Service creation in NestJS - Deep Dive

Overview - Service creation

What is it?

Service creation in NestJS means making a special class that holds the main logic of your app. These classes do tasks like talking to databases, processing data, or handling business rules. Services keep your code clean by separating the logic from the parts that show things on the screen or handle user input. They are easy to reuse and test because they focus on one job.

Why it matters

Without services, all the logic would be mixed with the code that handles user requests or shows data, making the app messy and hard to fix. Services help organize code so developers can work faster, find bugs easier, and add new features without breaking things. This makes apps more reliable and easier to grow over time.

Where it fits

Before learning service creation, you should understand basic TypeScript classes and how NestJS modules work. After mastering services, you can learn about dependency injection, providers, and how to connect services to databases or external APIs.

Mental Model

Core Idea

A service is a focused helper class that holds the app’s main logic, separate from how data is shown or received.

Think of it like...

Think of a service like a kitchen chef who prepares meals (logic) while waiters (controllers) take orders and serve food. The chef focuses on cooking, not on talking to customers.

┌───────────────┐      calls      ┌───────────────┐
│   Controller  │───────────────▶│    Service    │
└───────────────┘                └───────────────┘
       ▲                              │
       │                              │
       │                      business logic
       │                              │
       │                      data processing
       │                              │
       ▼                              ▼
  user input                   database/API

Build-Up - 7 Steps

1

Foundation

Understanding NestJS Service Basics

Concept: Learn what a service is and how to create a simple service class in NestJS.

In NestJS, a service is a TypeScript class decorated with @Injectable(). This decorator tells NestJS that this class can be managed and injected where needed. To create a service, you define a class and add methods that perform tasks. For example, a simple service might have a method that returns a greeting message.

Result

You get a reusable class that can be called from other parts of your app to perform specific tasks.

Understanding that services are just classes with special decorators helps you see how NestJS organizes logic cleanly and prepares for dependency injection.

2

Foundation

Connecting Services to Controllers

Concept: Learn how to use a service inside a controller to separate logic from request handling.

Controllers handle incoming requests and send responses. Instead of putting logic inside controllers, you inject the service into the controller's constructor. Then, you call service methods inside controller methods. This keeps controllers simple and focused on routing.

Result

Your controller calls the service to get data or perform actions, keeping code organized.

Knowing how to inject services into controllers is key to clean architecture and makes your app easier to maintain.

3

Intermediate

Using Dependency Injection for Services

🤔Before reading on: do you think you must manually create service instances in controllers or does NestJS handle it? Commit to your answer.

Concept: Learn how NestJS automatically provides service instances using dependency injection (DI).

NestJS uses DI to create and share service instances. When you add a service to a module's providers array, NestJS knows how to create it. Then, when a controller asks for the service in its constructor, NestJS gives the same instance. This avoids manual creation and helps manage shared state or resources.

Result

Services are automatically created and shared by NestJS, simplifying code and improving efficiency.

Understanding DI shows how NestJS manages object lifecycles and dependencies behind the scenes, making your code cleaner and more testable.

4

Intermediate

Organizing Services with Modules

🤔Before reading on: do you think services can be used anywhere without declaring them in modules? Commit to your answer.

Concept: Learn how to register services in modules to control their scope and availability.

In NestJS, modules group related controllers and services. You add services to the providers array of a module. Only modules that import this module can use its services. This helps organize large apps by keeping services scoped and avoiding conflicts.

Result

Services are neatly grouped and only available where needed, improving app structure.

Knowing module boundaries helps you design scalable apps and avoid accidental service misuse.

5

Intermediate

Creating Custom Service Methods

Concept: Learn how to add meaningful methods to services that perform real tasks.

Services can have any methods you want. For example, a UserService might have methods like createUser(), findUserById(), or updateUser(). These methods contain the logic to handle data, validate inputs, or call databases. You keep controllers simple by moving all this logic into services.

Result

Your app logic lives in services, making it reusable and testable.

Building rich service methods teaches you to separate concerns and write maintainable code.

6

Advanced

Singleton Nature and State in Services

🤔Before reading on: do you think each controller gets a new service instance or the same one? Commit to your answer.

Concept: Learn that services are singletons by default, meaning one instance is shared across the app.

NestJS creates one instance of each service per module by default. This means if you store data in a service property, it is shared across all users and requests. This is useful for caching or shared state but can cause bugs if you store user-specific data here.

Result

You understand when to use service properties and when to avoid them to prevent bugs.

Knowing the singleton behavior prevents common mistakes with shared state and helps design safe services.

7

Expert

Custom Providers and Service Factories

🤔Before reading on: do you think services must always be simple classes or can they be created dynamically? Commit to your answer.

Concept: Learn how to create services using custom providers and factory functions for advanced scenarios.

Sometimes you want to create a service instance dynamically or with special setup. NestJS allows custom providers where you define how to create the service using a factory function. This lets you inject configuration, create different instances, or wrap existing libraries as services.

Result

You can build flexible, configurable services that adapt to complex needs.

Understanding custom providers unlocks powerful patterns for real-world apps that need dynamic behavior or external integrations.

Under the Hood

