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

TP 5 : Valider les entrées utilisateurs d'une API de gestion de stagiaires

Ce TP fait réaliser une API de gestion de stagiaires entièrement protégée par la validation, publiée sur GitHub dès le départ. Les étudiants écrivent les DTO de création (nom, e-mail, CIN, date de nai...

0 chapitres 0 QCM Accès gratuit
TP 5 : Valider les entrées utilisateurs d'une API de gestion de stagiaires

À propos de ce cours

Ce TP fait réaliser une API de gestion de stagiaires entièrement protégée par la validation, publiée sur GitHub dès le départ. Les étudiants écrivent les DTO de création (nom, e-mail, CIN, date de naissance, groupe, téléphone, adresse imbriquée, compétences), de modification avec les mapped types et de filtre de la query string, un décorateur de validation personnalisé AgeMinimum, un pipe ParseMatriculePipe, et un ValidationPipe global qui renvoie les erreurs groupées par champ, y compris pour les objets imbriqués. Une batterie de requêtes vérifie chaque règle. Correction complète testée et grille d'évaluation.

Objectifs du TP

  • Protéger chaque entrée d'une API par des DTO validés.
  • Valider des objets imbriqués, des tableaux et la query string.
  • Dériver les DTO avec les mapped types.
  • Écrire un décorateur de validation et un pipe personnalisés.
  • Renvoyer des erreurs exploitables par un formulaire (groupées par champ).
  • Publier le projet sur GitHub dès le départ, un commit par partie.

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

Architecture du TP 5

Un ValidationPipe global, trois DTO, un décorateur et un pipe personnalisés.

Cahier des charges

Le service des stages veut une API d'inscription des stagiaires. L'interface (développée par un autre groupe) affichera les erreurs sous chaque champ du formulaire: l'API doit donc renvoyer toutes les erreurs, groupées par champ. Règles :

ChampRègle
nom, prenomobligatoires, 2 à 50 caractères, espaces de début et de fin supprimés
emailobligatoire, valide, enregistré en minuscules, unique (409)
cinexactement 8 chiffres, unique (409), non modifiable
dateNaissanceformat AAAA-MM-JJ, âge minimum 16 ans, non modifiable
groupeDEV101, DEV102, RES201 ou MUL301
telephonefacultatif, forme +216XXXXXXXX
adresseobjet obligatoire : rue (100 caractères au plus), ville, codePostal (4 chiffres)
competencesfacultatif, tableau de 10 chaînes différentes au plus
autres champsrefusés (400)
RouteRéponses
GET /api/v1/stagiaires?groupe=&q=&tri=&page=&limite=200 { total, page, limite, donnees }; 400 si filtre invalide (limite de 50)
GET /api/v1/stagiaires/:matricule200 ; 400 si matricule mal formé ; 404
POST /api/v1/stagiaires201 + Location (matricule STG-2026-0001…) ; 400 ; 409
PATCH /api/v1/stagiaires/:matricule200 ; 400 ; 404 ; 409
DELETE /api/v1/stagiaires/:matricule204 ; 404

Format d'erreur de validation attendu :

{
  "statusCode": 400,
  "message": "Données invalides",
  "erreurs": {
    "email": ["L'adresse e-mail n'est pas valide"],
    "adresse.codePostal": ["Le code postal doit contenir 4 chiffres"]
  }
}
Partie 1 Créer le projet et le dépôt GitHub
  1. nest new api-stagiaires --package-manager npm --strict; créez le dépôt GitHub public api-stagiaires, ajoutez-le comme origin et poussez (« chore: création du projet »).
  2. npm install class-validator class-transformer @nestjs/mapped-types.
  3. nest g res stagiaires --no-spec (REST API, sans CRUD généré) ou générez module, contrôleur et service séparément. Supprimez AppController et AppService.
  4. Dans main.ts: préfixe api, versionnement URI (defaultVersion: '1'), CORS exposant Location.
  5. Commit : chore: dépendances de validation et structure.
Partie 2 Le modèle et les DTO
  1. stagiaire.model.ts: la liste GROUPES (as const) et l'interface Stagiaire (avec matricule).
  2. dto/adresse.dto.ts puis dto/creer-stagiaire.dto.ts avec toutes les règles et des messages en français. Pour nettoyer nom et prenom, et mettre l'e-mail en minuscules, utilisez @Transform() de class-transformer (appliqué avant la validation lorsque transform est activé).
  3. dto/modifier-stagiaire.dto.ts avec PartialType et OmitType.
  4. dto/filtre-stagiaires.dto.ts: groupe, q (2 caractères au moins), tri (nom, dateNaissance ou matricule, défaut nom), page (défaut 1), limite (défaut 10, 50 au plus).
  5. Commit : feat: DTO de création, modification et filtre.

@Transform(({ value }) => …) reçoit la valeur brute : vérifiez toujours son type (typeof value === 'string') avant d'appeler trim(), sinon un client qui envoie "nom": 42 provoquerait une erreur 500 au lieu d'un 400.

Partie 3 Le décorateur AgeMinimum et le pipe ParseMatriculePipe
  1. class-validator permet de créer ses propres décorateurs avec registerDecorator(). Écrivez @AgeMinimum(16) dans src/common/validators/age-minimum.decorator.ts: la valeur doit être une date, et la personne doit avoir au moins l'âge indiqué aujourd'hui.
  2. Écrivez ParseMatriculePipe (activité 1 de la leçon 8.6) dans src/common/pipes/.
  3. Commit : feat: décorateur AgeMinimum et pipe de matricule.
// squelette de registerDecorator
export function AgeMinimum(minimum: number, options?: ValidationOptions) {
  return (objet: object, propriete: string) =>
    registerDecorator({
      name: 'ageMinimum',
      target: objet.constructor,
      propertyName: propriete,
      constraints: [minimum],
      options: { message: `L'âge minimum est de ${minimum} ans`, ...options },
      validator: {
        validate(valeur: unknown, args: ValidationArguments): boolean {
          // à compléter : renvoyer true si la valeur est valide
        },
      },
    });
}
Partie 4 Le service et le contrôleur
  1. StagiairesService: findAll(filtre) (filtres, recherche dans nom et prénom, tri, pagination), findOne (404), create (matricule STG-2026-NNNN, 409 si CIN ou e-mail déjà utilisés), update (409 si l'e-mail appartient à un autre stagiaire), remove.
  2. Le service ne revérifie aucune règle de format : il fait confiance aux DTO. Il ne vérifie que les règles qui demandent de consulter les données (unicité).
  3. StagiairesController (version 1) : @Query() filtre: FiltreStagiairesDto, ParseMatriculePipe sur tous les :matricule, Location au POST, 204 au DELETE.
  4. Commit : feat: service et contrôleur des stagiaires.
Partie 5 Le ValidationPipe global et le format des erreurs
  1. Créez src/common/validation.config.ts qui exporte un ValidationPipe avec whitelist, forbidNonWhitelisted, transform et une exceptionFactory.
  2. L'exceptionFactory doit aplatir l'arbre d'erreurs : une erreur d'un objet imbriqué se trouve dans children; son chemin est adresse.codePostal. Écrivez une fonction récursive.
  3. Activez-le dans main.ts avec app.useGlobalPipes(validationPipe).
  4. Commit : feat: validation globale et erreurs par champ.
Partie 6 Tester, documenter et livrer
  1. Créez requetes/stagiaires.http (base ci-dessous) et complétez-le pour couvrir chaque règle du cahier des charges.
  2. Constatez le comportement de PATCH avec { "adresse": { "ville": "Sousse" } } et expliquez-le dans le README (leçon 8.5).
  3. Rédigez le README.md: lancement, routes, tableau des règles de validation, exemple de réponse d'erreur.
  4. Vérifiez npm run lint et npm run build, commit docs: README et requêtes de test, push, étiquette v1.0.0.
@base = http://localhost:3000/api/v1/stagiaires

### 1. Création valide (201 + Location ; nom et e-mail nettoyés)
POST {{base}}
Content-Type: application/json

{
  "nom": "  Ben Ali ",
  "prenom": "Sami",
  "email": " Sami.BenAli@Exemple.tn ",
  "cin": "01234567",
  "dateNaissance": "2005-03-14",
  "groupe": "DEV101",
  "telephone": "+21622123456",
  "adresse": { "rue": "12 rue de Marseille", "ville": "Tunis", "codePostal": "1000" },
  "competences": ["HTML", "CSS"]
}

### 2. Corps vide : toutes les erreurs, groupées par champ
POST {{base}}
Content-Type: application/json

{}

### 3. Erreurs multiples, y compris dans l'adresse
POST {{base}}
Content-Type: application/json

{
  "nom": "B", "prenom": "Sami", "email": "sami@", "cin": "1234",
  "dateNaissance": "2015-01-01", "groupe": "DEV999", "telephone": "22123456",
  "adresse": { "rue": "", "ville": "Sfax", "codePostal": "30" },
  "competences": ["HTML", "HTML"]
}

### 4. Champ interdit (role) → 400
### 5. Même CIN → 409
### 6. Filtres : ?groupe=DEV102 ; ?limite=100&tri=age → 400
GET {{base}}?groupe=DEV102

### 7. Matricule saisi librement
GET {{base}}/stg-2026-1

### 8. Modification : le CIN est interdit
PATCH {{base}}/STG-2026-0001
Content-Type: application/json

{ "cin": "99999999" }

### 9. Suppression (204)
DELETE {{base}}/stg-2026-2
Résultat attendu

Réponses obtenues avec la correction (requêtes du fichier .http complété) :

POST /api/v1/stagiaires → 201 {"matricule":"STG-2026-0001","nom":"Ben Ali","prenom":"Sami","email":"sami.benali@exemple.tn","cin":"01234567","dateNaissance":"2005-03-14","groupe":"DEV101","telephone":"+21622123456","adresse":{"rue":"12 rue de Marseille","ville":"Tunis","codePostal":"1000"},"competences":["HTML","CSS"]}  [location: /api/v1/stagiaires/STG-2026-0001]
POST /api/v1/stagiaires → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"nom":["Le nom doit contenir entre 2 et 50 caractères","nom must be a string"],"prenom":["Le prénom doit contenir entre 2 et 50 caractères","prenom must be a string"],"email":["L'adresse e-mail n'est pas valide"],"cin":["Le CIN doit contenir exactement 8 chiffres"],"dateNaissance":["L'âge minimum est de 16 ans","La date de naissance doit être au format AAAA-MM-JJ"],"groupe":["Le groupe doit être l'un de : DEV101, DEV102, RES201, MUL301"]}}
POST /api/v1/stagiaires → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"nom":["Le nom doit contenir entre 2 et 50 caractères"],"email":["L'adresse e-mail n'est pas valide"],"cin":["Le CIN doit contenir exactement 8 chiffres"],"dateNaissance":["L'âge minimum est de 16 ans"],"groupe":["Le groupe doit être l'un de : DEV101, DEV102, RES201, MUL301"],"telephone":["Le téléphone doit avoir la forme +216XXXXXXXX"],"adresse.rue":["La rue est obligatoire"],"adresse.codePostal":["Le code postal doit contenir 4 chiffres"],"competences":["Les compétences doivent être différentes"]}}
POST /api/v1/stagiaires → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"dateNaissance":["L'âge minimum est de 16 ans","La date de naissance doit être au format AAAA-MM-JJ"]}}
POST /api/v1/stagiaires → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"role":["property role should not exist"]}}
POST /api/v1/stagiaires → 409 {"message":"Le CIN 01234567 est déjà enregistré","error":"Conflict","statusCode":409}
POST /api/v1/stagiaires → 201 {"matricule":"STG-2026-0002","nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","cin":"07654321","dateNaissance":"2005-03-14","groupe":"DEV102","telephone":"+21622123456","adresse":{"rue":"12 rue de Marseille","ville":"Tunis","codePostal":"1000"},"competences":[]}
GET /api/v1/stagiaires?groupe=DEV102 → 200 {"total":1,"page":1,"limite":10,"donnees":[{"matricule":"STG-2026-0002","nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","cin":"07654321","dateNaissance":"2005-03-14","groupe":"DEV102","telephone":"+21622123456","adresse":{"rue":"12 rue de Marseille","ville":"Tunis","codePostal":"1000"},"competences":[]}]}
GET /api/v1/stagiaires?limite=100&tri=age → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"tri":["tri must be one of the following values: nom, dateNaissance, matricule"],"limite":["limite must not be greater than 50"]}}
GET /api/v1/stagiaires/stg-2026-1 → 200 {"matricule":"STG-2026-0001","nom":"Ben Ali","prenom":"Sami","email":"sami.benali@exemple.tn","cin":"01234567","dateNaissance":"2005-03-14","groupe":"DEV101","telephone":"+21622123456","adresse":{"rue":"12 rue de Marseille","ville":"Tunis","codePostal":"1000"},"competences":["HTML","CSS"]}
GET /api/v1/stagiaires/ETU-1 → 400 {"message":"Matricule invalide : « ETU-1 » (format attendu : STG-AAAA-NNNN)","error":"Bad Request","statusCode":400}
PATCH /api/v1/stagiaires/STG-2026-0001 → 200 {"matricule":"STG-2026-0001","nom":"Ben Ali","prenom":"Sami","email":"sami.benali@exemple.tn","cin":"01234567","dateNaissance":"2005-03-14","groupe":"RES201","telephone":"+21698765432","adresse":{"rue":"12 rue de Marseille","ville":"Tunis","codePostal":"1000"},"competences":["HTML","CSS"]}
PATCH /api/v1/stagiaires/STG-2026-0001 → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"cin":["property cin should not exist"]}}
PATCH /api/v1/stagiaires/STG-2026-0001 → 400 {"statusCode":400,"message":"Données invalides","erreurs":{"adresse.rue":["rue must be shorter than or equal to 100 characters","La rue est obligatoire","rue must be a string"],"adresse.codePostal":["Le code postal doit contenir 4 chiffres"]}}
DELETE /api/v1/stagiaires/stg-2026-2 → 204
DELETE /api/v1/stagiaires/STG-2026-0002 → 404 {"message":"Stagiaire STG-2026-0002 introuvable","error":"Not Found","statusCode":404}

