Modules partagés, modules globaux et modules dynamiques

Trois façons de réutiliser un module, du plus courant au plus avancé.

1. Le module partagé

Dans NestJS, tout module est partagé par nature : dès qu'il exporte un provider, plusieurs modules peuvent l'importer. Point essentiel : ils reçoivent la même instance. Démonstration avec un compteur placé dans un CommonModule importé par deux modules :

📄 src/common/compteur.service.ts

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

@Injectable()
export class CompteurService {
  private readonly creeLe = new Date().toISOString();
  private total = 0;
  incrementer(source: string): string {
    this.total++;
    return `${source} → total ${this.total} (instance créée à ${this.creeLe.slice(11, 23)})`;
  }
}

📄 src/common/common.module.ts

import { Module } from '@nestjs/common';
import { CompteurService } from './compteur.service';

@Module({
  providers: [CompteurService],
  exports: [CompteurService],
})
export class CommonModule {}

📄 src/groupes/groupes.module.ts

import { Controller, Get, Module } from '@nestjs/common';
import { CommonModule } from '../common/common.module';
import { CompteurService } from '../common/compteur.service';

@Controller('groupes')
export class GroupesController {
  constructor(private readonly compteur: CompteurService) {}

  @Get()
  findAll() {
    return { visite: this.compteur.incrementer('groupes') };
  }
}

@Module({ imports: [CommonModule], controllers: [GroupesController] })
export class GroupesModule {}

Le module des stagiaires (ci-dessous, partie 3) importe lui aussi CommonModule. Résultat réel de trois requêtes :

Réponses :

GET /stagiaires → {"entete":"Institut de formation de Tunis — 2026-2027","visite":"stagiaires → total 1 (instance créée à 21:16:31.459)"}
GET /groupes → {"visite":"groupes → total 2 (instance créée à 21:16:31.459)"}
GET /stagiaires → {"entete":"Institut de formation de Tunis — 2026-2027","visite":"stagiaires → total 3 (instance créée à 21:16:31.459)"}

Le total continue de 1 à 3 d'un module à l'autre et l'heure de création est identique : une seule instance de CompteurService sert les deux modules. C'est ce qui permet de partager une connexion à la base de données, un cache ou une configuration.

2. Le module global

Certains services sont utilisés presque partout (configuration, journalisation). Les importer dans chaque module devient fastidieux. Le décorateur @Global() rend les exports d'un module disponibles dans toute l'application, à condition que le module soit importé une fois (en général dans AppModule).

@Global()
@Module({
  providers: [JournalService],
  exports: [JournalService],
})
export class JournalModule {}

// app.module.ts : importé une seule fois
@Module({ imports: [JournalModule, StagiairesModule, GroupesModule] })
export class AppModule {}

// stagiaires.module.ts : aucun import nécessaire pour injecter JournalService
@Module({ controllers: [StagiairesController], providers: [StagiairesService] })
export class StagiairesModule {}

3. Le module dynamique

Un module « statique » est toujours identique. Un module dynamique reçoit des options au moment de l'import: nom de l'établissement, adresse de la base de données, clé secrète… Il expose une méthode statique, par convention forRoot(), qui renvoie un objet DynamicModule:

📄 src/parametres/parametres.constants.ts

export interface ParametresOptions {
  etablissement: string;
  anneeScolaire: string;
}

export const PARAMETRES_OPTIONS = 'PARAMETRES_OPTIONS';   // jeton d'injection

📄 src/parametres/parametres.module.ts

import { DynamicModule, Global, Module } from '@nestjs/common';
import { PARAMETRES_OPTIONS, ParametresOptions } from './parametres.constants';
import { ParametresService } from './parametres.service';

@Global()
@Module({})
export class ParametresModule {
  static forRoot(options: ParametresOptions): DynamicModule {
    return {
      module: ParametresModule,
      providers: [
        { provide: PARAMETRES_OPTIONS, useValue: options },   // les options deviennent injectables
        ParametresService,
      ],
      exports: [ParametresService],
    };
  }
}

• module: la classe du module (obligatoire) ;
• providers: ici, un provider de valeur { provide: JETON, useValue: options } qui rend les options injectables (les providers personnalisés sont détaillés au chapitre 07) ;
• exports: comme pour un module statique.

Comme les options ne sont pas une classe, on les injecte grâce à leur jeton avec @Inject():

📄 src/parametres/parametres.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { PARAMETRES_OPTIONS, ParametresOptions } from './parametres.constants';

@Injectable()
export class ParametresService {
  constructor(@Inject(PARAMETRES_OPTIONS) private readonly options: ParametresOptions) {}

  entete(): string {
    return `${this.options.etablissement} — ${this.options.anneeScolaire}`;
  }
}

Le module est configuré au moment de l'import, dans AppModule:

📄 src/app.module.ts

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

@Module({
  imports: [
    ParametresModule.forRoot({ etablissement: 'Institut de formation de Tunis', anneeScolaire: '2026-2027' }),
    StagiairesModule,
    GroupesModule,
  ],
})
export class AppModule {}

Et grâce à @Global(), le module des stagiaires injecte ParametresService sans l'importer, alors qu'il importe explicitement CommonModule:

📄 src/stagiaires/stagiaires.module.ts

import { Controller, Get, Module } from '@nestjs/common';
import { CommonModule } from '../common/common.module';
import { CompteurService } from '../common/compteur.service';
import { ParametresService } from '../parametres/parametres.service';

@Controller('stagiaires')
export class StagiairesController {
  constructor(
    private readonly compteur: CompteurService,        // module partagé importé
    private readonly parametres: ParametresService,    // module global : aucun import
  ) {}

  @Get()
  findAll() {
    return { entete: this.parametres.entete(), visite: this.compteur.incrementer('stagiaires') };
  }
}

@Module({ imports: [CommonModule], controllers: [StagiairesController] })
export class StagiairesModule {}

Le champ entete des réponses ci-dessus (« Institut de formation de Tunis — 2026-2027 ») provient bien des options passées à forRoot().

4. Les conventions de nommage

// Aperçu des chapitres 10 et 11 : configuration lue dans .env, puis base de données
@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'mysql',
        host: config.get('DB_HOST'),
        database: config.get('DB_NAME'),
        autoLoadEntities: true,
      }),
    }),
    StagiairesModule,
  ],
})
export class AppModule {}

Vous savez maintenant ce que fait ce code : deux modules dynamiques, le premier global, le second configuré à partir d'un service injecté.

Activités

import { DynamicModule, Inject, Injectable, Module } from '@nestjs/common';

export interface JournalOptions {
  prefixe: string;
  horodatage?: boolean;
}
export const JOURNAL_OPTIONS = 'JOURNAL_OPTIONS';

@Injectable()
export class JournalService {
  constructor(@Inject(JOURNAL_OPTIONS) private readonly options: JournalOptions) {}
  ecrire(message: string): string {
    const heure = this.options.horodatage ? `${new Date().toISOString().slice(11, 19)} ` : '';
    const ligne = `${heure}[${this.options.prefixe}] ${message}`;
    console.log(ligne);
    return ligne;
  }
}

@Module({})
export class JournalModule {
  static forRoot(options: JournalOptions): DynamicModule {
    return {
      module: JournalModule,
      global: true,                       // autre façon de rendre un module global
      providers: [{ provide: JOURNAL_OPTIONS, useValue: { horodatage: false, ...options } }, JournalService],
      exports: [JournalService],
    };
  }
}

[API-FORMATION] route /test appelée
Réponse : [API-FORMATION] route /test appelée