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

TP 8 : Sécuriser une API avec JWT et gestion des rôles (admin / formateur / stagiaire)

Ce TP fait sécuriser complètement une API de scolarité NestJS et MySQL, publiée sur GitHub dès le départ. Les étudiants mettent en place l'inscription publique des stagiaires, la création des formateu...

0 chapitres 0 QCM Accès gratuit
TP 8 : Sécuriser une API avec JWT et gestion des rôles (admin / formateur / stagiaire)

À propos de ce cours

Ce TP fait sécuriser complètement une API de scolarité NestJS et MySQL, publiée sur GitHub dès le départ. Les étudiants mettent en place l'inscription publique des stagiaires, la création des formateurs par l'administrateur, la connexion avec mots de passe bcrypt et protection contre le chronométrage, les access et refresh tokens avec rotation et détection de réutilisation, deux guards globaux (JWT puis rôles) et les règles de propriété : chacun ne voit et ne saisit que les notes qui le concernent. Le premier administrateur est créé par un seeder. Correction exécutée et grille sur 20.

Objectifs du TP

  • Mettre en place une authentification complète : comptes, bcrypt, JWT, refresh tokens.
  • Protéger toute l'API par défaut, avec quelques routes publiques.
  • Appliquer des règles d'autorisation par rôle et par propriété des données.
  • Gérer le cycle de vie des sessions : rotation, révocation, désactivation, changement de mot de passe.
  • Publier le projet sur GitHub dès le départ, sans aucun secret dans le dépôt.

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

Architecture du TP 8

Trois modules, deux guards globaux, trois tables.

Cahier des charges
RôlePeut
admintout ; créer des comptes formateur ou admin ; changer un rôle ; désactiver un compte (sauf le sien) ; créer des groupes et y affecter des stagiaires ; supprimer des notes
formateurvoir les groupes qu'il encadre et les notes de leurs stagiaires ; saisir des notes pour ses stagiaires uniquement
stagiaires'inscrire (rôle imposé) ; voir son groupe et ses notes
  • Toutes les routes exigent un jeton, sauf : inscription, connexion, rafraîchissement.
  • Mots de passe : 8 caractères au moins avec minuscule, majuscule et chiffre ; stockés avec bcrypt ; jamais renvoyés.
  • Connexion : même message et même durée pour un compte inconnu et un mot de passe faux.
  • Jetons : access 15 min, refresh 7 jours, secrets distincts ; rotation et détection de réutilisation.
  • Désactiver un compte, changer son rôle ou son mot de passe ferme ses sessions.
  • Le premier administrateur est créé par un seeder à partir de variables d'environnement.
Partie 1 Projet, dépôt et configuration
  1. nest new api-scolarite-securisee --package-manager npm --strict; dépôt GitHub public ; vérifiez que .env est dans .gitignore.
  2. npm install @nestjs/config @nestjs/typeorm typeorm mysql2 @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt class-validator class-transformer et npm install -D @types/passport-jwt @types/bcrypt.
  3. Générez deux secrets : node -e "console.log(require('crypto').randomBytes(32).toString('hex'))". Créez .env (ci-dessous) et .env.example.
  4. Commit : chore: configuration et dépendances.
# .env (ne pas versionner) — .env.example contient les mêmes noms, sans les secrets
DB_HOTE=localhost
DB_PORT=3306
DB_UTILISATEUR=apc_dev
DB_MOT_DE_PASSE=secret_dev
DB_NOM=scolarite_dev
JWT_SECRET=<64 caractères hexadécimaux aléatoires>
JWT_DUREE=15m
JWT_REFRESH_SECRET=<64 autres caractères aléatoires>
JWT_REFRESH_DUREE=7d
ADMIN_EMAIL=admin@exemple.tn
ADMIN_MOT_DE_PASSE=Admin2026!
Partie 2 Entités, migration et seeder
  1. Entités Utilisateur (mot de passe et empreinte du refresh token en select: false), Groupe (formateur responsable), Note (stagiaire, auteur de la saisie).
  2. data-source.ts, scripts de migration (leçon 11.8), migration Initialisation relue puis exécutée.
  3. Seeder src/seeds/admin.seed.ts: crée l'administrateur s'il n'existe pas ; script npm seed:admin.
  4. Commit : db: entités, migration initiale et seeder admin.
Partie 3 AuthModule : comptes et jetons
  1. DTO d'inscription, de connexion, de rafraîchissement (@IsJWT()) et de changement de mot de passe.
  2. AuthService: creerCompte (bcrypt, 409 si doublon), inscrire (toujours stagiaire), connecter (hachage factice), emettre (paire de jetons, empreinte SHA-256), rafraichir (vérification, comparaison en temps constant, rotation, révocation en cas de réutilisation), deconnecter, changerMotDePasse.
  3. JwtStrategy qui relit l'utilisateur (actif, rôle et groupe à jour).
  4. Commit : feat: authentification JWT avec refresh tokens.
