Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

TP 6 : Tracer, filtrer et formater les requêtes d'une API NestJS

Ce TP fait équiper une API NestJS de toute la chaîne de traitement des requêtes, publiée sur GitHub dès le départ. Les étudiants écrivent un middleware d'identifiant de corrélation et un journal des r...

0 chapitres 0 QCM Accès gratuit
TP 6 : Tracer, filtrer et formater les requêtes d'une API NestJS

À propos de ce cours

Ce TP fait équiper une API NestJS de toute la chaîne de traitement des requêtes, publiée sur GitHub dès le départ. Les étudiants écrivent un middleware d'identifiant de corrélation et un journal des requêtes par niveau, deux guards globaux (clé API puis rôles) avec les décorateurs @Public et @Roles, un décorateur @Utilisateur, un intercepteur qui enveloppe toutes les réponses et mesure leur durée, et un filtre global qui uniformise toutes les erreurs et journalise les erreurs imprévues sans les révéler. Tous les éléments sont enregistrés avec APP_GUARD, APP_INTERCEPTOR, APP_PIPE et APP_FILTER. Correction testée et grille.

Objectifs du TP

  • Tracer chaque requête (identifiant de corrélation, journal par niveau, durée).
  • Contrôler l'accès par clé API et par rôle, avec des routes publiques.
  • Donner à toutes les réponses, succès comme erreurs, un format unique.
  • Enregistrer chaque élément au bon niveau (APP_GUARD, APP_INTERCEPTOR, APP_PIPE, APP_FILTER).
  • Publier le projet sur GitHub dès le départ, un commit par partie.

Durée: 4 h  |  Prérequis: chapitres 05 à 09  |  Livrable: le dépôt api-formation-securisee avec l'étiquette v1.0.0.

Architecture du TP 6

Chaque requête traverse middlewares, guards, intercepteur, pipe et, en cas d'erreur, le filtre global.

Cahier des charges

L'API de gestion des formations va être ouverte à d'autres applications de l'établissement. L'équipe d'exploitation exige :

  1. Traçabilité: chaque réponse contient un en-tête X-Correlation-Id (celui envoyé par le client s'il est valide, sinon un UUID) ; chaque requête produit une ligne de journal MÉTHODE URL STATUT DURÉEms [corrélation], au niveau log, warn (4xx) ou error (5xx).
  2. Accès: toutes les routes exigent une clé API (en-tête x-api-key), sauf la santé et la liste des formations. Chaque clé correspond à un utilisateur et un rôle. Création et modification : formateur ou admin ; suppression et rapport : admin.
  3. Format des succès: { "succes": true, "donnees": …, "meta": { "total"?, "correlationId", "dureeMs" } }, et l'en-tête X-Duree-Ms. Pas de corps pour un 204.
  4. Format des erreurs: { "succes": false, "erreur": { "statut", "message" }, "meta": { "correlationId", "chemin", "horodatage" } } pour toutes les erreurs, y compris les 404 de routes inconnues et les erreurs imprévues, dont le détail est journalisé mais jamais envoyé.
  5. Une formation créée enregistre son auteur (creePar), issu de la clé API.
RouteAccès
GET /santepublic
GET /api/v1/formationspublic
GET /api/v1/formations/:idtoute clé valide
POST, PATCH /api/v1/formations[/:id]formateur, admin
DELETE /api/v1/formations/:id, GET /api/v1/formations/rapportadmin
Partie 1 Créer le projet et le dépôt GitHub
  1. nest new api-formation-securisee --package-manager npm --strict; créez le dépôt GitHub public du même nom et poussez (« chore: création du projet »).
  2. npm install class-validator class-transformer @nestjs/mapped-types.
  3. Créez la ressource formations (module, contrôleur, service, DTO) en mémoire, avec deux formations initiales, et un SanteController. Le service contient une méthode rapport() qui lève volontairement une Error (simulation d'une panne d'un service externe).
  4. main.ts: préfixe api sauf sante, versionnement URI par défaut 1, CORS exposant X-Correlation-Id et X-Duree-Ms.
  5. Commit : feat: ressource formations en mémoire.
Partie 2 Middlewares : corrélation et journal
  1. src/common/middlewares/correlation.middleware.ts: n'acceptez l'identifiant du client que s'il respecte ^[\w-]{1,64}$ (un client ne doit pas pouvoir injecter n'importe quoi dans vos journaux).
  2. src/common/middlewares/journal.middleware.ts avec Logger('HTTP') et trois niveaux.
  3. Enregistrez-les dans AppModule.configure() avec forRoutes('{*splat}'), dans cet ordre (pourquoi ?).
  4. Commit : feat: corrélation et journal des requêtes.