Remarquez dans la deuxième réponse que, pour un corps vide, nom reçoit deux messages (longueur et type) : class-validator vérifie toutes les règles d'une propriété. Si vous préférez un seul message par champ, ajoutez l'option stopAtFirstError: true. Dans la dernière modification, l'adresse incomplète est refusée : PartialType ne s'applique pas à l'intérieur de l'objet imbriqué.

Pour aller plus loin
  • Ajoutez une route POST /api/v1/stagiaires/import qui reçoit { "stagiaires": [ … ] } (1 à 100 éléments, @ValidateNested({ each: true })) et renvoie les erreurs avec leur position (stagiaires.3.email) grâce à votre fonction d'aplatissement.
  • Écrivez un décorateur @EstCinUnique() asynchrone avec une classe @ValidatorConstraint({ async: true }) qui injecte StagiairesService (cela demande useContainer(app.select(AppModule), { fallbackOnErrors: true }) de class-validator). Comparez avec la vérification dans le service.
  • Remplacez adresse dans ModifierStagiaireDto par un ModifierAdresseDto (tout facultatif) pour permettre la modification d'un seul champ de l'adresse.
  • Renvoyez un StagiaireReponseDto (leçon 8.1) qui masque le CIN sauf ses 3 derniers chiffres (*****567).