Partie 4 Guards et décorateurs
  1. @Public(), @Roles(), @Utilisateur() dans src/auth/decorators.ts.
  2. JwtAuthGuard et RolesGuard, enregistrés avec APP_GUARD dans cet ordre.
  3. Routes d'AuthController avec les bons @Public().
  4. Commit : feat: guards globaux et rôles.
Partie 5 Utilisateurs, groupes et notes
  1. UtilisateursController entièrement réservé à l'admin (@Roles sur la classe) : liste, création de comptes, changement de rôle, activation. Chaque modification sensible efface l'empreinte du refresh token.
  2. GroupesController: liste filtrée selon le rôle ; création (le formateur doit exister et avoir le rôle formateur) et affectation réservées à l'admin.
  3. NotesService: liste filtrée dans la requête SQL selon le rôle ; saisie autorisée au formateur du groupe du stagiaire (403 sinon) et à l'admin ; suppression réservée à l'admin.
  4. Commit : feat: utilisateurs, groupes et notes.
Partie 6 Tester, documenter et livrer
  1. requetes/scolarite.http (base ci-dessous) : complétez-le pour couvrir chaque ligne du cahier des charges, y compris les refus (401, 403, 409).
  2. Vérifiez avec git grep -i secret qu'aucun secret n'est dans le dépôt.
  3. README : installation (base, .env, migration, seeder), tableau des droits par rôle, cycle de vie des jetons.
  4. npm run lint, npm run build, commit, push, étiquette v1.0.0.
@base = http://localhost:3000/api

### Connexion de l'administrateur (créé par le seeder)
# @name admin
POST {{base}}/auth/connexion
Content-Type: application/json

{ "email": "admin@exemple.tn", "motDePasse": "Admin2026!" }

### Créer une formatrice
POST {{base}}/utilisateurs
Authorization: Bearer {{admin.response.body.access_token}}
Content-Type: application/json

{ "email": "mansouri@exemple.tn", "nom": "Lina Mansouri", "motDePasse": "Formateur2026", "role": "formateur" }

### Inscription publique d'un stagiaire
POST {{base}}/auth/inscription
Content-Type: application/json

{ "email": "sami@exemple.tn", "nom": "Sami Ben Ali", "motDePasse": "Stagiaire2026" }

### Créer un groupe et y affecter le stagiaire
POST {{base}}/groupes
Authorization: Bearer {{admin.response.body.access_token}}
Content-Type: application/json

{ "code": "dev101", "intitule": "Développement web 1", "formateurId": 2 }

###
PATCH {{base}}/groupes/1/stagiaires/3
Authorization: Bearer {{admin.response.body.access_token}}

### Connexion de la formatrice, saisie d'une note
# @name lina
POST {{base}}/auth/connexion
Content-Type: application/json

{ "email": "mansouri@exemple.tn", "motDePasse": "Formateur2026" }

###
POST {{base}}/notes
Authorization: Bearer {{lina.response.body.access_token}}
Content-Type: application/json

{ "stagiaireId": 3, "matiere": "SQL", "valeur": 15 }

### Rafraîchir
POST {{base}}/auth/rafraichir
Content-Type: application/json

{ "refreshToken": "{{lina.response.body.refresh_token}}" }
Résultat attendu

Migration, seeder et requêtes exécutés avec la correction :

$ npm run build && npm run migration:generate --name=Initialisation
Migration src/migrations/1794731273670-Initialisation.ts has been generated successfully.

$ npm run build && npm run migration:run
0 migrations are already loaded in the database.
1 migrations were found in the source code.
1 migrations are new migrations must be executed.
Migration Initialisation1794731273670 has been executed successfully.

$ npm run seed:admin
Administrateur admin@exemple.tn créé