Partie 3 Décorateurs et guards
  1. Décorateurs dans src/common/decorators/: @Public() et @Roles(...roles) avec SetMetadata, @Utilisateur(champ?) avec createParamDecorator.
  2. CleApiGuard: laisse passer les routes @Public(); sinon cherche la clé dans un dictionnaire (trois clés de démonstration), lève 401 si elle est inconnue, et place l'utilisateur dans req.utilisateur.
  3. RolesGuard: lit @Roles (méthode, sinon contrôleur) et lève 403 si le rôle de req.utilisateur ne convient pas.
  4. Enregistrez les deux avec APP_GUARD, dans cet ordre. Placez les décorateurs sur le contrôleur, et utilisez @Utilisateur('nom') dans create pour remplir creePar.
  5. Commit : feat: guards de clé API et de rôles.

Les clés sont écrites dans le code pour ce TP seulement. Au chapitre 10, elles passeront dans les variables d'environnement, et au chapitre 13, elles seront remplacées par des jetons JWT.

Partie 4 L'intercepteur d'enveloppe
  1. EnveloppeInterceptor: mesure la durée, ajoute X-Duree-Ms, enveloppe les données avec total (pour les tableaux) et correlationId. Pour un statut 204, renvoyez la valeur sans enveloppe.
  2. Enregistrez-le avec APP_INTERCEPTOR, et le ValidationPipe avec APP_PIPE (useValue).
  3. Commit : feat: enveloppe des réponses.
Partie 5 Le filtre global
  1. ErreursFilter avec @Catch(): pour une HttpException, reprenez le statut et le message (chaîne ou tableau) ; pour toute autre erreur, 500 « Erreur interne du serveur » et une ligne Logger.error avec l'identifiant de corrélation et le vrai message.
  2. Enregistrez-le avec APP_FILTER.
  3. Vérifiez qu'une route inexistante (/api/v1/inconnue) reçoit aussi le nouveau format.
  4. Commit : feat: format uniforme des erreurs.
Partie 6 Tester, documenter et livrer
  1. Créez requetes/formations.http (base ci-dessous) et complétez-le pour couvrir chaque ligne du cahier des charges.
  2. Dans le README.md, décrivez le cycle d'une requête dans votre API (quels éléments, dans quel ordre, quel statut chacun peut produire) et donnez les trois clés de démonstration.
  3. npm run lint, npm run build, commit docs: README et requêtes, push, étiquette v1.0.0.
@base = http://localhost:3000/api/v1/formations
@admin = cle-admin-2026
@formateur = cle-formateur-2026
@stagiaire = cle-stagiaire-2026

### Santé (publique, hors préfixe)
GET http://localhost:3000/sante

### Liste publique, avec identifiant de corrélation choisi
GET {{base}}
X-Correlation-Id: tp6-000

### Sans clé → 401
GET {{base}}/1

### Stagiaire : lecture OK, 404, 400
GET {{base}}/1
x-api-key: {{stagiaire}}

###
GET {{base}}/9
x-api-key: {{stagiaire}}