Correction
src/common/validators/age-minimum.decorator.ts
import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';

// Décorateur de validation personnalisé : la date (AAAA-MM-JJ) doit correspondre à un âge >= minimum
export function AgeMinimum(minimum: number, options?: ValidationOptions) {
  return (objet: object, propriete: string) =>
    registerDecorator({
      name: 'ageMinimum',
      target: objet.constructor,
      propertyName: propriete,
      constraints: [minimum],
      options: { message: `L'âge minimum est de ${minimum} ans`, ...options },
      validator: {
        validate(valeur: unknown, args: ValidationArguments) {
          if (typeof valeur !== 'string') return false;
          const naissance = new Date(valeur);
          if (Number.isNaN(naissance.getTime())) return false;
          const limite = new Date();
          limite.setFullYear(limite.getFullYear() - (args.constraints[0] as number));
          return naissance <= limite;
        },
      },
    });
}
src/common/pipes/parse-matricule.pipe.ts
import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';

// Accepte « stg-2026-7 », « STG-2026-0007 »… et renvoie toujours « STG-2026-0007 »
@Injectable()
export class ParseMatriculePipe implements PipeTransform<string, string> {
  transform(value: string): string {
    const m = /^stg-(\d{4})-(\d{1,4})$/i.exec((value ?? '').trim());
    if (!m) throw new BadRequestException(`Matricule invalide : « ${value} » (format attendu : STG-AAAA-NNNN)`);
    return `STG-${m[1]}-${m[2].padStart(4, '0')}`;
  }
}
src/common/validation.config.ts
import { BadRequestException, ValidationError, ValidationPipe } from '@nestjs/common';

