Comment fonctionne l'injection de dépendances dans NestJS ?

Question

Accepted Answer

**Dependency Injection (DI)** est un motif fondamental de NestJS où le framework **crée automatiquement et fournit** les dépendances dont une classe a besoin, au lieu que la classe les construise elle-même. Vous déclarez ce dont vous avez besoin dans le constructeur, et NestJS le fournit — ce qui conduit à un code faiblement couplé et testable.

## Comment ça fonctionne : déclarer dans le constructeur

```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 lit les types de paramètres du constructeur, cherche les fournisseurs enregistrés correspondants, les crée (s'ils ne sont pas déjà présents), et les passe — résolvant automatiquement tout le graphe de dépendances.

## Le flux DI

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

## Enregistrement et résolution

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

## Pourquoi DI est précieux

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

## Testabilité — l'avantage majeur

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

Parce que la classe ne construit pas ses dépendances, vous pouvez injecter des mocks pour tester — DI rend les applications NestJS très testables.

## Injecter des valeurs non-classe

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

## Pourquoi c'est important

L'injection de dépendances est le motif fondateur qui soutient toute l'architecture de NestJS — c'est comment les contrôleurs obtiennent les services, les services obtiennent les référentiels et les autres services, et comment l'ensemble de l'application est connecté.

La comprendre est essentiel car presque chaque classe NestJS participe à DI : vous déclarez les dépendances dans le constructeur et le conteneur IoC du framework les résout et les fournit automatiquement, éliminant l'instanciation manuelle et le couplage étroit.

Les avantages sont significatifs et centraux à la raison pour laquelle NestJS est apprécié : **couplage faible** (dépendre d'abstractions), **testabilité** (injecter des mocks à la place des vraies dépendances — ce qui rend les tests unitaires approfondis faciles), réutilisabilité (singletons partagés), et maintenabilité.

DI est emprunté à des frameworks comme Angular et Spring, et le maîtriser — comment déclarer, enregistrer, injecter, et mocker les dépendances — est nécessaire pour construire des applications NestJS bien structurées et testables, et est l'un des concepts les plus importants à comprendre en profondeur dans le framework.