$ requêtes de test
— Comptes
connexion admin → 200
POST /api/utilisateurs → 201 {"id":2,"email":"mansouri@exemple.tn","nom":"Lina Mansouri","role":"formateur"}
POST /api/utilisateurs → 201 {"id":3,"email":"jlassi@exemple.tn","nom":"Omar Jlassi","role":"formateur"}
POST /api/auth/inscription → 201 {"id":4,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
POST /api/auth/inscription → 201 {"id":5,"email":"ines@exemple.tn","nom":"Ines Trabelsi","role":"stagiaire"}
POST /api/auth/inscription → 400 {"message":["property role should not exist"],"error":"Bad Request","statusCode":400}
— Groupes
POST /api/groupes → 201 {"id":1,"code":"DEV101","intitule":"Développement web 1","formateurId":2}
POST /api/groupes → 201 {"id":2,"code":"RES201","intitule":"Réseaux","formateurId":3}
POST /api/groupes → 400 {"message":"L'utilisateur 4 n'est pas un formateur","error":"Bad Request","statusCode":400}
PATCH /api/groupes/1/stagiaires/4 → 200 {"stagiaireId":4,"groupeId":1}
PATCH /api/groupes/2/stagiaires/5 → 200 {"stagiaireId":5,"groupeId":2}
— Notes
POST /api/notes → 201 {"id":1,"stagiaire":"Sami Ben Ali","matiere":"SQL","valeur":15}
POST /api/notes → 201 {"id":2,"stagiaire":"Sami Ben Ali","matiere":"JS","valeur":12.5}
POST /api/notes → 403 {"message":"Ce stagiaire n'appartient pas à l'un de vos groupes","error":"Forbidden","statusCode":403}
POST /api/notes → 201 {"id":3,"stagiaire":"Ines Trabelsi","matiere":"Anglais","valeur":14}
POST /api/notes → 403 {"message":"Accès réservé : formateur, admin","error":"Forbidden","statusCode":403}
GET /api/notes → 200 [{"id":2,"matiere":"JS","valeur":12.5,"stagiaire":{"nom":"Sami Ben Ali","groupe":{"code":"DEV101"}},"stagiaireId":4},{"id":1,"matiere":"SQL","valeur":15,"stagiaire":{"nom":"Sami Ben Ali","groupe":{"code":"DEV101"}},"stagiaireId":4}]
GET /api/notes → 200 [{"id":3,"matiere":"Anglais","valeur":14,"stagiaire":{"nom":"Ines Trabelsi","groupe":{"code":"RES201"}},"stagiaireId":5}]
GET /api/notes → 200 [{"id":3,"matiere":"Anglais","valeur":14,"stagiaire":{"nom":"Ines Trabelsi","groupe":{"code":"RES201"}},"stagiaireId":5},{"id":2,"matiere":"JS","valeur":12.5,"stagiaire":{"nom":"Sami Ben Ali","groupe":{"code":"DEV101"}},"stagiaireId":4},{"id":1,"matiere":"SQL","valeur":15,"stagiaire":{"nom":"Sami Ben Ali","groupe":{"code":"DEV101"}},"stagiaireId":4}]
GET /api/groupes → 200 [{"id":1,"code":"DEV101","intitule":"Développement web 1","formateur":{"id":2,"email":"mansouri@exemple.tn","nom":"Lina Mansouri","role":"formateur","actif":true,"groupeId":null,"creeLe":"…"},"formateurId":2}]
DELETE /api/notes/1 → 403 {"message":"Accès réservé : admin","error":"Forbidden","statusCode":403}
GET /api/utilisateurs → 403 {"message":"Accès réservé : admin","error":"Forbidden","statusCode":403}
GET /api/notes → 401 {"message":"Unauthorized","statusCode":401}
— Sessions
rafraîchir (Sami) → 200
réutiliser l'ancien refresh → 403
PATCH /api/utilisateurs/2/actif → 200 {"id":2,"email":"mansouri@exemple.tn","nom":"Lina Mansouri","role":"formateur","actif":false,"groupeId":null,"creeLe":"…"}
GET /api/auth/profil → 401 {"message":"Compte désactivé ou supprimé","error":"Unauthorized","statusCode":401}
rafraîchir (Lina désactivée) → 401
PATCH /api/auth/mot-de-passe → 401 {"message":"Ancien mot de passe incorrect","error":"Unauthorized","statusCode":401}
PATCH /api/auth/mot-de-passe → 204
connexion Omar avec l'ancien mot de passe → 401
connexion Omar avec le nouveau → 200

À vérifier dans vos résultats : l'inscription refuse le champ role; un utilisateur qui n'est pas formateur ne peut pas encadrer un groupe ; la formatrice ne peut pas noter Ines (autre groupe) ; chaque rôle reçoit une liste de notes différente ; la réutilisation d'un refresh token est détectée ; un compte désactivé est refusé immédiatement, même avec un jeton valide ; après un changement de mot de passe, seul le nouveau fonctionne.

Pour aller plus loin
  • Placez le refresh token dans un cookie HttpOnly (leçon 13.8, activité 2).
  • Remplacez la colonne refresh_hache par une table sessions (plusieurs appareils, liste des sessions actives, déconnexion à distance).
  • Limitez les tentatives de connexion à 5 par minute et par adresse IP avec @nestjs/throttler (chapitre 19).
  • Ajoutez la réinitialisation du mot de passe par e-mail avec un jeton à usage unique valable 30 minutes (chapitre 15).
  • Remplacez @Roles par des permissions (leçon 13.7) et ajoutez un rôle secretariat.
Correction
src/utilisateurs/utilisateur.entity.ts
import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
import { Groupe } from '../groupes/groupe.entity';

export enum Role {
  Admin = 'admin',
  Formateur = 'formateur',
  Stagiaire = 'stagiaire',
}

@Entity('utilisateurs')
export class Utilisateur {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 120, unique: true })
  email: string;

  @Column({ length: 80 })
  nom: string;

  @Column({ name: 'mot_de_passe', length: 60, select: false })
  motDePasse: string;

  @Column({ type: 'enum', enum: Role, default: Role.Stagiaire })
  role: Role;

  @Column({ default: true })
  actif: boolean;

  // Pour un stagiaire : son groupe
  @ManyToOne(() => Groupe, { nullable: true, onDelete: 'SET NULL' })
  @JoinColumn({ name: 'groupe_id' })
  groupe: Groupe | null;

  @Column({ type: 'int', name: 'groupe_id', nullable: true })
  groupeId: number | null;

  @Column({ type: 'char', name: 'refresh_hache', length: 64, nullable: true, select: false })
  refreshHache: string | null;

  @CreateDateColumn({ name: 'cree_le' })
  creeLe: Date;
}
src/groupes/groupe.entity.ts
import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
import { Utilisateur } from '../utilisateurs/utilisateur.entity';

