À propos de ce cours
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.
Trois modules, deux guards globaux, trois tables.
Cahier des charges
| Rôle | Peut |
|---|---|
| admin | tout ; 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 |
| formateur | voir les groupes qu'il encadre et les notes de leurs stagiaires ; saisir des notes pour ses stagiaires uniquement |
| stagiaire | s'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
nest new api-scolarite-securisee --package-manager npm --strict; dépôt GitHub public ; vérifiez que.envest dans.gitignore.npm install @nestjs/config @nestjs/typeorm typeorm mysql2 @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt class-validator class-transformeretnpm install -D @types/passport-jwt @types/bcrypt.- Générez deux secrets :
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))". Créez.env(ci-dessous) et.env.example. - 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
- Entités
Utilisateur(mot de passe et empreinte du refresh token enselect: false),Groupe(formateur responsable),Note(stagiaire, auteur de la saisie). data-source.ts, scripts de migration (leçon 11.8), migrationInitialisationrelue puis exécutée.- Seeder
src/seeds/admin.seed.ts: crée l'administrateur s'il n'existe pas ; script npmseed:admin. - Commit :
db: entités, migration initiale et seeder admin.
Partie 3 AuthModule : comptes et jetons
- DTO d'inscription, de connexion, de rafraîchissement (
@IsJWT()) et de changement de mot de passe. 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.JwtStrategyqui relit l'utilisateur (actif, rôle et groupe à jour).- Commit :
feat: authentification JWT avec refresh tokens.
Partie 4 Guards et décorateurs
@Public(),@Roles(),@Utilisateur()danssrc/auth/decorators.ts.JwtAuthGuardetRolesGuard, enregistrés avecAPP_GUARDdans cet ordre.- Routes d'
AuthControlleravec les bons@Public(). - Commit :
feat: guards globaux et rôles.
Partie 5 Utilisateurs, groupes et notes
UtilisateursControllerentièrement réservé à l'admin (@Rolessur la classe) : liste, création de comptes, changement de rôle, activation. Chaque modification sensible efface l'empreinte du refresh token.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.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.- Commit :
feat: utilisateurs, groupes et notes.
Partie 6 Tester, documenter et livrer
requetes/scolarite.http(base ci-dessous) : complétez-le pour couvrir chaque ligne du cahier des charges, y compris les refus (401, 403, 409).- Vérifiez avec
git grep -i secretqu'aucun secret n'est dans le dépôt. - README : installation (base,
.env, migration, seeder), tableau des droits par rôle, cycle de vie des jetons. npm run lint,npm run build, commit, push, étiquettev1.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_hachepar une tablesessions(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
@Rolespar des permissions (leçon 13.7) et ajoutez un rôlesecretariat.
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ère | Points |
|---|---|
Dépôt GitHub dès la Partie 1, commits clairs, aucun secret versionné, .env.example, étiquette v1.0.0 | 2 |
| Entités, migration, seeder admin à partir de l'environnement | 2 |
| 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, @Public | 3 |
| Refresh tokens : secrets distincts, empreinte SHA-256, rotation, détection de réutilisation, déconnexion | 3 |
| Rôles : RolesGuard, ordre des guards, routes d'administration | 2 |
| Propriété : listes filtrées en SQL, saisie limitée aux stagiaires du formateur | 3 |
| Fichier .http couvrant les refus, README avec tableau des droits | 2 |
| Total | 20 |
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !