Les services NestJS (@Injectable)

Provider et service

Dans NestJS, un provider est tout ce que le conteneur peut fournir et injecter : une classe, une valeur, le résultat d'une fonction (leçon 7.4). Le service est le provider le plus courant : une classe décorée par @Injectable() qui contient la logique d'une fonctionnalité.

Il peut en revanche lever des exceptions HTTP (NotFoundException…) : c'est une pratique courante et acceptée dans NestJS.

Créer un service

nest g s stagiaires --no-spec      # crée stagiaires.service.ts et l'ajoute aux providers du module

📄 src/stagiaires.service.ts

import { Injectable, Logger, NotFoundException } from '@nestjs/common';

export interface Stagiaire {
  id: number;
  nom: string;
  groupe: string;
}

@Injectable()
export class StagiairesService {
  private readonly logger = new Logger(StagiairesService.name);
  private readonly stagiaires: Stagiaire[] = [
    { id: 1, nom: 'Ben Ali', groupe: 'DEV101' },
    { id: 2, nom: 'Trabelsi', groupe: 'DEV101' },
    { id: 3, nom: 'Gharbi', groupe: 'DEV102' },
  ];
  readonly creeLe = new Date().toISOString().slice(11, 23);

  constructor() {
    this.logger.log('instance de StagiairesService créée');
  }

  findAll(): Stagiaire[] {
    return this.stagiaires;
  }

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

• @Injectable() indique à NestJS que la classe peut être gérée par le conteneur, et surtout déclenche l'enregistrement des types du constructeur (design:paramtypes, leçon 4.7).
• private readonly logger = new Logger(StagiairesService.name): un Logger avec le nom de la classe comme contexte. C'est l'un des rares new légitimes dans un service, car ce n'est pas un provider.
• readonly sur le tableau : la référence ne change pas (son contenu, si).

Des services qui collaborent

Le service des notes a besoin de vérifier que le stagiaire existe et de connaître son nom : il injecte le service des stagiaires.

📄 src/notes.service.ts

import { BadRequestException, Injectable } from '@nestjs/common';
import { StagiairesService } from './stagiaires.service';

interface Note {
  stagiaireId: number;
  matiere: string;
  valeur: number;
}

@Injectable()
export class NotesService {
  private readonly notes: Note[] = [];

  constructor(private readonly stagiairesService: StagiairesService) {}   // un service en utilise un autre

  ajouter(stagiaireId: number, matiere: string, valeur: number): Note {
    this.stagiairesService.findOne(stagiaireId);                          // 404 si le stagiaire n'existe pas
    if (valeur < 0 || valeur > 20) throw new BadRequestException('La note doit être comprise entre 0 et 20');
    const note = { stagiaireId, matiere, valeur };
    this.notes.push(note);
    return note;
  }

  bulletin(stagiaireId: number) {
    const stagiaire = this.stagiairesService.findOne(stagiaireId);
    const notes = this.notes.filter((n) => n.stagiaireId === stagiaireId);
    const moyenne = notes.length ? notes.reduce((s, n) => s + n.valeur, 0) / notes.length : null;
    return { stagiaire: stagiaire.nom, notes: notes.map((n) => `${n.matiere} : ${n.valeur}`), moyenne };
  }
}

Deux contrôleurs utilisent ces services ; NotesController injecte même les deux :

📄 src/controllers.ts

import { Body, Controller, Get, Param, ParseIntPipe, Post } from '@nestjs/common';
import { NotesService } from './notes.service';
import { StagiairesService } from './stagiaires.service';

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

  @Get()
  findAll() {
    return { instance: this.stagiairesService.creeLe, liste: this.stagiairesService.findAll().map((s) => s.nom) };
  }
}

@Controller('notes')
export class NotesController {
  constructor(
    private readonly notesService: NotesService,
    private readonly stagiairesService: StagiairesService,     // même instance que dans StagiairesController
  ) {}

  @Post()
  ajouter(@Body() body: { stagiaireId: number; matiere: string; valeur: number }) {
    return this.notesService.ajouter(body.stagiaireId, body.matiere, body.valeur);
  }

  @Get('bulletin/:id')
  bulletin(@Param('id', ParseIntPipe) id: number) {
    return { instance: this.stagiairesService.creeLe, ...this.notesService.bulletin(id) };
  }
}

📄 src/app.module.ts

import { Module } from '@nestjs/common';
import { NotesController, StagiairesController } from './controllers';
import { NotesService } from './notes.service';
import { StagiairesService } from './stagiaires.service';

