Hoe werkt dependency injection in NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** is een kernpatroon van NestJS waarbij het framework **automatisch de afhankelijkheden aanmaakt en levert** die een klasse nodig heeft, in plaats van dat de klasse ze zelf construeert. Je declareert wat je nodig hebt in de constructor, en NestJS levert het — wat leidt tot losjes gekoppelde, testbare code.

## Waarom het belangrijk is: declareer in de 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 leest de parametertypen van de constructor, zoekt de overeenkomstige geregistreerde providers op, maakt ze aan (als ze nog niet bestaan) en geeft ze door — waarbij de hele afhankelijkheidsgrafiek automatisch wordt opgelost.

## De 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
```

## Registratie en resolutie

```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
```

## Waarom DI waardevol is

```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)
```

## Testbaarheid — het voornaamste voordeel

```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();
```

Omdat de klasse zijn afhankelijkheden niet construeert, kun je mocks voor testen injecteren — DI maakt NestJS-apps zeer testbaar.

## Non-class waarden injecteren

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

## Waarom het belangrijk is

Dependency injection is het fundamentele patroon dat de gehele architectuur van NestJS ondersteunt — het is hoe controllers services krijgen, services repositories en andere services krijgen, en hoe de hele applicatie in elkaar wordt gezet.

Het begrijpen ervan is essentieel omdat vrijwel elke NestJS-klasse deelneemt aan DI: je declareert afhankelijkheden in de constructor en de IoC-container van het framework lost ze automatisch op en levert ze, wat handmatige instantiatie en strakke koppeling elimineert.

De voordelen zijn significant en centraal voor de reden waarom NestJS wordt gewaardeerd: **losse koppeling** (afhangen van abstracties), **testbaarheid** (mocks injecteren in plaats van echte afhankelijkheden — waardoor grondige unit testen gemakkelijk zijn), herbruikbaarheid (gedeelde singletons) en onderhoudbaarheid.

DI is overgenomen van frameworks zoals Angular en Spring, en het beheersen ervan — hoe je afhankelijkheden declareert, registreert, injecteert en mockt — is nodig voor het bouwen van goed gestructureerde, testbare NestJS-applicaties en is een van de belangrijkste concepten om diep te begrijpen in het framework.