Constructor injection in NestJS - Deep Dive

Overview - Constructor injection

What is it?

Constructor injection is a way to give a class the things it needs to work by passing them in when the class is created. In NestJS, this means putting the needed services or objects as parameters in the class constructor. The framework then automatically provides these dependencies when it makes the class. This helps keep code organized and easy to change.

Why it matters

Without constructor injection, classes would have to find or create their own dependencies, making the code messy and hard to test. Constructor injection solves this by clearly showing what a class needs and letting the framework handle the setup. This makes apps easier to build, maintain, and test, especially as they grow bigger.

Where it fits

Before learning constructor injection, you should understand basic TypeScript classes and how NestJS modules and providers work. After mastering constructor injection, you can learn about other dependency injection patterns in NestJS like property injection or factory providers, and advanced topics like scopes and lifecycle hooks.

Mental Model

Core Idea

Constructor injection means giving a class its needed parts right when it is created, so it can work without searching for them later.

Think of it like...

It's like giving a chef all the ingredients and tools they need before they start cooking, instead of making them find everything in the kitchen while cooking.

┌─────────────────────────────┐
│        Class (Service)      │
│ ┌─────────────────────────┐ │
│ │ constructor(dependency) │ │
│ └─────────────────────────┘ │
│           │                 │
│           ▼                 │
│  Dependency provided by     │
│  NestJS Dependency Injector │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Constructors

Concept: Learn what classes and constructors are in TypeScript, the basics needed to understand constructor injection.

A class is like a blueprint for creating objects. A constructor is a special method inside a class that runs when you create a new object. It can take parameters to set up the object with needed data or parts.

Result

You can create objects with initial values by passing arguments to the constructor.

Understanding constructors is essential because constructor injection uses this exact mechanism to pass dependencies into classes.

2

Foundation

What is Dependency Injection?

Concept: Introduce the idea of dependency injection as a way to supply objects with what they need from outside rather than creating them inside.

Dependency injection means giving an object the things it needs (dependencies) from outside instead of making it create or find them itself. This helps keep code clean and easy to change.

Result

You see that dependencies are managed outside the class, making the class simpler and more focused.

Knowing dependency injection helps you understand why constructor injection is used and how it improves code design.

3

Intermediate

Constructor Injection in NestJS Basics

🤔Before reading on: do you think NestJS automatically creates dependencies if you list them in the constructor, or do you have to create them manually? Commit to your answer.

Concept: Learn how NestJS uses constructor parameters to automatically provide dependencies when creating a class instance.

In NestJS, when you add a provider (like a service) as a parameter in a class constructor, the framework automatically finds or creates that provider and passes it in. This is called constructor injection. You just declare what you need, and NestJS handles the rest.

Result

Your class receives the needed services without manual setup, ready to use them.

Understanding that NestJS handles dependency creation and injection automatically through constructors simplifies how you build and connect parts of your app.

4

Intermediate

Using @Injectable and Providers Together

🤔Before reading on: do you think a class must be marked with @Injectable to receive constructor injection in NestJS? Commit to yes or no.

Concept: Learn the role of the @Injectable decorator and how providers are registered to enable constructor injection.

In NestJS, classes that want to receive dependencies via constructor injection must be marked with @Injectable. This tells NestJS they can be managed by the dependency injection system. Also, these classes must be registered as providers in a module so NestJS knows to create and inject them.

Result

Classes properly marked and registered receive their dependencies automatically.

Knowing the need for @Injectable and provider registration prevents common errors where dependencies are undefined or injection fails.

5

Intermediate

Injecting Custom Services via Constructor

🤔Before reading on: do you think you can inject any class via constructor if it’s not registered as a provider? Commit to yes or no.

Concept: Learn how to inject your own services by registering them as providers and listing them in constructors.

To inject a custom service, first create the service class and mark it with @Injectable. Then add it to the providers array of a module. Finally, list it as a parameter in the constructor of the class that needs it. NestJS will inject the instance automatically.

Result

Your classes can use custom services without manual creation or wiring.

Understanding this flow is key to building modular and testable NestJS applications.

6

Advanced

Handling Circular Dependencies in Constructor Injection

🤔Before reading on: do you think circular dependencies cause runtime errors or are handled silently by NestJS? Commit to your answer.

Concept: Learn what happens when two providers depend on each other and how to resolve this in NestJS.

Circular dependencies happen when Service A needs Service B, and Service B also needs Service A. This can cause errors or infinite loops. NestJS provides ways to fix this, like using forwardRef() to tell the framework about the circular link so it can resolve dependencies properly.

Result

You can safely inject dependencies even when they depend on each other, avoiding crashes.

Knowing how to handle circular dependencies prevents hard-to-debug runtime errors in complex apps.

7

Expert

Behind the Scenes: NestJS Dependency Injection Container

🤔Before reading on: do you think NestJS creates a new instance of a provider every time it’s injected, or reuses one? Commit to your answer.

Concept: Understand how NestJS manages provider instances and injects them using a container and scopes.

NestJS uses a dependency injection container that keeps track of all providers. By default, it creates one instance per provider (singleton) and reuses it wherever injected. The container resolves dependencies recursively and supports scopes like transient or request-scoped providers for different lifetimes.

Result

You grasp how NestJS efficiently manages instances and injection lifecycles.

Understanding the container and scopes helps you design providers with correct lifetimes and avoid bugs related to shared or recreated instances.

Under the Hood

NestJS builds a dependency injection container at runtime that holds all registered providers. When a class with constructor parameters is instantiated, the container looks up each parameter's type and provides the corresponding instance. It uses metadata from TypeScript and decorators to know what to inject. Providers are usually singletons unless scoped differently. The container resolves dependencies recursively, creating a tree of instances.