// Transforme l'arbre d'erreurs de class-validator en { "champ.sousChamp": [messages] }
function aplatir(erreurs: ValidationError[], parent = ''): Record<string, string[]> {
  const resultat: Record<string, string[]> = {};
  for (const e of erreurs) {
    const chemin = parent ? `${parent}.${e.property}` : e.property;
    if (e.constraints) resultat[chemin] = Object.values(e.constraints);
    if (e.children?.length) Object.assign(resultat, aplatir(e.children, chemin));
  }
  return resultat;
}

export const validationPipe = new ValidationPipe({
  whitelist: true,
  forbidNonWhitelisted: true,
  transform: true,
  exceptionFactory: (erreurs) =>
    new BadRequestException({ statusCode: 400, message: 'Données invalides', erreurs: aplatir(erreurs) }),
});
src/stagiaires/stagiaire.model.ts
import { AdresseDto } from './dto/adresse.dto';

export const GROUPES = ['DEV101', 'DEV102', 'RES201', 'MUL301'] as const;

export interface Stagiaire {
  matricule: string;
  nom: string;
  prenom: string;
  email: string;
  cin: string;
  dateNaissance: string;
  groupe: string;
  telephone?: string;
  adresse: AdresseDto;
  competences: string[];
}
src/stagiaires/dto/adresse.dto.ts
import { IsNotEmpty, IsString, Matches, MaxLength } from 'class-validator';