@Entity('groupes')
export class Groupe {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 10, unique: true })
  code: string;

  @Column({ length: 80 })
  intitule: string;

  // Le formateur responsable du groupe
  @ManyToOne(() => Utilisateur, { nullable: false })
  @JoinColumn({ name: 'formateur_id' })
  formateur: Utilisateur;

  @Column({ name: 'formateur_id' })
  formateurId: number;
}
src/notes/note.entity.ts
import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
import { Utilisateur } from '../utilisateurs/utilisateur.entity';

@Entity('notes')
export class Note {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 30 })
  matiere: string;

  @Column({ type: 'decimal', precision: 4, scale: 2, transformer: { to: (v: number) => v, from: (v: string) => Number(v) } })
  valeur: number;

  @ManyToOne(() => Utilisateur, { nullable: false, onDelete: 'CASCADE' })
  @JoinColumn({ name: 'stagiaire_id' })
  stagiaire: Utilisateur;

  @Column({ name: 'stagiaire_id' })
  stagiaireId: number;

  @ManyToOne(() => Utilisateur, { nullable: false })
  @JoinColumn({ name: 'saisie_par' })
  saisiePar: Utilisateur;

  @Column({ name: 'saisie_par' })
  saisieParId: number;

  @CreateDateColumn({ name: 'cree_le' })
  creeLe: Date;
}
src/data-source.ts
import 'dotenv/config';
import { DataSource } from 'typeorm';

export default new DataSource({
  type: 'mysql',
  host: process.env.DB_HOTE,
  port: Number(process.env.DB_PORT ?? 3306),
  username: process.env.DB_UTILISATEUR,
  password: process.env.DB_MOT_DE_PASSE,
  database: process.env.DB_NOM,
  entities: [__dirname + '/**/*.entity.js'],
  migrations: [__dirname + '/migrations/*.js'],
});
src/auth/decorators.ts
import { createParamDecorator, ExecutionContext, SetMetadata } from '@nestjs/common';
import { Role } from '../utilisateurs/utilisateur.entity';

export const EST_PUBLIC = 'estPublic';
export const Public = () => SetMetadata(EST_PUBLIC, true);

export const ROLES = 'roles';
export const Roles = (...roles: Role[]) => SetMetadata(ROLES, roles);

export interface UtilisateurConnecte {
  id: number;
  email: string;
  nom: string;
  role: Role;
  groupeId: number | null;
}

export const Utilisateur = createParamDecorator((champ: keyof UtilisateurConnecte | undefined, ctx: ExecutionContext) => {
  const user = ctx.switchToHttp().getRequest().user as UtilisateurConnecte;
  return champ ? user?.[champ] : user;
});
src/auth/guards.ts
import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { Role } from '../utilisateurs/utilisateur.entity';
import { EST_PUBLIC, ROLES } from './decorators';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  constructor(private readonly reflector: Reflector) {
    super();
  }

  canActivate(context: ExecutionContext) {
    if (this.reflector.getAllAndOverride<boolean>(EST_PUBLIC, [context.getHandler(), context.getClass()])) return true;
    return super.canActivate(context);
  }
}

@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()]);
    const user = context.switchToHttp().getRequest().user;
    if (!roles?.length || !user) return true;
    if (!roles.includes(user.role)) throw new ForbiddenException(`Accès réservé : ${roles.join(', ')}`);
    return true;
  }
}
src/auth/jwt.strategy.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PassportStrategy } from '@nestjs/passport';
import { InjectRepository } from '@nestjs/typeorm';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { Repository } from 'typeorm';
import { Utilisateur } from '../utilisateurs/utilisateur.entity';
import { UtilisateurConnecte } from './decorators';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(
    config: ConfigService,
    @InjectRepository(Utilisateur) private readonly depot: Repository<Utilisateur>,
  ) {
    super({ jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), secretOrKey: config.getOrThrow<string>('JWT_SECRET') });
  }

  async validate(charge: { sub: number }): Promise<UtilisateurConnecte> {
    const u = await this.depot.findOneBy({ id: charge.sub });
    if (!u || !u.actif) throw new UnauthorizedException('Compte désactivé ou supprimé');
    return { id: u.id, email: u.email, nom: u.nom, role: u.role, groupeId: u.groupeId };   // rôle relu en base : toujours à jour
  }
}
src/auth/auth.dto.ts
import { IsEmail, IsJWT, IsString, Length, Matches, MinLength } from 'class-validator';