@Module({
  controllers: [StagiairesController, NotesController],
  providers: [StagiairesService, NotesService],
})
export class AppModule {}

Journal de démarrage et réponses obtenues :

[StagiairesService] instance de StagiairesService créée
GET /api/stagiaires → 200 {"instance":"22:28:54.615","liste":["Ben Ali","Trabelsi","Gharbi"]}
POST /api/notes → 201 {"stagiaireId":1,"matiere":"NestJS","valeur":15}
POST /api/notes → 201 {"stagiaireId":1,"matiere":"SQL","valeur":12}
POST /api/notes → 404 {"message":"Stagiaire 9 introuvable","error":"Not Found","statusCode":404}
POST /api/notes → 400 {"message":"La note doit être comprise entre 0 et 20","error":"Bad Request","statusCode":400}
GET /api/notes/bulletin/1 → 200 {"instance":"22:28:54.615","stagiaire":"Ben Ali","notes":["NestJS : 15","SQL : 12"],"moyenne":13.5}
GET /api/notes/bulletin/2 → 200 {"instance":"22:28:54.615","stagiaire":"Trabelsi","notes":[],"moyenne":null}

Une seule instance, partagée

Trois classes, une seule instance de StagiairesService.

La trace le prouve : le message « instance de StagiairesService créée » n'apparaît qu'une fois, au démarrage, et l'heure de création (instance) est identique dans les réponses des deux contrôleurs. StagiairesController, NotesController et NotesService partagent le même objet, donc les mêmes données.

Conséquence importante : un service ne doit pas stocker de données propres à une requête (l'utilisateur courant, par exemple) dans une propriété, car elles seraient partagées entre tous les utilisateurs. Les données d'une requête passent en paramètre des méthodes (ou par une portée particulière, leçon 7.5).

Le piège de l'@Injectable oublié

Que se passe-t-il si on oublie @Injectable() sur un service qui a une dépendance ?

import { Module } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';

export class JournalService {                     // ✗ @Injectable() oublié
  ecrire(m: string) { return `[journal] ${m}`; }
}

export class StagiairesService {                  // ✗ @Injectable() oublié, alors qu'il a une dépendance
  constructor(private readonly journal: JournalService) {}
  inscrire(nom: string) {
    return this.journal.ecrire(`${nom} inscrit`);
  }
}

@Module({ providers: [JournalService, StagiairesService] })
class AppModule {}

async function main() {
  const app = await NestFactory.create(AppModule, { logger: false });
  await app.init();
  console.log('démarrage réussi');
  try {
    console.log(app.get(StagiairesService).inscrire('Ben Ali'));
  } catch (e) {
    console.log(`plantage à l'utilisation : ${(e as Error).message}`);
  }
  await app.close();
}
main();

Résultat réellement obtenu :

démarrage réussi
plantage à l'utilisation : Cannot read properties of undefined (reading 'ecrire')

L'application démarre sans erreur… puis plante à la première utilisation. Sans décorateur sur la classe, TypeScript ne produit pas les métadonnées des paramètres du constructeur : NestJS ne sait pas qu'il faut un JournalService et crée StagiairesService sans argument. this.journal vaut alors undefined. Ce bug est sournois car il n'apparaît qu'à l'exécution de la route concernée.

Activités

@Injectable()
export class GroupesService {
  private readonly groupes = [{ code: 'DEV101', capacite: 2 }, { code: 'DEV102', capacite: 20 }];
  findOne(code: string) {
    const g = this.groupes.find((x) => x.code === code);
    if (!g) throw new NotFoundException(`Groupe ${code} introuvable`);
    return g;
  }
}

@Injectable()
export class StagiairesService {
  constructor(private readonly groupesService: GroupesService) {}

  inscrire(nom: string, code: string) {
    const groupe = this.groupesService.findOne(code);
    const effectif = this.stagiaires.filter((s) => s.groupe === code).length;
    if (effectif >= groupe.capacite) throw new ConflictException(`Le groupe ${code} est complet`);
    const s = { id: this.stagiaires.length + 1, nom, groupe: code };
    this.stagiaires.push(s);
    return s;
  }
}

private readonly logger = new Logger(NotesService.name);

ajouter(stagiaireId: number, matiere: string, valeur: number) {
  // … vérifications …
  this.logger.log(`note ajoutée : ${matiere} ${valeur} pour le stagiaire ${stagiaireId}`);
  if (valeur < 8) this.logger.warn(`note faible (${valeur}) pour le stagiaire ${stagiaireId}`);
}