export class AdresseDto {
  @IsString()
  @IsNotEmpty({ message: 'La rue est obligatoire' })
  @MaxLength(100)
  rue: string;

  @IsString()
  @IsNotEmpty({ message: 'La ville est obligatoire' })
  ville: string;

  @Matches(/^\d{4}$/, { message: 'Le code postal doit contenir 4 chiffres' })
  codePostal: string;
}
src/stagiaires/dto/creer-stagiaire.dto.ts
import { Transform, Type } from 'class-transformer';
import {
  ArrayMaxSize, ArrayUnique, IsArray, IsDateString, IsEmail, IsIn, IsOptional, IsString, Length, Matches,
  ValidateNested,
} from 'class-validator';
import { AgeMinimum } from '../../common/validators/age-minimum.decorator';
import { GROUPES } from '../stagiaire.model';
import { AdresseDto } from './adresse.dto';

const nettoyer = ({ value }: { value: unknown }) => (typeof value === 'string' ? value.trim() : value);

export class CreerStagiaireDto {
  @Transform(nettoyer)
  @IsString()
  @Length(2, 50, { message: 'Le nom doit contenir entre 2 et 50 caractères' })
  nom: string;

  @Transform(nettoyer)
  @IsString()
  @Length(2, 50, { message: 'Le prénom doit contenir entre 2 et 50 caractères' })
  prenom: string;