const FORT = /(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/;
const MESSAGE = 'Le mot de passe doit contenir au moins 8 caractères dont une minuscule, une majuscule et un chiffre';

export class InscriptionDto {
  @IsEmail() email: string;
  @IsString() @Length(2, 80) nom: string;
  @IsString() @MinLength(8, { message: MESSAGE }) @Matches(FORT, { message: MESSAGE }) motDePasse: string;
}

export class ConnexionDto {
  @IsEmail() email: string;
  @IsString() motDePasse: string;
}

export class RafraichirDto {
  @IsJWT() refreshToken: string;
}

export class ChangerMotDePasseDto {
  @IsString() ancien: string;
  @IsString() @MinLength(8, { message: MESSAGE }) @Matches(FORT, { message: MESSAGE }) nouveau: string;
}
src/auth/auth.service.ts
import { ConflictException, ForbiddenException, Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { JwtService } from '@nestjs/jwt';
import { InjectRepository } from '@nestjs/typeorm';
import * as bcrypt from 'bcrypt';
import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
import { QueryFailedError, Repository } from 'typeorm';
import { Role, Utilisateur } from '../utilisateurs/utilisateur.entity';
import { ChangerMotDePasseDto, ConnexionDto, InscriptionDto } from './auth.dto';

const COUT = 10;
const sha256 = (t: string) => createHash('sha256').update(t).digest('hex');
// Hachage factice : même durée de calcul quand l'e-mail est inconnu (évite de deviner les comptes au chronomètre)
const HACHAGE_FACTICE = bcrypt.hashSync('mot-de-passe-factice', COUT);

@Injectable()
export class AuthService {
  constructor(
    @InjectRepository(Utilisateur) private readonly depot: Repository<Utilisateur>,
    private readonly jwt: JwtService,
    private readonly config: ConfigService,
  ) {}

  async creerCompte(donnees: { email: string; nom: string; motDePasse: string; role?: Role }) {
    try {
      const u = await this.depot.save(this.depot.create({
        email: donnees.email.toLowerCase(), nom: donnees.nom, role: donnees.role ?? Role.Stagiaire,
        motDePasse: await bcrypt.hash(donnees.motDePasse, COUT),
      }));
      return { id: u.id, email: u.email, nom: u.nom, role: u.role };
    } catch (e) {
      if (e instanceof QueryFailedError && (e as any).code === 'ER_DUP_ENTRY') throw new ConflictException('Un compte existe déjà avec cet e-mail');
      throw e;
    }
  }

  inscrire(dto: InscriptionDto) {
    return this.creerCompte(dto);                                   // inscription publique : toujours stagiaire
  }

  async connecter({ email, motDePasse }: ConnexionDto) {
    const u = await this.depot.findOne({
      where: { email: email.toLowerCase() },
      select: { id: true, email: true, role: true, actif: true, motDePasse: true },
    });
    const ok = await bcrypt.compare(motDePasse, u?.motDePasse ?? HACHAGE_FACTICE);
    if (!u || !ok || !u.actif) throw new UnauthorizedException('E-mail ou mot de passe incorrect');
    return this.emettre(u);
  }

  private async emettre(u: { id: number; email: string; role: Role }) {
    const [access_token, refresh_token] = await Promise.all([
      this.jwt.signAsync({ sub: u.id, email: u.email, role: u.role }),
      this.jwt.signAsync({ sub: u.id, jti: randomUUID() }, {
        secret: this.config.getOrThrow('JWT_REFRESH_SECRET'),
        expiresIn: this.config.get('JWT_REFRESH_DUREE', '7d'),
      }),
    ]);
    await this.depot.update({ id: u.id }, { refreshHache: sha256(refresh_token) });
    return { access_token, refresh_token, token_type: 'Bearer' };
  }

  async rafraichir(refreshToken: string) {
    let id: number;
    try {
      ({ sub: id } = await this.jwt.verifyAsync<{ sub: number }>(refreshToken, { secret: this.config.getOrThrow('JWT_REFRESH_SECRET') }));
    } catch {
      throw new UnauthorizedException('Refresh token invalide ou expiré');
    }
    const u = await this.depot.findOne({ where: { id }, select: { id: true, email: true, role: true, actif: true, refreshHache: true } });
    if (!u || !u.actif || !u.refreshHache) throw new UnauthorizedException('Session terminée');
    if (!timingSafeEqual(Buffer.from(u.refreshHache, 'hex'), Buffer.from(sha256(refreshToken), 'hex'))) {
      await this.depot.update({ id }, { refreshHache: null });
      throw new ForbiddenException('Refresh token déjà utilisé : session révoquée');
    }
    return this.emettre(u);
  }

  async deconnecter(id: number) {
    await this.depot.update({ id }, { refreshHache: null });
  }

  async changerMotDePasse(id: number, { ancien, nouveau }: ChangerMotDePasseDto) {
    const u = await this.depot.findOne({ where: { id }, select: { id: true, motDePasse: true } });
    if (!u || !(await bcrypt.compare(ancien, u.motDePasse))) throw new UnauthorizedException('Ancien mot de passe incorrect');
    await this.depot.update({ id }, { motDePasse: await bcrypt.hash(nouveau, COUT), refreshHache: null });   // déconnecte les sessions
  }
}
src/auth/auth.controller.ts
import { Body, Controller, Get, HttpCode, Patch, Post } from '@nestjs/common';
import { ChangerMotDePasseDto, ConnexionDto, InscriptionDto, RafraichirDto } from './auth.dto';
import { AuthService } from './auth.service';
import { Public, Utilisateur, UtilisateurConnecte } from './decorators';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Public() @Post('inscription')
  inscrire(@Body() dto: InscriptionDto) {
    return this.authService.inscrire(dto);
  }

  @Public() @Post('connexion') @HttpCode(200)
  connecter(@Body() dto: ConnexionDto) {
    return this.authService.connecter(dto);
  }

  @Public() @Post('rafraichir') @HttpCode(200)
  rafraichir(@Body() dto: RafraichirDto) {
    return this.authService.rafraichir(dto.refreshToken);
  }

  @Post('deconnexion') @HttpCode(204)
  deconnecter(@Utilisateur('id') id: number) {
    return this.authService.deconnecter(id);
  }

  @Get('profil')
  profil(@Utilisateur() u: UtilisateurConnecte) {
    return u;
  }

  @Patch('mot-de-passe') @HttpCode(204)
  changerMotDePasse(@Utilisateur('id') id: number, @Body() dto: ChangerMotDePasseDto) {
    return this.authService.changerMotDePasse(id, dto);
  }
}
src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { APP_GUARD } from '@nestjs/core';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Utilisateur } from '../utilisateurs/utilisateur.entity';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { JwtAuthGuard, RolesGuard } from './guards';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    TypeOrmModule.forFeature([Utilisateur]),
    PassportModule,
    JwtModule.registerAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        secret: config.getOrThrow<string>('JWT_SECRET'),
        signOptions: { expiresIn: config.get('JWT_DUREE', '15m') },
      }),
    }),
  ],
  controllers: [AuthController],
  providers: [
    AuthService,
    JwtStrategy,
    { provide: APP_GUARD, useClass: JwtAuthGuard },
    { provide: APP_GUARD, useClass: RolesGuard },
  ],
  exports: [AuthService],
})
export class AuthModule {}
src/utilisateurs/utilisateurs.controller.ts
import { Body, Controller, Get, NotFoundException, Param, ParseIntPipe, Patch, Post } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { IsBoolean, IsEnum } from 'class-validator';
import { Repository } from 'typeorm';
import { InscriptionDto } from '../auth/auth.dto';
import { AuthService } from '../auth/auth.service';
import { Roles, Utilisateur as Moi } from '../auth/decorators';
import { Role, Utilisateur } from './utilisateur.entity';