Why designed this way?

This design allows clear separation of concerns, automatic wiring of dependencies, and easy testing. It avoids manual creation and passing of dependencies, reducing boilerplate and errors. The container pattern is a proven approach in many frameworks, chosen for its flexibility and efficiency. Alternatives like service locators were rejected because they hide dependencies and make testing harder.

┌───────────────────────────────┐
│       Dependency Injection    │
│           Container           │
│ ┌───────────────┐ ┌─────────┐│
│ │ Provider A    │ │Provider B││
│ └───────────────┘ └─────────┘│
│           ▲           ▲       │
│           │           │       │
│  ┌─────────────────────────┐ │
│  │ Class with constructor   │ │
│  │ injection (Service C)   │ │
│  └─────────────────────────┘ │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does NestJS create a new instance of a provider every time it’s injected? Commit to yes or no.

Common Belief: Many think NestJS creates a new instance of a provider each time it’s injected.

Reality: By default, NestJS creates a single instance (singleton) of each provider and reuses it wherever injected.

Why it matters: Believing otherwise can lead to unnecessary resource use or bugs when expecting fresh instances but getting shared ones.

Quick: Can you inject a class via constructor without marking it @Injectable? Commit to yes or no.

Common Belief: Some believe any class can be injected if listed in the constructor.

Reality: Only classes marked with @Injectable and registered as providers can be injected by NestJS.

Why it matters: Not marking classes properly causes runtime errors where dependencies are undefined.

Quick: Does constructor injection mean the class creates its own dependencies? Commit to yes or no.

Common Belief: Some think constructor injection means the class still creates its dependencies inside.

Reality: Constructor injection means dependencies are provided from outside, not created inside the class.

Why it matters: Misunderstanding this leads to tightly coupled code that is hard to test and maintain.

Quick: Does NestJS automatically resolve circular dependencies without extra work? Commit to yes or no.

Common Belief: Many assume NestJS handles circular dependencies automatically without configuration.

Reality: Circular dependencies require explicit handling using forwardRef() to avoid errors.

Why it matters: Ignoring this causes runtime crashes and hard-to-debug issues in complex apps.

Expert Zone

1

Constructor injection in NestJS relies on TypeScript's metadata reflection, which requires enabling emitDecoratorMetadata and experimentalDecorators in tsconfig.

2

Providers can have different scopes (singleton, transient, request), affecting how constructor injection behaves and when new instances are created.

3

Using forwardRef() to resolve circular dependencies changes how NestJS delays provider resolution, which can affect initialization order and lifecycle hooks.

When NOT to use

Constructor injection is not suitable when dependencies need to be optional or decided at runtime dynamically; in such cases, use property injection or factory providers. Also, for very large dependency graphs with complex cycles, consider redesigning to reduce coupling.

Production Patterns

In real-world NestJS apps, constructor injection is used to build modular services, controllers, and repositories. Experts use scopes to manage lifetimes, forwardRef() for circular dependencies, and custom providers for dynamic injection. Testing uses constructor injection to easily mock dependencies.

Connections

Inversion of Control (IoC)

Constructor injection is a specific way to implement IoC by letting an external system provide dependencies.

Understanding IoC clarifies why constructor injection improves modularity and testability by reversing who controls dependency creation.

Factory Design Pattern

Constructor injection often works with factories that create dependencies before injection.

Knowing factories helps understand how complex or dynamic dependencies can be created and injected cleanly.

Human Teamwork and Delegation

Constructor injection is like delegating tasks to team members who come prepared with their tools.

Seeing software dependencies as teamwork helps grasp why clear roles and prepared inputs lead to smoother collaboration and fewer errors.

Common Pitfalls

#1 Forgetting to mark a class with @Injectable causes injection failure.

Wrong approach:

export class MyService {
constructor(private readonly dep: OtherService) {}
}

Correct approach:

@Injectable()
export class MyService {
constructor(private readonly dep: OtherService) {}
}

Root cause:

NestJS only injects dependencies into classes marked with @Injectable to know they participate in DI.

#2 Not registering a provider in a module leads to undefined dependencies.

Wrong approach:

@Injectable()
export class MyService {}

// Module missing MyService in providers array

Correct approach:

@Injectable()
export class MyService {}

@Module({
providers: [MyService],
})
export class AppModule {}

Root cause:

NestJS must know about providers via module registration to create and inject them.

#3 Creating circular dependencies without forwardRef causes runtime errors.

Wrong approach:

@Injectable()
export class ServiceA {
constructor(private serviceB: ServiceB) {}
}

@Injectable()
export class ServiceB {
constructor(private serviceA: ServiceA) {}
}

Correct approach:

@Injectable()
export class ServiceA {
constructor(@Inject(forwardRef(() => ServiceB)) private serviceB: ServiceB) {}
}

@Injectable()
export class ServiceB {
constructor(@Inject(forwardRef(() => ServiceA)) private serviceA: ServiceA) {}
}

Root cause:

NestJS needs forwardRef to resolve circular dependencies by delaying provider resolution.

Key Takeaways

Constructor injection in NestJS means passing dependencies to a class through its constructor, letting the framework provide them automatically.

Classes must be marked with @Injectable and registered as providers in modules to participate in constructor injection.

NestJS uses a dependency injection container that manages provider instances, usually as singletons, and injects them where needed.

Handling circular dependencies requires special care using forwardRef to avoid runtime errors.

Constructor injection improves code modularity, testability, and maintainability by clearly defining and managing dependencies.