How does dependency injection work in NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** is a core NestJS pattern where the framework **automatically creates and provides** the dependencies a class needs, rather than the class constructing them itself. You declare what you need in the constructor, and NestJS supplies it — leading to loosely-coupled, testable code.

## How it works: declare in the constructor

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest reads the constructor's parameter types, looks up the corresponding registered providers, creates them (if not already), and passes them in — automatically resolving the whole dependency graph.

## The DI flow

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## Registration and resolution

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## Why DI is valuable

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## Testability — the killer benefit

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

Because the class doesn't construct its dependencies, you can swap in mocks for testing — DI makes NestJS apps highly testable.

## Injecting non-class values

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## Why it matters

Dependency injection is the foundational pattern underpinning NestJS's entire architecture — it's how controllers get services, services get repositories and other services, and the whole application is wired together.

Understanding it is essential because nearly every NestJS class participates in DI: you declare dependencies in the constructor and the framework's IoC container resolves and provides them automatically, eliminating manual instantiation and tight coupling.

The benefits are significant and central to why NestJS is valued: **loose coupling** (depend on abstractions), **testability** (inject mocks instead of real dependencies — making thorough unit testing easy), reusability (shared singletons), and maintainability.

DI is borrowed from frameworks like Angular and Spring, and mastering it — how to declare, register, inject, and mock dependencies — is necessary for building well-structured, testable NestJS applications and is one of the most important concepts to understand deeply in the framework.