class CreerCompteDto extends InscriptionDto {
  @IsEnum(Role) role: Role;
}
class RoleDto {
  @IsEnum(Role) role: Role;
}
class ActifDto {
  @IsBoolean() actif: boolean;
}

@Controller('utilisateurs')
@Roles(Role.Admin)                                        // tout le contrôleur est réservé à l'admin
export class UtilisateursController {
  constructor(
    @InjectRepository(Utilisateur) private readonly depot: Repository<Utilisateur>,
    private readonly authService: AuthService,
  ) {}

  @Get()
  lister() {
    return this.depot.find({ order: { role: 'ASC', nom: 'ASC' }, select: { id: true, email: true, nom: true, role: true, actif: true, groupeId: true } });
  }

  @Post()
  creer(@Body() dto: CreerCompteDto) {
    return this.authService.creerCompte(dto);
  }

  @Patch(':id/role')
  async changerRole(@Param('id', ParseIntPipe) id: number, @Body() { role }: RoleDto) {
    const r = await this.depot.update({ id }, { role, refreshHache: null });      // le changement prend effet à la prochaine connexion
    if (!r.affected) throw new NotFoundException(`Utilisateur ${id} introuvable`);
    return this.depot.findOneBy({ id });
  }

  @Patch(':id/actif')
  async activer(@Param('id', ParseIntPipe) id: number, @Body() { actif }: ActifDto, @Moi('id') moi: number) {
    if (id === moi && !actif) throw new NotFoundException('Vous ne pouvez pas désactiver votre propre compte');
    const r = await this.depot.update({ id }, { actif, ...(actif ? {} : { refreshHache: null }) });
    if (!r.affected) throw new NotFoundException(`Utilisateur ${id} introuvable`);
    return this.depot.findOneBy({ id });
  }
}
src/utilisateurs/utilisateurs.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from '../auth/auth.module';
import { Utilisateur } from './utilisateur.entity';
import { UtilisateursController } from './utilisateurs.controller';

