Les modules NestJS (@Module : imports, controllers, providers, exports)

Les quatre propriétés de @Module

Retenez la règle d'or : un provider est privé à son module. Pour l'utiliser ailleurs, il faut à la fois qu'il soit exporté par son module et que ce module soit importé là où on l'utilise.

StagiairesModule importe GroupesModule : il voit GroupesService (exporté) mais pas CodesService (privé).

Un exemple complet : groupes et stagiaires

Un stagiaire appartient à un groupe. La route GET /api/stagiaires/:id doit renvoyer le stagiaire avec le détail de son groupe, fourni par GroupesService. Générez la structure :

nest g mo groupes
nest g co groupes --no-spec
nest g s groupes --no-spec
nest g s groupes/codes --flat --no-spec
nest g mo stagiaires
nest g co stagiaires --no-spec
nest g s stagiaires --no-spec

Le module des groupes: un service interne (CodesService), un service exporté (GroupesService) et un contrôleur.

📄 src/groupes/codes.service.ts

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

@Injectable()
export class CodesService {          // service interne : NON exporté
  normaliser(code: string): string {
    return code.trim().toUpperCase();
  }
}

📄 src/groupes/groupes.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { CodesService } from './codes.service';

export interface Groupe {
  code: string;
  filiere: string;
}

@Injectable()
export class GroupesService {
  private groupes: Groupe[] = [
    { code: 'DEV101', filiere: 'Développement digital' },
    { code: 'DEV102', filiere: 'Développement digital' },
  ];

  constructor(private readonly codes: CodesService) {}

  findAll(): Groupe[] {
    return this.groupes;
  }

  findOne(code: string): Groupe {
    const g = this.groupes.find((x) => x.code === this.codes.normaliser(code));
    if (!g) throw new NotFoundException(`Groupe ${code} introuvable`);
    return g;
  }
}

📄 src/groupes/groupes.controller.ts

import { Controller, Get, Param } from '@nestjs/common';
import { GroupesService } from './groupes.service';

@Controller('groupes')
export class GroupesController {
  constructor(private readonly groupesService: GroupesService) {}

  @Get()
  findAll() {
    return this.groupesService.findAll();
  }

  @Get(':code')
  findOne(@Param('code') code: string) {
    return this.groupesService.findOne(code);
  }
}

📄 src/groupes/groupes.module.ts

import { Module } from '@nestjs/common';
import { CodesService } from './codes.service';
import { GroupesController } from './groupes.controller';
import { GroupesService } from './groupes.service';

@Module({
  controllers: [GroupesController],
  providers: [GroupesService, CodesService],
  exports: [GroupesService],          // seul GroupesService est visible à l'extérieur
})
export class GroupesModule {}

Le module des stagiaires importe GroupesModule pour pouvoir injecter GroupesService:

📄 src/stagiaires/stagiaires.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { GroupesService } from '../groupes/groupes.service';

@Injectable()
export class StagiairesService {
  private stagiaires = [
    { id: 1, nom: 'Ben Ali', groupe: 'DEV101' },
    { id: 2, nom: 'Mansouri', groupe: 'DEV102' },
  ];

  constructor(private readonly groupesService: GroupesService) {}   // vient de GroupesModule

  findOne(id: number) {
    const s = this.stagiaires.find((x) => x.id === id);
    if (!s) throw new NotFoundException(`Stagiaire ${id} introuvable`);
    return { ...s, groupe: this.groupesService.findOne(s.groupe) };   // groupe détaillé
  }
}

📄 src/stagiaires/stagiaires.controller.ts

import { Controller, Get, Param } from '@nestjs/common';
import { StagiairesService } from './stagiaires.service';

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

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.stagiairesService.findOne(Number(id));
  }
}

📄 src/stagiaires/stagiaires.module.ts

import { Module } from '@nestjs/common';
import { GroupesModule } from '../groupes/groupes.module';
import { StagiairesController } from './stagiaires.controller';
import { StagiairesService } from './stagiaires.service';

@Module({
  imports: [GroupesModule],           // pour pouvoir injecter GroupesService
  controllers: [StagiairesController],
  providers: [StagiairesService],
})
export class StagiairesModule {}

📄 src/app.module.ts

import { Module } from '@nestjs/common';
import { GroupesModule } from './groupes/groupes.module';
import { StagiairesModule } from './stagiaires/stagiaires.module';

@Module({
  imports: [GroupesModule, StagiairesModule],
})
export class AppModule {}

Avec le préfixe global api (leçon 3.3), voici les réponses réellement obtenues :

Réponses de l'API :

GET /api/groupes → 200 [{"code":"DEV101","filiere":"Développement digital"},{"code":"DEV102","filiere":"Développement digital"}]
GET /api/groupes/dev102 → 200 {"code":"DEV102","filiere":"Développement digital"}
GET /api/stagiaires/1 → 200 {"id":1,"nom":"Ben Ali","groupe":{"code":"DEV101","filiere":"Développement digital"}}
GET /api/stagiaires/7 → 404 {"message":"Stagiaire 7 introuvable","error":"Not Found","statusCode":404}

Observez : dev102 en minuscules fonctionne grâce à CodesService, utilisé à l'intérieur de GroupesModule ; le stagiaire 1 est renvoyé avec l'objet groupe complet ; l'exception NotFoundException levée dans le service devient automatiquement une réponse 404.

Lire l'erreur de dépendance

Supprimez imports: [GroupesModule] de StagiairesModule et relancez. L'application refuse de démarrer :

Erreur au démarrage :

Nest can't resolve dependencies of the StagiairesService (?). Please make sure that the argument GroupesService at index [0] is available in the StagiairesModule module.

Potential solutions:
- Is StagiairesModule a valid NestJS module?
- If GroupesService is a provider, is it part of the current StagiairesModule?
- If GroupesService is exported from a separate @Module, is that module imported within StagiairesModule?
  @Module({
    imports: [ /* the Module containing GroupesService */ ]
  })

Ce message, que vous rencontrerez souvent, se lit ainsi :

• StagiairesService (?): la classe qui n'a pas pu être créée ; le ? marque le paramètre introuvable (s'il y en a plusieurs : (JournalService, ?)).
• GroupesService at index [0]: la dépendance manquante et sa position dans le constructeur.
• in the StagiairesModule module: le module dans lequel NestJS l'a cherchée.

Trois causes possibles, à vérifier dans l'ordre : le provider n'est déclaré nulle part ; il est déclaré dans un autre module qui ne l'exporte pas ; le module qui l'exporte n'est pas importé.

Réexporter un module

Un module peut exporter un module qu'il importe. Ceux qui l'importent reçoivent alors aussi les exports du module réexporté :

@Module({
  imports: [GroupesModule, FormationsModule],
  exports: [GroupesModule, FormationsModule],   // réexportation
})
export class ReferentielModule {}

// Ailleurs : un seul import donne accès à GroupesService ET FormationsService
@Module({ imports: [ReferentielModule], providers: [InscriptionsService] })
export class InscriptionsModule {}

Injecter dans la classe d'un module

La classe d'un module peut elle aussi recevoir des providers dans son constructeur, par exemple pour une configuration au démarrage :

@Module({ providers: [GroupesService, CodesService], exports: [GroupesService] })
export class GroupesModule {
  constructor(private readonly groupesService: GroupesService) {
    console.log(`GroupesModule : ${groupesService.findAll().length} groupes disponibles`);
  }
}

Activités