Injecter un service dans un contrôleur

Le constructeur avant tout ; les autres formes pour des cas particuliers.

1. L'injection par le constructeur

C'est la forme normale, utilisée dans 99 % des cas. Vous la connaissez depuis le chapitre 03 :

@Controller('stagiaires')
export class StagiairesController {
  constructor(
    private readonly stagiairesService: StagiairesService,
    private readonly notesService: NotesService,
  ) {}
}

• private: la propriété n'est utilisée qu'à l'intérieur du contrôleur.
• readonly: elle ne sera jamais réaffectée (le compilateur l'interdit).
• L'ordre des paramètres n'a pas d'importance pour NestJS, qui se fie aux types.
• Le type doit être une classe (ou un jeton avec @Inject, leçon 7.4) : une interface disparaît à la compilation.

Un contrôleur qui utilise les autres formes

📄 src/services.ts

import { Injectable } from '@nestjs/common';

@Injectable()
export class GroupesService {
  findAll() {
    return ['DEV101', 'DEV102'];
  }
}

@Injectable()
export class JournalService {
  private lignes: string[] = [];
  ecrire(message: string) {
    this.lignes.push(message);
  }
  get nombre() {
    return this.lignes.length;
  }
}

@Injectable()
export class StatistiquesService {
  calculer() {
    return { groupes: 2 };
  }
}

📄 src/groupes.controller.ts

import { Controller, Get, Inject, Optional } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
import { GroupesService, JournalService, StatistiquesService } from './services';

class CacheService {}   // n'est déclaré dans aucun module

@Controller('groupes')
export class GroupesController {
  // 2. Injection par propriété (rare : réservée aux cas d'héritage)
  @Inject(JournalService)
  private readonly journal: JournalService;

  // 1. Injection par le constructeur (la forme normale)
  constructor(
    private readonly groupesService: GroupesService,
    @Optional() private readonly cache?: CacheService,      // 3. dépendance facultative
    private readonly moduleRef?: ModuleRef,                  // 4. accès programmatique au conteneur
  ) {}

  @Get()
  findAll() {
    this.journal.ecrire('liste des groupes');
    return {
      groupes: this.groupesService.findAll(),
      cacheDisponible: this.cache !== undefined,
      lignesJournal: this.journal.nombre,
    };
  }

  @Get('statistiques')
  statistiques() {
    const stats = this.moduleRef!.get(StatistiquesService);  // obtenu à la demande
    return stats.calculer();
  }
}

Réponses obtenues :

GET /api/groupes → 200 {"groupes":["DEV101","DEV102"],"cacheDisponible":false,"lignesJournal":1}
GET /api/groupes → 200 {"groupes":["DEV101","DEV102"],"cacheDisponible":false,"lignesJournal":2}
GET /api/groupes/statistiques → 200 {"groupes":2}

2. L'injection par propriété

@Inject(JournalService) sur une propriété demande à NestJS de la remplir après la création de l'objet. Le compteur lignesJournal qui passe de 1 à 2 montre que le journal (un singleton) a bien été injecté. Cette forme est déconseillée en général : la dépendance n'apparaît pas dans le constructeur, et la propriété n'est pas disponible pendant celui-ci. Elle est utile dans un cas précis : une classe de base héritée par plusieurs classes, pour éviter que chaque classe fille répète le super(…) avec toutes les dépendances.

3. Les dépendances facultatives

CacheService n'est déclaré dans aucun module. Sans @Optional(), l'application refuserait de démarrer (« Nest can't resolve dependencies… »). Avec, NestJS injecte undefined: la réponse indique cacheDisponible: false. Le code doit alors tester la présence (this.cache?.lire(…)).

4. ModuleRef : obtenir un provider à la demande

ModuleRef (de @nestjs/core) est le conteneur lui-même, injectable comme n'importe quel provider. moduleRef.get(Classe) renvoie l'instance d'un provider du module. C'est utile quand le provider à utiliser n'est connu qu'à l'exécution (choisir un service selon un paramètre), mais à éviter quand l'injection classique suffit : la dépendance devient invisible.

// Exemple d'usage légitime : choisir une stratégie à l'exécution
@Injectable()
export class ExportService {
  constructor(private readonly moduleRef: ModuleRef) {}

  exporter(format: 'pdf' | 'csv', donnees: unknown[]) {
    const generateur = format === 'pdf' ? this.moduleRef.get(ExportPdf) : this.moduleRef.get(ExportCsv);
    return generateur.generer(donnees);
  }
}

Erreurs courantes

Activités

@Injectable()
export class NotesService {
  constructor(
    private readonly stagiairesService: StagiairesService,
    @Optional() private readonly notifications?: NotificationsService,
  ) {}

  ajouter(stagiaireId: number, matiere: string, valeur: number) {
    // … enregistrement …
    this.notifications?.envoyer(stagiaireId, `Nouvelle note en ${matiere} : ${valeur}`);
    return note;
  }
}

@Controller('stagiaires')
export class StagiairesController {
  constructor(private readonly stagiairesService: StagiairesService) {}

  @Get('noms')
  noms() {
    return this.stagiairesService.findAll().map(this.formater);
  }

  formater(s: Stagiaire) {
    return this.stagiairesService.nomComplet(s);
  }
}