### Stagiaire : création interdite → 403
POST {{base}}
x-api-key: {{stagiaire}}
Content-Type: application/json

{ "intitule": "Docker", "heures": 40, "niveau": "initiation" }

### Formateur : création → 201 (creePar = Mansouri)
POST {{base}}
x-api-key: {{formateur}}
Content-Type: application/json

{ "intitule": "Docker", "heures": 40, "niveau": "initiation" }

### Formateur : suppression interdite → 403 ; admin → 204
DELETE {{base}}/3
x-api-key: {{admin}}

### Erreur imprévue → 500 sans détail (voir le terminal)
GET {{base}}/rapport
x-api-key: {{admin}}
Résultat attendu

Réponses et lignes de journal obtenues avec la correction (les horodatages et les durées ont été remplacés par « … » pour la lisibilité) :

[LOG HTTP] GET /sante 200 8ms [e09dcfff-e00d-416b-bcce-b99201e3a909]
GET /sante → 200 {"succes":true,"donnees":{"statut":"ok"},"meta":{"correlationId":"e09dcfff-e00d-416b-bcce-b99201e3a909","dureeMs":…}}
  [LOG HTTP] GET /api/v1/formations 200 1ms [tp6-000]
GET /api/v1/formations → 200 {"succes":true,"donnees":[{"id":1,"intitule":"Développement web","heures":600,"niveau":"initiation","creePar":"Hajji"},{"id":2,"intitule":"NestJS avancé","heures":120,"niveau":"perfectionnement","creePar":"Hajji"}],"meta":{"total":2,"correlationId":"tp6-000","dureeMs":…}}  [x-correlation-id: tp6-000]
  [WARN HTTP] GET /api/v1/formations/1 401 1ms [58aca2e6-995a-409d-afde-38dcb6d17724]
GET /api/v1/formations/1 → 401 {"succes":false,"erreur":{"statut":401,"message":"Clé API absente ou invalide"},"meta":{"correlationId":"58aca2e6-995a-409d-afde-38dcb6d17724","chemin":"/api/v1/formations/1","horodatage":"…"}}
  [WARN HTTP] GET /api/v1/formations/1 401 1ms [8311c3d5-15ee-4184-ad65-44a773090948]
GET /api/v1/formations/1 → 401 {"succes":false,"erreur":{"statut":401,"message":"Clé API absente ou invalide"},"meta":{"correlationId":"8311c3d5-15ee-4184-ad65-44a773090948","chemin":"/api/v1/formations/1","horodatage":"…"}}
  [LOG HTTP] GET /api/v1/formations/1 200 1ms [tp6-003]
GET /api/v1/formations/1 → 200 {"succes":true,"donnees":{"id":1,"intitule":"Développement web","heures":600,"niveau":"initiation","creePar":"Hajji"},"meta":{"correlationId":"tp6-003","dureeMs":…}}
  [WARN HTTP] GET /api/v1/formations/9 404 2ms [tp6-003]
GET /api/v1/formations/9 → 404 {"succes":false,"erreur":{"statut":404,"message":"Formation 9 introuvable"},"meta":{"correlationId":"tp6-003","chemin":"/api/v1/formations/9","horodatage":"…"}}
  [WARN HTTP] GET /api/v1/formations/abc 400 1ms [tp6-003]
GET /api/v1/formations/abc → 400 {"succes":false,"erreur":{"statut":400,"message":"Validation failed (numeric string is expected)"},"meta":{"correlationId":"tp6-003","chemin":"/api/v1/formations/abc","horodatage":"…"}}
  [WARN HTTP] POST /api/v1/formations 403 1ms [tp6-003]
POST /api/v1/formations → 403 {"succes":false,"erreur":{"statut":403,"message":"Action réservée au rôle : formateur ou admin"},"meta":{"correlationId":"tp6-003","chemin":"/api/v1/formations","horodatage":"…"}}
  [LOG HTTP] POST /api/v1/formations 201 4ms [tp6-002]