@Module({
  imports: [TypeOrmModule.forFeature([Utilisateur]), AuthModule],
  controllers: [UtilisateursController],
})
export class UtilisateursModule {}
src/groupes/groupes.controller.ts
import { BadRequestException, Body, Controller, Get, NotFoundException, Param, ParseIntPipe, Patch, Post } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { IsInt, IsString, Length } from 'class-validator';
import { Repository } from 'typeorm';
import { Roles, Utilisateur as Moi, UtilisateurConnecte } from '../auth/decorators';
import { Role, Utilisateur } from '../utilisateurs/utilisateur.entity';
import { Groupe } from './groupe.entity';

class CreerGroupeDto {
  @IsString() @Length(2, 10) code: string;
  @IsString() @Length(2, 80) intitule: string;
  @IsInt() formateurId: number;
}

@Controller('groupes')
export class GroupesController {
  constructor(
    @InjectRepository(Groupe) private readonly groupes: Repository<Groupe>,
    @InjectRepository(Utilisateur) private readonly utilisateurs: Repository<Utilisateur>,
  ) {}

  @Get()
  lister(@Moi() moi: UtilisateurConnecte) {
    const where =
      moi.role === Role.Admin ? {} : moi.role === Role.Formateur ? { formateurId: moi.id } : { id: moi.groupeId ?? 0 };
    return this.groupes.find({ where, relations: { formateur: true }, order: { code: 'ASC' } });
  }

  @Post()
  @Roles(Role.Admin)
  async creer(@Body() dto: CreerGroupeDto) {
    const formateur = await this.utilisateurs.findOneBy({ id: dto.formateurId, role: Role.Formateur });
    if (!formateur) throw new BadRequestException(`L'utilisateur ${dto.formateurId} n'est pas un formateur`);
    return this.groupes.save(this.groupes.create({ code: dto.code.toUpperCase(), intitule: dto.intitule, formateurId: formateur.id }));
  }

