Dependency Injection

Use NestJS 11's DI container for scopes, custom providers, and testable service wiring.

Recipe

Quick-reference recipe card - copy-paste ready.

import { Module, Injectable, Inject } from "@nestjs/common";
 
@Injectable()
export class UsersRepository {
  findById(id: string) { return { id, name: "Ada" }; }
}
 
@Injectable()
export class UsersService {
  constructor(private readonly repo: UsersRepository) {}
 
  getUser(id: string) {
    return this.repo.findById(id);
  }
}
 
@Module({
  providers: [UsersRepository, UsersService],
  exports: [UsersService],
})
export class UsersModule {}

When to reach for this: Any NestJS service that depends on another service, repository, or external client.

Working Example

import { Module, Injectable, Inject } from "@nestjs/common";
import { Test } from "@nestjs/testing";
 
// Interface token for swappable implementations
export const EMAIL_SENDER = Symbol("EMAIL_SENDER");
 
export interface EmailSender {
  send(to: string, subject: string): Promise<void>;
}
 
@Injectable()
export class SmtpEmailSender implements EmailSender {
  async send(to: string, subject: string) {
    console.log(`Sending to ${to}: ${subject}`);
  }
}
 
@Injectable()
export class UsersService {
  constructor(
    @Inject(EMAIL_SENDER) private readonly email: EmailSender,
  ) {}
 
  async register(email: string) {
    await this.email.send(email, "Welcome!");
    return { email };
  }
}
 
@Module({
  providers: [
    UsersService,
    { provide: EMAIL_SENDER, useClass: SmtpEmailSender },
  ],
})
export class UsersModule {}
 
// Test override
const testModule = await Test.createTestingModule({
  imports: [UsersModule],
})
  .overrideProvider(EMAIL_SENDER)
  .useValue({ send: async () => {} })
  .compile();

What this demonstrates:

• Constructor injection of services
• Custom provider tokens with Symbol
• useClass for interface-to-implementation binding
• overrideProvider for test doubles

Deep Dive

How It Works

• NestJS creates a DI container at bootstrap
• @Injectable() registers a class as a provider
• Constructor parameter types determine what to inject
• Container resolves dependency graph before serving requests

Provider Scopes

@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  userId?: string;
}

Custom Provider Patterns

Gotchas

• Circular dependencies - A injects B injects A. Fix: forwardRef(() => B) or refactor shared logic to a third service.
• Request-scoped in singleton - injecting request service into singleton fails. Fix: use ModuleRef or make the consumer request-scoped too.
• Forgetting exports - service not available in importing module. Fix: add to exports array.
• Manual new Service() - bypasses DI and testability. Fix: always inject via constructor.
• Too many providers in one module - god module anti-pattern. Fix: split into feature modules.
• Not overriding in tests - tests hit real database. Fix: overrideProvider or useValue mock.

Alternatives

FAQs

Related

• NestJS Basics - module structure
• Guards, Interceptors & Pipes - injectable cross-cutting
• NestJS + Prisma/TypeORM - data layer DI
• Dependency Injection Patterns - framework-agnostic DI
• NestJS Best Practices - section checklist

External Related Links

• NestJS Documentation - Progressive Node.js framework docs.
• Node.js Best Practices (GitHub) - Curated production best practices.
• DEV Community – Node.js - Community articles and discussions.
• Node.js Design Patterns, 4th Edition - Production-grade application patterns.
• Node.js Design Patterns (author site) - Author site for Design Patterns.

Stack versions: This page was written for Node.js 24.18.0 (Active LTS), npm 10+, TypeScript 5.6+, Express 5, Fastify 5, and NestJS 11.