POST /api/v1/formations → 201 {"succes":true,"donnees":{"id":3,"intitule":"Docker","heures":40,"niveau":"initiation","creePar":"Mansouri"},"meta":{"correlationId":"tp6-002","dureeMs":…}}
  [WARN HTTP] POST /api/v1/formations 400 3ms [tp6-002]
POST /api/v1/formations → 400 {"succes":false,"erreur":{"statut":400,"message":["property prix should not exist","intitule must be longer than or equal to 3 characters","heures must not be less than 10","niveau must be one of the following values: initiation, perfectionnement"]},"meta":{"correlationId":"tp6-002","chemin":"/api/v1/formations","horodatage":"…"}}
  [LOG HTTP] PATCH /api/v1/formations/3 200 1ms [tp6-002]
PATCH /api/v1/formations/3 → 200 {"succes":true,"donnees":{"id":3,"intitule":"Docker","heures":60,"niveau":"initiation","creePar":"Mansouri"},"meta":{"correlationId":"tp6-002","dureeMs":…}}
  [WARN HTTP] DELETE /api/v1/formations/3 403 0ms [tp6-002]
DELETE /api/v1/formations/3 → 403 {"succes":false,"erreur":{"statut":403,"message":"Action réservée au rôle : admin"},"meta":{"correlationId":"tp6-002","chemin":"/api/v1/formations/3","horodatage":"…"}}
  [LOG HTTP] DELETE /api/v1/formations/3 204 1ms [tp6-001]
DELETE /api/v1/formations/3 → 204
  [ERROR Erreurs] [tp6-001] Connexion au service de rapports refusée (ECONNREFUSED 10.0.0.5:8080)
  [ERROR HTTP] GET /api/v1/formations/rapport 500 2ms [tp6-001]
GET /api/v1/formations/rapport → 500 {"succes":false,"erreur":{"statut":500,"message":"Erreur interne du serveur"},"meta":{"correlationId":"tp6-001","chemin":"/api/v1/formations/rapport","horodatage":"…"}}
  [WARN HTTP] GET /api/v1/inconnue 404 0ms [tp6-001]
GET /api/v1/inconnue → 404 {"succes":false,"erreur":{"statut":404,"message":"Cannot GET /api/v1/inconnue"},"meta":{"correlationId":"tp6-001","chemin":"/api/v1/inconnue","horodatage":"…"}}

Remarquez :

  • Sans identifiant fourni, chaque requête reçoit un UUID, que l'on retrouve dans la ligne de journal et dans la réponse.
  • Les 4xx sont journalisées en WARN, la 500 en ERROR, avec deux lignes : le filtre écrit le vrai message (ECONNREFUSED…) et le journal HTTP la requête. Le client, lui, ne reçoit que « Erreur interne du serveur » et l'identifiant tp6-001, à communiquer au support pour retrouver l'erreur.
  • Le 403 du stagiaire sur POST arrive avant toute validation du corps : les guards passent avant les pipes.
Pour aller plus loin
  • Ajoutez un intercepteur de délai global (5 s) qui produit un 408 au format uniforme.
  • Ajoutez un guard de limitation de débit simple : au plus 20 requêtes par minute et par clé API (429). Comparez ensuite avec le module officiel @nestjs/throttler.
  • Écrivez le décorateur composé @Acces('admin') qui combine @Roles et un en-tête Cache-Control: no-store.
  • Écrivez les journaux au format JSON (une ligne par requête), plus facile à analyser par les outils de supervision (chapitre 20).
Correction
src/common/middlewares/correlation.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { randomUUID } from 'node:crypto';

export const ENTETE_CORRELATION = 'x-correlation-id';