NestJS uses a dependency injection container that scans modules for providers (services). When the app starts, it creates instances of these providers and keeps them in a registry. When a controller or another provider requests a service, NestJS returns the existing instance from the registry. This container manages lifecycles and dependencies automatically, so you don't manually create or pass service instances.

Why designed this way?

This design follows the principle of separation of concerns and inversion of control. By letting NestJS manage service creation, developers write cleaner code without worrying about object lifetimes or dependencies. It also enables easier testing and modularity. Alternatives like manual instantiation were rejected because they lead to tightly coupled, hard-to-maintain code.

┌───────────────┐       registers       ┌───────────────┐
│   Module A    │──────────────────────▶│  DI Container │
└───────────────┘                       └───────────────┘
       ▲                                      │
       │ injects                              │ provides
       │                                      ▼
┌───────────────┐       requests       ┌───────────────┐
│ Controller A  │────────────────────▶│   Service A   │
└───────────────┘                      └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think each controller gets a new service instance every time? Commit to yes or no.

Common Belief: Each controller creates its own separate service instance.

Reality: Services are singletons by default, so all controllers share the same service instance within a module.

Why it matters: Assuming separate instances can cause bugs when you rely on shared state or expect isolated data.

Quick: Can you use a service without adding it to a module's providers? Commit to yes or no.

Common Belief: You can use any service anywhere without declaring it in a module.

Reality: Services must be registered in a module's providers array to be injectable and usable.

Why it matters: Not registering services leads to runtime errors and broken dependency injection.

Quick: Do you think services should handle HTTP requests directly? Commit to yes or no.

Common Belief: Services can handle HTTP requests and responses directly.

Reality: Controllers handle HTTP requests; services only contain business logic and data handling.

Why it matters: Mixing concerns makes code harder to maintain and test.

Quick: Can you create multiple instances of a service by default? Commit to yes or no.

Common Belief: By default, NestJS creates a new service instance every time it is injected.

Reality: NestJS creates one instance per provider per module (singleton), unless explicitly configured otherwise.

Why it matters: Misunderstanding this can cause unexpected shared state bugs or performance issues.

Expert Zone

1

Services can be scoped differently (e.g., request-scoped) to create new instances per request, which is useful for per-user data isolation.

2

Using custom providers allows injecting dynamic configuration or wrapping third-party libraries as services, enabling flexible architecture.

3

Circular dependencies between services can occur and must be handled carefully using forward references or refactoring to avoid runtime errors.

When NOT to use

Avoid using services to handle UI logic or direct HTTP responses; use controllers or middleware instead. For simple apps, overusing services can add unnecessary complexity. For cross-cutting concerns like logging or caching, consider using interceptors or middleware rather than services alone.

Production Patterns

In real apps, services often connect to databases via repositories or ORM layers, handle caching, and implement complex business rules. They are tested independently with mocks. Large apps split services into feature modules and use global modules for shared services like configuration or authentication.

Connections

Dependency Injection

Service creation builds on dependency injection to manage instances automatically.

Understanding services deepens your grasp of DI, showing how it simplifies object management and testing.

Single Responsibility Principle (SRP)

Services embody SRP by focusing on one area of logic, separating concerns from controllers.

Knowing SRP helps you design services that are easier to maintain and extend.

Factory Design Pattern

Custom providers and service factories in NestJS implement the factory pattern to create objects dynamically.

Recognizing this pattern helps you build flexible, configurable services in complex applications.

Common Pitfalls

#1 Storing user-specific data in service properties causing data leaks between users.

Wrong approach:

export class UserService {
currentUser = null;
setUser(user) { this.currentUser = user; }
getUser() { return this.currentUser; }
}

Correct approach:

export class UserService {
getUserFromRequest(request) {
return request.user;
}
}

Root cause:

Misunderstanding that services are singletons shared across all requests, so instance properties are shared.

#2 Forgetting to add the service to the module's providers array causing injection errors.

Wrong approach:

import { Injectable } from '@nestjs/common';

@Injectable()
export class MyService {}

// Module without providers
@Module({
controllers: [MyController],
})
export class MyModule {}

Correct approach:

import { Injectable } from '@nestjs/common';

@Injectable()
export class MyService {}

import { Module } from '@nestjs/common';
@Module({
controllers: [MyController],
providers: [MyService],
})
export class MyModule {}

Root cause:

Not understanding that NestJS needs services declared in providers to manage and inject them.

#3 Putting business logic inside controllers instead of services.

Wrong approach:

export class UserController {
getUser() {
// logic here
return { id: 1, name: 'Alice' };
}
}

Correct approach:

export class UserService {
getUser() {
return { id: 1, name: 'Alice' };
}
}

export class UserController {
constructor(private userService: UserService) {}
getUser() {
return this.userService.getUser();
}
}

Root cause:

Not separating concerns leads to hard-to-maintain and test code.

Key Takeaways

Services in NestJS are special classes that hold your app’s main logic, separate from controllers that handle requests.

NestJS uses dependency injection to create and share service instances automatically, making your code cleaner and easier to test.

Services are singletons by default, so be careful with storing state inside them to avoid shared data bugs.

Registering services in modules controls their scope and availability, helping organize large applications.

Advanced patterns like custom providers let you create flexible, dynamic services for real-world complex needs.