  @Transform(({ value }) => (typeof value === 'string' ? value.trim().toLowerCase() : value))
  @IsEmail({}, { message: "L'adresse e-mail n'est pas valide" })
  email: string;

  @Matches(/^\d{8}$/, { message: 'Le CIN doit contenir exactement 8 chiffres' })
  cin: string;

  @IsDateString({ strict: true }, { message: 'La date de naissance doit être au format AAAA-MM-JJ' })
  @AgeMinimum(16)
  dateNaissance: string;

  @IsIn(GROUPES, { message: `Le groupe doit être l'un de : ${GROUPES.join(', ')}` })
  groupe: string;

  @IsOptional()
  @Matches(/^\+216\d{8}$/, { message: 'Le téléphone doit avoir la forme +216XXXXXXXX' })
  telephone?: string;

  @ValidateNested()
  @Type(() => AdresseDto)
  adresse: AdresseDto;

  @IsOptional()
  @IsArray()
  @ArrayMaxSize(10, { message: 'Au plus 10 compétences' })
  @ArrayUnique({ message: 'Les compétences doivent être différentes' })
  @IsString({ each: true })
  competences?: string[];
}
src/stagiaires/dto/modifier-stagiaire.dto.ts
import { OmitType, PartialType } from '@nestjs/mapped-types';
import { CreerStagiaireDto } from './creer-stagiaire.dto';

// Le CIN et la date de naissance ne se modifient pas ; tout le reste est facultatif
export class ModifierStagiaireDto extends PartialType(OmitType(CreerStagiaireDto, ['cin', 'dateNaissance'] as const)) {}
src/stagiaires/dto/filtre-stagiaires.dto.ts
import { Type } from 'class-transformer';
import { IsIn, IsInt, IsOptional, IsString, Max, MinLength, Min } from 'class-validator';
import { GROUPES } from '../stagiaire.model';

export class FiltreStagiairesDto {
  @IsOptional()
  @IsIn(GROUPES)
  groupe?: string;

  @IsOptional()
  @IsString()
  @MinLength(2)
  q?: string;

  @IsOptional()
  @IsIn(['nom', 'dateNaissance', 'matricule'])
  tri: string = 'nom';

  @IsOptional()
  @Type(() => Number)
  @IsInt()
  @Min(1)
  page: number = 1;

  @IsOptional()
  @Type(() => Number)
  @IsInt()
  @Min(1)
  @Max(50)
  limite: number = 10;
}
src/stagiaires/stagiaires.service.ts
import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { CreerStagiaireDto } from './dto/creer-stagiaire.dto';
import { FiltreStagiairesDto } from './dto/filtre-stagiaires.dto';
import { ModifierStagiaireDto } from './dto/modifier-stagiaire.dto';
import { Stagiaire } from './stagiaire.model';

@Injectable()
export class StagiairesService {
  private readonly stagiaires: Stagiaire[] = [];
  private compteur = 0;

  findAll(f: FiltreStagiairesDto) {
    let liste = this.stagiaires.filter(
      (s) =>
        (!f.groupe || s.groupe === f.groupe) &&
        (!f.q || `${s.nom} ${s.prenom}`.toLowerCase().includes(f.q.toLowerCase())),
    );
    liste = [...liste].sort((a, b) => String(a[f.tri as keyof Stagiaire]).localeCompare(String(b[f.tri as keyof Stagiaire])));
    const debut = (f.page - 1) * f.limite;
    return { total: liste.length, page: f.page, limite: f.limite, donnees: liste.slice(debut, debut + f.limite) };
  }

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