@Injectable()
export class CorrelationMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const recu = req.header(ENTETE_CORRELATION);
    const id = recu && /^[\w-]{1,64}$/.test(recu) ? recu : randomUUID();
    req.headers[ENTETE_CORRELATION] = id;
    res.setHeader('X-Correlation-Id', id);
    next();
  }
}
src/common/middlewares/journal.middleware.ts
import { Injectable, Logger, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { ENTETE_CORRELATION } from './correlation.middleware';

@Injectable()
export class JournalMiddleware implements NestMiddleware {
  private readonly logger = new Logger('HTTP');

  use(req: Request, res: Response, next: NextFunction) {
    const debut = Date.now();
    res.on('finish', () => {
      const ligne = `${req.method} ${req.originalUrl} ${res.statusCode} ${Date.now() - debut}ms [${req.header(ENTETE_CORRELATION)}]`;
      if (res.statusCode >= 500) this.logger.error(ligne);
      else if (res.statusCode >= 400) this.logger.warn(ligne);
      else this.logger.log(ligne);
    });
    next();
  }
}
src/common/decorators/public.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const EST_PUBLIC = 'estPublic';
export const Public = () => SetMetadata(EST_PUBLIC, true);
src/common/decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';

export type Role = 'admin' | 'formateur' | 'stagiaire';
export const ROLES = 'roles';
export const Roles = (...roles: Role[]) => SetMetadata(ROLES, roles);
src/common/decorators/utilisateur.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { Request } from 'express';
import { Role } from './roles.decorator';

export interface UtilisateurConnecte {
  nom: string;
  role: Role;
}

// L'utilisateur est placé dans la requête par CleApiGuard
export const Utilisateur = createParamDecorator((champ: keyof UtilisateurConnecte | undefined, ctx: ExecutionContext) => {
  const utilisateur = ctx.switchToHttp().getRequest<Request & { utilisateur?: UtilisateurConnecte }>().utilisateur;
  return champ ? utilisateur?.[champ] : utilisateur;
});
src/common/guards/cle-api.guard.ts
import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Request } from 'express';
import { EST_PUBLIC } from '../decorators/public.decorator';
import { UtilisateurConnecte } from '../decorators/utilisateur.decorator';

// Clés API de démonstration (au chapitre 13, elles seront remplacées par des jetons JWT)
const CLES: Record<string, UtilisateurConnecte> = {
  'cle-admin-2026': { nom: 'Hajji', role: 'admin' },
  'cle-formateur-2026': { nom: 'Mansouri', role: 'formateur' },
  'cle-stagiaire-2026': { nom: 'Ben Ali', role: 'stagiaire' },
};

@Injectable()
export class CleApiGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    if (this.reflector.getAllAndOverride<boolean>(EST_PUBLIC, [context.getHandler(), context.getClass()])) return true;
    const req = context.switchToHttp().getRequest<Request & { utilisateur?: UtilisateurConnecte }>();
    const utilisateur = CLES[req.header('x-api-key') ?? ''];
    if (!utilisateur) throw new UnauthorizedException('Clé API absente ou invalide');
    req.utilisateur = utilisateur;                      // disponible pour la suite (guards, décorateur @Utilisateur)
    return true;
  }
}
src/common/guards/roles.guard.ts
import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Request } from 'express';
import { Role, ROLES } from '../decorators/roles.decorator';
import { UtilisateurConnecte } from '../decorators/utilisateur.decorator';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.getAllAndOverride<Role[]>(ROLES, [context.getHandler(), context.getClass()]);
    if (!roles?.length) return true;
    const utilisateur = context.switchToHttp().getRequest<Request & { utilisateur?: UtilisateurConnecte }>().utilisateur;
    if (!utilisateur || !roles.includes(utilisateur.role)) {
      throw new ForbiddenException(`Action réservée au rôle : ${roles.join(' ou ')}`);
    }
    return true;
  }
}
src/common/interceptors/enveloppe.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Request, Response } from 'express';
import { map, Observable } from 'rxjs';

