À propos de ce cours
Objectifs de la leçon
- Comprendre le fonctionnement de Passport et de ses stratégies.
- Écrire une stratégie local (e-mail + mot de passe).
- Écrire une stratégie jwt qui relit l'utilisateur.
- Utiliser AuthGuard('local') et AuthGuard('jwt').
Pourquoi Passport ?
Passport propose plus de 500 stratégies d'authentification : identifiant et mot de passe (passport-local), JWT (passport-jwt), Google, GitHub, Microsoft, clés API… Toutes s'utilisent de la même façon. @nestjs/passport les transforme en guards NestJS. Notre guard de la leçon 13.4 fonctionnait ; Passport apporte une structure standard et la possibilité d'ajouter d'autres modes de connexion sans réécrire le reste.
npm install @nestjs/passport passport passport-local passport-jwt
npm install -D @types/passport-local @types/passport-jwt
Chaque stratégie a sa méthode validate, dont le résultat devient req.user.
La stratégie local
📄 src/auth/local.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-local';
import { AuthService } from './auth.service';
// Stratégie « local » : e-mail + mot de passe envoyés dans le corps
@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) { // nom par défaut : 'local'
constructor(private readonly authService: AuthService) {
super({ usernameField: 'email', passwordField: 'motDePasse' });
}
// Appelée par Passport ; ce qui est renvoyé devient req.user
validate(email: string, motDePasse: string) {
return this.authService.verifierIdentifiants({ email, motDePasse }); // lève 401 si incorrect
}
}
La stratégie jwt
📄 src/auth/jwt.strategy.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { UtilisateursService } from '../utilisateurs/utilisateurs.service';
export interface ChargeJwt {
sub: number;
email: string;
role: string;
}
// Stratégie « jwt » : jeton dans l'en-tête Authorization: Bearer …
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) { // nom par défaut : 'jwt'
constructor(
config: ConfigService,
private readonly utilisateurs: UtilisateursService,
) {
super({
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
secretOrKey: config.getOrThrow<string>('JWT_SECRET'),
ignoreExpiration: false,
});
}
// Appelée APRÈS la vérification de la signature et de l'expiration
async validate(charge: ChargeJwt) {
const utilisateur = await this.utilisateurs.findById(charge.sub);
if (!utilisateur || !utilisateur.actif) throw new UnauthorizedException('Compte désactivé ou supprimé');
return { id: utilisateur.id, email: utilisateur.email, nom: utilisateur.nom, role: utilisateur.role };
}
}
jwtFromRequest: où trouver le jeton (ici l'en-tête Bearer ; il existe aussifromExtractorspour lire un cookie).secretOrKey: le même secret que celui qui signe les jetons.validate(charge)n'est appelée que si le jeton est valide et non expiré. On y relit l'utilisateur: une requête SQL par appel, mais un compte désactivé ou supprimé est refusé immédiatement, et le rôle est toujours à jour.
Le contrôleur et le module
📄 src/auth/auth.controller.ts
import { Body, Controller, Get, HttpCode, Post, Req, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { Request } from 'express';
import { InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';
type Utilisateur = { id: number; email: string; nom: string; role: string };
@Controller('auth')
export class AuthController {
constructor(private readonly authService: AuthService) {}
@Post('inscription')
inscrire(@Body() dto: InscriptionDto) {
return this.authService.inscrire(dto);
}
@Post('connexion')
@HttpCode(200)
@UseGuards(AuthGuard('local')) // Passport vérifie e-mail + mot de passe AVANT le handler
connecter(@Req() req: Request & { user: Utilisateur }) {
return this.authService.genererJeton(req.user);
}
@Get('profil')
@UseGuards(AuthGuard('jwt')) // Passport vérifie le jeton
profil(@Req() req: Request & { user: Utilisateur }) {
return req.user;
}
}
📄 src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { UtilisateursModule } from '../utilisateurs/utilisateurs.module';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';
import { LocalStrategy } from './local.strategy';
@Module({
imports: [
UtilisateursModule,
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, LocalStrategy, JwtStrategy],
})
export class AuthModule {}
Dans AuthService, la méthode connecter devient genererJeton(utilisateur): la vérification du mot de passe est faite par la stratégie avant le handler.
const b = '/api/auth';
const port = app.getHttpServer().address().port;
await appel('POST', `${b}/inscription`, { corps: { email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' } });
await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn', motDePasse: 'mauvais' } });
await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn' } });
const r = await fetch(`http://localhost:${port}${b}/connexion`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ email: 'sami@exemple.tn', motDePasse: 'Formation2026' }) });
const { access_token } = await r.json();
console.log('POST /api/auth/connexion →', r.status, '(jeton reçu)');
await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token}` } });
await appel('GET', `${b}/profil`, { entetes: { authorization: 'Bearer abc.def.ghi' } });
await appel('GET', `${b}/profil`);
await app.get(DataSource).query("UPDATE utilisateurs SET actif = 0 WHERE email = 'sami@exemple.tn'");
console.log('(compte de Sami désactivé en base, jeton toujours valide)');
await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token}` } });
Résultat réellement obtenu :
POST /api/auth/inscription → 201 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire","actif":true,"creeLe":"…"}
POST /api/auth/connexion → 401 {"message":"E-mail ou mot de passe incorrect","error":"Unauthorized","statusCode":401}
POST /api/auth/connexion → 401 {"message":"Unauthorized","statusCode":401}
POST /api/auth/connexion → 200 (jeton reçu)
GET /api/auth/profil → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
GET /api/auth/profil → 401 {"message":"Unauthorized","statusCode":401}
GET /api/auth/profil → 401 {"message":"Unauthorized","statusCode":401}
(compte de Sami désactivé en base, jeton toujours valide)
GET /api/auth/profil → 401 {"message":"Compte désactivé ou supprimé","error":"Unauthorized","statusCode":401}
Lecture
- Mauvais mot de passe : notre
UnauthorizedException(levée parverifierIdentifiantsdansvalidate) est transmise telle quelle. - Mot de passe absent :
passport-localrefuse avant d'appelervalidate, avec le message standard « Unauthorized ». Le guard s'exécutant avant les pipes (leçon 9.4), leValidationPipen'a pas pu valider le corps. - Jeton faux ou absent : « Unauthorized » de
passport-jwt. - Compte désactivé en base : le jeton est toujours valide, mais
validaterelit l'utilisateur et le refuse.
Relire ou non l'utilisateur ? Sans relecture, validate peut simplement renvoyer la charge : aucune requête SQL, mais un compte désactivé garde l'accès jusqu'à l'expiration du jeton. Avec relecture, une requête par appel (rapide sur une clé primaire). Pour une API de gestion, la relecture est généralement préférable.
Activités
Activité 1 Des messages plus clairs
Créez LocalAuthGuard extends AuthGuard('local') et redéfinissez handleRequest(err, user, info) pour renvoyer « E-mail et mot de passe obligatoires » quand info indique des identifiants manquants.
Voir le corrigé
@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {
handleRequest<T>(err: unknown, user: T, info?: { message?: string }): T {
if (err) throw err; // notre UnauthorizedException
if (!user) {
throw new UnauthorizedException(info?.message === 'Missing credentials' ? 'E-mail et mot de passe obligatoires' : 'Authentification refusée');
}
return user;
}
}
Activité 2 Lire le jeton dans un cookie
Modifiez JwtStrategy pour accepter le jeton dans l'en-tête ou dans un cookie access_token (avec cookie-parser).
Voir le corrigé
// main.ts : app.use(cookieParser());
super({
jwtFromRequest: ExtractJwt.fromExtractors([
ExtractJwt.fromAuthHeaderAsBearerToken(),
(req: Request) => req?.cookies?.access_token ?? null,
]),
secretOrKey: config.getOrThrow<string>('JWT_SECRET'),
});
Activité 3 Sans relecture
Écrivez une variante de validate qui ne relit pas la base. Mesurez avec logging: true le nombre de requêtes SQL pour 10 appels à /auth/profil dans les deux versions. Quand préférer chaque version ?
Voir le corrigé
Sans relecture : 0 requête ; avec : 10 SELECT … WHERE id = ?. Sans relecture convient aux jetons très courts et aux microservices où l'utilisateur n'est pas dans la base locale ; avec relecture convient quand il faut pouvoir bloquer un compte immédiatement. Un cache de quelques secondes (chapitre 15) peut combiner les deux.
Activité 4 Une seconde stratégie
Ajoutez une stratégie cle-api (paquet passport-headerapikey ou stratégie personnalisée avec passport-custom) pour les applications partenaires, et protégez une route avec AuthGuard(['jwt', 'cle-api']). Que signifie ce tableau ?
Voir le corrigé
Un tableau de stratégies signifie « l'une ou l'autre » : Passport essaie la première, puis la suivante en cas d'échec. La route accepte donc un utilisateur connecté (JWT) ou une application partenaire (clé API). Chaque stratégie a son nom (second argument de PassportStrategy(Strategy, 'cle-api')).
À retenir
- @nestjs/passport transforme les stratégies Passport en guards : AuthGuard('local'), AuthGuard('jwt').
- LocalStrategy : usernameField/passwordField, validate(email, mdp) → utilisateur ou 401.
- JwtStrategy : jwtFromRequest, secretOrKey ; validate(charge) appelée après vérification du jeton.
- Ce que renvoie validate devient req.user.
- Relire l'utilisateur dans validate : compte désactivé refusé immédiatement, rôle à jour.
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 !