  @Patch(':id/stagiaires/:stagiaireId')
  @Roles(Role.Admin)
  async affecter(@Param('id', ParseIntPipe) id: number, @Param('stagiaireId', ParseIntPipe) stagiaireId: number) {
    if (!(await this.groupes.existsBy({ id }))) throw new NotFoundException(`Groupe ${id} introuvable`);
    const r = await this.utilisateurs.update({ id: stagiaireId, role: Role.Stagiaire }, { groupeId: id });
    if (!r.affected) throw new NotFoundException(`Stagiaire ${stagiaireId} introuvable`);
    return { stagiaireId, groupeId: id };
  }
}
src/notes/notes.service.ts
import { ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { UtilisateurConnecte } from '../auth/decorators';
import { Groupe } from '../groupes/groupe.entity';
import { Role, Utilisateur } from '../utilisateurs/utilisateur.entity';
import { Note } from './note.entity';

@Injectable()
export class NotesService {
  constructor(
    @InjectRepository(Note) private readonly notes: Repository<Note>,
    @InjectRepository(Utilisateur) private readonly utilisateurs: Repository<Utilisateur>,
    @InjectRepository(Groupe) private readonly groupes: Repository<Groupe>,
  ) {}

  lister(moi: UtilisateurConnecte) {
    const qb = this.notes
      .createQueryBuilder('n')
      .innerJoin('n.stagiaire', 's')
      .leftJoin('s.groupe', 'g')
      .select(['n.id', 'n.matiere', 'n.valeur', 'n.stagiaireId', 's.nom', 'g.code'])
      .orderBy('s.nom')
      .addOrderBy('n.matiere');
    if (moi.role === Role.Stagiaire) qb.where('n.stagiaireId = :id', { id: moi.id });           // ses notes
    if (moi.role === Role.Formateur) qb.where('g.formateurId = :id', { id: moi.id });           // ses groupes
    return qb.getMany();
  }

  async ajouter(moi: UtilisateurConnecte, dto: { stagiaireId: number; matiere: string; valeur: number }) {
    const stagiaire = await this.utilisateurs.findOne({ where: { id: dto.stagiaireId, role: Role.Stagiaire }, relations: { groupe: true } });
    if (!stagiaire) throw new NotFoundException(`Stagiaire ${dto.stagiaireId} introuvable`);
    if (moi.role === Role.Formateur && stagiaire.groupe?.formateurId !== moi.id) {
      throw new ForbiddenException("Ce stagiaire n'appartient pas à l'un de vos groupes");
    }
    const note = await this.notes.save(this.notes.create({ ...dto, saisieParId: moi.id }));
    return { id: note.id, stagiaire: stagiaire.nom, matiere: note.matiere, valeur: note.valeur };
  }

  async supprimer(id: number) {
    const r = await this.notes.delete({ id });
    if (!r.affected) throw new NotFoundException(`Note ${id} introuvable`);
  }
}
src/notes/notes.controller.ts
import { Body, Controller, Delete, Get, HttpCode, Param, ParseIntPipe, Post } from '@nestjs/common';
import { IsIn, IsInt, IsNumber, Max, Min } from 'class-validator';
import { Roles, Utilisateur, UtilisateurConnecte } from '../auth/decorators';
import { Role } from '../utilisateurs/utilisateur.entity';
import { NotesService } from './notes.service';

class CreerNoteDto {
  @IsInt() stagiaireId: number;
  @IsIn(['SQL', 'JS', 'PHP', 'Anglais']) matiere: string;
  @IsNumber({ maxDecimalPlaces: 2 }) @Min(0) @Max(20) valeur: number;
}

@Controller('notes')
export class NotesController {
  constructor(private readonly notesService: NotesService) {}

  @Get()
  lister(@Utilisateur() moi: UtilisateurConnecte) {
    return this.notesService.lister(moi);
  }

  @Post()
  @Roles(Role.Formateur, Role.Admin)
  ajouter(@Utilisateur() moi: UtilisateurConnecte, @Body() dto: CreerNoteDto) {
    return this.notesService.ajouter(moi, dto);
  }

  @Delete(':id')
  @Roles(Role.Admin)
  @HttpCode(204)
  supprimer(@Param('id', ParseIntPipe) id: number) {
    return this.notesService.supprimer(id);
  }
}
src/scolarite.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Groupe } from './groupes/groupe.entity';
import { GroupesController } from './groupes/groupes.controller';
import { Note } from './notes/note.entity';
import { NotesController } from './notes/notes.controller';
import { NotesService } from './notes/notes.service';
import { Utilisateur } from './utilisateurs/utilisateur.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Groupe, Note, Utilisateur])],
  controllers: [GroupesController, NotesController],
  providers: [NotesService],
})
export class ScolariteModule {}
src/app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from './auth/auth.module';
import { ScolariteModule } from './scolarite.module';
import { UtilisateursModule } from './utilisateurs/utilisateurs.module';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'mysql',
        host: config.getOrThrow('DB_HOTE'),
        port: Number(config.get('DB_PORT', 3306)),
        username: config.getOrThrow('DB_UTILISATEUR'),
        password: config.get('DB_MOT_DE_PASSE', ''),
        database: config.getOrThrow('DB_NOM'),
        autoLoadEntities: true,
        synchronize: false,
      }),
    }),
    AuthModule,
    UtilisateursModule,
    ScolariteModule,
  ],
})
export class AppModule {}
src/seeds/admin.seed.ts
import 'reflect-metadata';
import * as bcrypt from 'bcrypt';
import source from '../data-source';
import { Role, Utilisateur } from '../utilisateurs/utilisateur.entity';

// Crée le premier administrateur à partir des variables d'environnement (jamais écrit dans le code)
async function semer() {
  const email = process.env.ADMIN_EMAIL;
  const motDePasse = process.env.ADMIN_MOT_DE_PASSE;
  if (!email || !motDePasse) throw new Error('ADMIN_EMAIL et ADMIN_MOT_DE_PASSE sont obligatoires');
  await source.initialize();
  const depot = source.getRepository(Utilisateur);
  if (await depot.existsBy({ email })) {
    console.log(`L'administrateur ${email} existe déjà`);
  } else {
    await depot.save(depot.create({ email, nom: 'Administrateur', role: Role.Admin, motDePasse: await bcrypt.hash(motDePasse, 10) }));
    console.log(`Administrateur ${email} créé`);
  }
  await source.destroy();
}
semer().catch((e) => {
  console.error('Seeder en échec :', e.message);
  process.exit(1);
});
src/main.ts
import { ValidationPipe } 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');
  app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();
Grille d'évaluation
CritèrePoints
Dépôt GitHub dès la Partie 1, commits clairs, aucun secret versionné, .env.example, étiquette v1.0.02
Entités, migration, seeder admin à partir de l'environnement2
Inscription et connexion : bcrypt, rôle imposé, message et durée identiques, mot de passe jamais renvoyé3
JWT : configuration, stratégie qui relit l'utilisateur, guard global, @Public3
Refresh tokens : secrets distincts, empreinte SHA-256, rotation, détection de réutilisation, déconnexion3
Rôles : RolesGuard, ordre des guards, routes d'administration2
Propriété : listes filtrées en SQL, saisie limitée aux stagiaires du formateur3
Fichier .http couvrant les refus, README avec tableau des droits2
Total20

Cet article vous a-t-il aidé ?