  create(dto: CreerStagiaireDto): Stagiaire {
    if (this.stagiaires.some((s) => s.cin === dto.cin)) throw new ConflictException(`Le CIN ${dto.cin} est déjà enregistré`);
    if (this.stagiaires.some((s) => s.email === dto.email)) throw new ConflictException(`L'e-mail ${dto.email} est déjà utilisé`);
    this.compteur++;
    const stagiaire: Stagiaire = {
      matricule: `STG-2026-${String(this.compteur).padStart(4, '0')}`,
      ...dto,
      competences: dto.competences ?? [],
    };
    this.stagiaires.push(stagiaire);
    return stagiaire;
  }

  update(matricule: string, dto: ModifierStagiaireDto): Stagiaire {
    const s = this.findOne(matricule);
    if (dto.email && this.stagiaires.some((x) => x.email === dto.email && x !== s)) {
      throw new ConflictException(`L'e-mail ${dto.email} est déjà utilisé`);
    }
    Object.assign(s, dto);                       // sûr : le DTO validé ne contient que des champs autorisés
    return s;
  }

  remove(matricule: string): void {
    const s = this.findOne(matricule);
    this.stagiaires.splice(this.stagiaires.indexOf(s), 1);
  }
}
src/stagiaires/stagiaires.controller.ts
import {
  Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Patch, Post, Query, Res,
} from '@nestjs/common';
import type { Response } from 'express';
import { ParseMatriculePipe } from '../common/pipes/parse-matricule.pipe';
import { CreerStagiaireDto } from './dto/creer-stagiaire.dto';
import { FiltreStagiairesDto } from './dto/filtre-stagiaires.dto';
import { ModifierStagiaireDto } from './dto/modifier-stagiaire.dto';
import { StagiairesService } from './stagiaires.service';

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

  @Get()
  findAll(@Query() filtre: FiltreStagiairesDto) {
    return this.stagiairesService.findAll(filtre);
  }

  @Get(':matricule')
  findOne(@Param('matricule', ParseMatriculePipe) matricule: string) {
    return this.stagiairesService.findOne(matricule);
  }

  @Post()
  create(@Body() dto: CreerStagiaireDto, @Res({ passthrough: true }) res: Response) {
    const s = this.stagiairesService.create(dto);
    res.location(`/api/v1/stagiaires/${s.matricule}`);
    return s;
  }

  @Patch(':matricule')
  update(@Param('matricule', ParseMatriculePipe) matricule: string, @Body() dto: ModifierStagiaireDto) {
    return this.stagiairesService.update(matricule, dto);
  }

  @Delete(':matricule')
  @HttpCode(HttpStatus.NO_CONTENT)
  remove(@Param('matricule', ParseMatriculePipe) matricule: string) {
    this.stagiairesService.remove(matricule);
  }
}
src/stagiaires/stagiaires.module.ts
import { Module } from '@nestjs/common';
import { StagiairesController } from './stagiaires.controller';
import { StagiairesService } from './stagiaires.service';

@Module({
  controllers: [StagiairesController],
  providers: [StagiairesService],
})
export class StagiairesModule {}
src/app.module.ts
import { Module } from '@nestjs/common';
import { StagiairesModule } from './stagiaires/stagiaires.module';

@Module({ imports: [StagiairesModule] })
export class AppModule {}
src/main.ts
import { VersioningType } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { validationPipe } from './common/validation.config';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api');
  app.enableVersioning({ type: VersioningType.URI, defaultVersion: '1' });
  app.useGlobalPipes(validationPipe);
  app.enableCors({ exposedHeaders: ['Location'] });
  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
CreerStagiaireDto : toutes les règles, messages en français, @Transform, adresse imbriquée, compétences5
ModifierStagiaireDto et FiltreStagiairesDto (mapped types, conversion de la query string, valeurs par défaut)3
Décorateur AgeMinimum et ParseMatriculePipe fonctionnels3
ValidationPipe global : whitelist, forbid, transform, erreurs aplaties par champ (y compris imbriquées)3
Service et contrôleur : 201/Location, 204, 404, 409, pagination2
Fichier .http couvrant chaque règle, README avec le tableau des règles2
Total20

Cet article vous a-t-il aidé ?