@Injectable()
export class EnveloppeInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const debut = performance.now();
    const http = context.switchToHttp();
    return next.handle().pipe(
      map((donnees) => {
        const res = http.getResponse<Response>();
        if (res.statusCode === 204) return donnees;                     // pas de corps pour 204
        const duree = Math.round(performance.now() - debut);
        res.setHeader('X-Duree-Ms', String(duree));
        return {
          succes: true,
          donnees,
          meta: {
            ...(Array.isArray(donnees) ? { total: donnees.length } : {}),
            correlationId: http.getRequest<Request>().header('x-correlation-id'),
            dureeMs: duree,
          },
        };
      }),
    );
  }
}
src/common/filters/erreurs.filter.ts
import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus, Logger } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch()
export class ErreursFilter implements ExceptionFilter {
  private readonly logger = new Logger('Erreurs');

  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const req = ctx.getRequest<Request>();
    const res = ctx.getResponse<Response>();
    const correlationId = req.header('x-correlation-id');

    let statut = HttpStatus.INTERNAL_SERVER_ERROR;
    let message: string | string[] = 'Erreur interne du serveur';
    let details: unknown;

    if (exception instanceof HttpException) {
      statut = exception.getStatus();
      const corps = exception.getResponse();
      if (typeof corps === 'string') message = corps;
      else {
        const { message: m, erreurs } = corps as { message?: string | string[]; erreurs?: unknown };
        message = m ?? exception.message;
        details = erreurs;
      }
    } else {
      const e = exception as Error;
      this.logger.error(`[${correlationId}] ${e?.message}`, e?.stack?.split('\n')[1]?.trim());
    }

    res.status(statut).json({
      succes: false,
      erreur: { statut, message, ...(details ? { details } : {}) },
      meta: { correlationId, chemin: req.originalUrl, horodatage: new Date().toISOString() },
    });
  }
}
src/formations/formation.dto.ts
import { PartialType } from '@nestjs/mapped-types';
import { IsIn, IsInt, IsString, Length, Max, Min } from 'class-validator';

export class CreerFormationDto {
  @IsString()
  @Length(3, 80)
  intitule: string;

  @IsInt()
  @Min(10)
  @Max(1200)
  heures: number;

  @IsIn(['initiation', 'perfectionnement'])
  niveau: string;
}

export class ModifierFormationDto extends PartialType(CreerFormationDto) {}
src/formations/formations.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { CreerFormationDto, ModifierFormationDto } from './formation.dto';

export interface Formation extends CreerFormationDto {
  id: number;
  creePar: string;
}

@Injectable()
export class FormationsService {
  private readonly formations: Formation[] = [
    { id: 1, intitule: 'Développement web', heures: 600, niveau: 'initiation', creePar: 'Hajji' },
    { id: 2, intitule: 'NestJS avancé', heures: 120, niveau: 'perfectionnement', creePar: 'Hajji' },
  ];
  private prochainId = 3;

  findAll() {
    return this.formations;
  }

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

  create(dto: CreerFormationDto, auteur: string) {
    const f = { id: this.prochainId++, ...dto, creePar: auteur };
    this.formations.push(f);
    return f;
  }

  update(id: number, dto: ModifierFormationDto) {
    return Object.assign(this.findOne(id), dto);
  }

  remove(id: number) {
    this.formations.splice(this.formations.indexOf(this.findOne(id)), 1);
  }

  rapport() {
    throw new Error('Connexion au service de rapports refusée (ECONNREFUSED 10.0.0.5:8080)');
  }
}
src/formations/formations.controller.ts
import {
  Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, ParseIntPipe, Patch, Post,
} from '@nestjs/common';
import { Public } from '../common/decorators/public.decorator';
import { Roles } from '../common/decorators/roles.decorator';
import { Utilisateur } from '../common/decorators/utilisateur.decorator';
import { CreerFormationDto, ModifierFormationDto } from './formation.dto';
import { FormationsService } from './formations.service';

@Controller({ path: 'formations', version: '1' })
export class FormationsController {
  constructor(private readonly formationsService: FormationsService) {}

  @Public()
  @Get()
  findAll() {
    return this.formationsService.findAll();
  }

  @Get('rapport')
  @Roles('admin')
  rapport() {
    return this.formationsService.rapport();
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.formationsService.findOne(id);
  }

  @Post()
  @Roles('formateur', 'admin')
  create(@Body() dto: CreerFormationDto, @Utilisateur('nom') auteur: string) {
    return this.formationsService.create(dto, auteur);
  }

  @Patch(':id')
  @Roles('formateur', 'admin')
  update(@Param('id', ParseIntPipe) id: number, @Body() dto: ModifierFormationDto) {
    return this.formationsService.update(id, dto);
  }

  @Delete(':id')
  @Roles('admin')
  @HttpCode(HttpStatus.NO_CONTENT)
  remove(@Param('id', ParseIntPipe) id: number) {
    this.formationsService.remove(id);
  }
}
src/formations/formations.module.ts
import { Module } from '@nestjs/common';
import { FormationsController } from './formations.controller';
import { FormationsService } from './formations.service';

@Module({ controllers: [FormationsController], providers: [FormationsService] })
export class FormationsModule {}
src/sante.controller.ts
import { Controller, Get, VERSION_NEUTRAL } from '@nestjs/common';
import { Public } from './common/decorators/public.decorator';

@Controller({ path: 'sante', version: VERSION_NEUTRAL })
export class SanteController {
  @Public()
  @Get()
  sante() {
    return { statut: 'ok' };
  }
}
src/app.module.ts
import { MiddlewareConsumer, Module, NestModule, ValidationPipe } from '@nestjs/common';
import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
import { ErreursFilter } from './common/filters/erreurs.filter';
import { CleApiGuard } from './common/guards/cle-api.guard';
import { RolesGuard } from './common/guards/roles.guard';
import { EnveloppeInterceptor } from './common/interceptors/enveloppe.interceptor';
import { CorrelationMiddleware } from './common/middlewares/correlation.middleware';
import { JournalMiddleware } from './common/middlewares/journal.middleware';
import { FormationsModule } from './formations/formations.module';
import { SanteController } from './sante.controller';

@Module({
  imports: [FormationsModule],
  controllers: [SanteController],
  providers: [
    { provide: APP_GUARD, useClass: CleApiGuard },          // 1. qui êtes-vous ?
    { provide: APP_GUARD, useClass: RolesGuard },           // 2. avez-vous le droit ?
    { provide: APP_INTERCEPTOR, useClass: EnveloppeInterceptor },
    { provide: APP_PIPE, useValue: new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }) },
    { provide: APP_FILTER, useClass: ErreursFilter },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(CorrelationMiddleware, JournalMiddleware).forRoutes('{*splat}');
  }
}
src/main.ts
import { VersioningType } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api', { exclude: ['sante'] });
  app.enableVersioning({ type: VersioningType.URI, defaultVersion: '1' });
  app.enableCors({ exposedHeaders: ['X-Correlation-Id', 'X-Duree-Ms'] });
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();
Grille d'évaluation
CritèrePoints
Dépôt GitHub dès la Partie 1, un commit clair par partie, étiquette v1.0.02
Middlewares : corrélation validée, journal à trois niveaux, forRoutes('{*splat}')3
Guards : 401 et 403 corrects, @Public et @Roles, ordre des APP_GUARD, req.utilisateur5
Décorateur @Utilisateur utilisé pour creePar2
Intercepteur : enveloppe, total, correlationId, X-Duree-Ms, 204 sans corps3
Filtre global : format unique (y compris 404 de route et 500), détail journalisé et masqué3
Fichier .http complet, README décrivant le cycle de requête2
Total20

Cet article vous a-t-il aidé ?