À propos de ce cours
Objectifs de la leçon
- Comprendre le fonctionnement « autour » d'un intercepteur.
- Utiliser next.handle() et les opérateurs RxJS map, tap, timeout, catchError.
- Écrire des intercepteurs de durée, d'enveloppe, de cache et de délai.
- Connaître l'ordre complet d'exécution d'une requête NestJS.
Un intercepteur entoure le handler
Un intercepteur implémente NestInterceptor. Sa méthode intercept(context, next) est appelée avant le handler ; elle appelle next.handle() pour exécuter le handler, et reçoit en retour un Observable (RxJS) qui émettra la valeur renvoyée par le handler. En ajoutant des opérateurs à cet Observable, on agit après le handler.
intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
// AVANT le handler
return next.handle().pipe(
// APRÈS le handler : map (transformer), tap (observer), catchError, timeout…
);
}
RxJS en bref (chapitre 03) : map(f) remplace la valeur par f(valeur); tap(f) exécute f sans modifier la valeur ; catchError(f) intercepte une erreur ; timeout(ms) lève une TimeoutError si rien n'arrive à temps ; of(v) crée un Observable qui émet v.
Quatre intercepteurs
nest g interceptor common/interceptors/duree --no-spec
📄 src/common/interceptors/duree.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Response } from 'express';
import { Observable, tap } from 'rxjs';
@Injectable()
export class DureeInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
const debut = performance.now(); // AVANT le handler
const nom = `${context.getClass().name}.${context.getHandler().name}`;
return next.handle().pipe(
tap(() => { // APRÈS le handler
const ms = (performance.now() - debut).toFixed(1);
context.switchToHttp().getResponse<Response>().setHeader('X-Duree-Ms', ms);
console.log(` [Duree] ${nom} : ${ms} ms`);
}),
);
}
}
📄 src/common/interceptors/enveloppe.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { map, Observable } from 'rxjs';
export interface Enveloppe<T> {
succes: true;
donnees: T;
meta: { total?: number; horodatage: string };
}
@Injectable()
export class EnveloppeInterceptor<T> implements NestInterceptor<T, Enveloppe<T>> {
intercept(context: ExecutionContext, next: CallHandler<T>): Observable<Enveloppe<T>> {
return next.handle().pipe(
map((donnees) => ({
succes: true,
donnees,
meta: { ...(Array.isArray(donnees) ? { total: donnees.length } : {}), horodatage: new Date().toISOString() },
})),
);
}
}
📄 src/common/interceptors/cache-memoire.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Request } from 'express';
import { Observable, of, tap } from 'rxjs';
// Cache en mémoire très simple pour les GET (démonstration)
@Injectable()
export class CacheMemoireInterceptor implements NestInterceptor {
private readonly cache = new Map<string, { valeur: unknown; expire: number }>();
intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
const req = context.switchToHttp().getRequest<Request>();
if (req.method !== 'GET') return next.handle();
const cle = req.originalUrl;
const entree = this.cache.get(cle);
if (entree && entree.expire > Date.now()) {
console.log(` [Cache] ${cle} servi depuis le cache`);
return of(entree.valeur); // le handler n'est PAS appelé
}
return next.handle().pipe(
tap((valeur) => this.cache.set(cle, { valeur, expire: Date.now() + 30_000 })), // 30 s
);
}
}
📄 src/common/interceptors/delai.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor, RequestTimeoutException } from '@nestjs/common';
import { catchError, Observable, throwError, timeout, TimeoutError } from 'rxjs';
@Injectable()
export class DelaiInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
return next.handle().pipe(
timeout(500), // 500 ms au plus
catchError((err) =>
throwError(() => (err instanceof TimeoutError ? new RequestTimeoutException('Le traitement a pris trop de temps') : err)),
),
);
}
}
📄 src/stagiaires.controller.ts
import { Controller, Get, Param, ParseIntPipe, UseInterceptors } from '@nestjs/common';
import { CacheMemoireInterceptor } from './cache-memoire.interceptor';
import { DelaiInterceptor } from './delai.interceptor';
let appelsStatistiques = 0;
@Controller('stagiaires')
export class StagiairesController {
@Get()
findAll() {
return ['Ben Ali', 'Trabelsi', 'Gharbi'];
}
@Get('statistiques')
@UseInterceptors(CacheMemoireInterceptor)
async statistiques() {
appelsStatistiques++;
await new Promise((r) => setTimeout(r, 120)); // calcul « coûteux »
return { moyenne: 13.4, appelsStatistiques };
}
@Get('rapport/:secondes')
@UseInterceptors(DelaiInterceptor)
async rapport(@Param('secondes', ParseIntPipe) secondes: number) {
await new Promise((r) => setTimeout(r, secondes * 1000));
return { rapport: 'prêt' };
}
}
Les deux premiers sont globaux, les deux autres limités à une route :
app.useGlobalInterceptors(new DureeInterceptor(), new EnveloppeInterceptor()); // main.ts
await appel('GET', '/api/stagiaires', { voir: ['x-duree-ms'] });
await appel('GET', '/api/stagiaires/statistiques');
await appel('GET', '/api/stagiaires/statistiques'); // deuxième appel
await appel('GET', '/api/stagiaires/rapport/0');
await appel('GET', '/api/stagiaires/rapport/1'); // dure 1 s, délai maximal 500 ms
await appel('GET', '/api/stagiaires/rapport/abc');
Résultat réellement obtenu :
[Duree] StagiairesController.findAll : 1.4 ms
GET /api/stagiaires → 200 {"succes":true,"donnees":["Ben Ali","Trabelsi","Gharbi"],"meta":{"total":3,"horodatage":"2026-11-15T07:12:35.440Z"}} [x-duree-ms: 1.4]
[Duree] StagiairesController.statistiques : 121.2 ms
GET /api/stagiaires/statistiques → 200 {"succes":true,"donnees":{"moyenne":13.4,"appelsStatistiques":1},"meta":{"horodatage":"2026-11-15T07:12:35.577Z"}}
[Cache] /api/stagiaires/statistiques servi depuis le cache
[Duree] StagiairesController.statistiques : 0.5 ms
GET /api/stagiaires/statistiques → 200 {"succes":true,"donnees":{"moyenne":13.4,"appelsStatistiques":1},"meta":{"horodatage":"2026-11-15T07:12:35.581Z"}}
[Duree] StagiairesController.rapport : 2.4 ms
GET /api/stagiaires/rapport/0 → 200 {"succes":true,"donnees":{"rapport":"prêt"},"meta":{"horodatage":"2026-11-15T07:12:35.586Z"}}
GET /api/stagiaires/rapport/1 → 408 {"message":"Le traitement a pris trop de temps","error":"Request Timeout","statusCode":408}
GET /api/stagiaires/rapport/abc → 400 {"message":"Validation failed (numeric string is expected)","error":"Bad Request","statusCode":400}
Ce qu'il faut observer
- Enveloppe: le handler renvoie un simple tableau, le client reçoit
{ succes, donnees, meta }avec le total. Aucun handler n'a été modifié. - Durée: l'intercepteur connaît le contrôleur et la méthode (
context.getClass(),getHandler()), ce que le middleware ne pouvait pas savoir, et ajoute l'en-têteX-Duree-Ms. - Cache: le premier appel prend 121 ms ; le second est servi en moins d'une milliseconde, et
appelsStatistiquesreste à 1 : le handler n'a pas été exécuté. L'intercepteur a renvoyéof(valeur)sans appelernext.handle(). - Délai: le rapport d'une seconde est interrompu au bout de 500 ms avec un 408. Remarquez qu'il n'y a pas de ligne
[Duree]: en cas d'erreur,tapn'est pas appelé, et l'enveloppe non plus. Les erreurs sont traitées par les filtres. - Pour
abc, l'erreur vient du pipe : elle survient à l'intérieur denext.handle().
Cache réel: notre cache en mémoire est pédagogique (pas de limite de taille, pas d'invalidation après modification). En production, on utilise le module officiel @nestjs/cache-manager, qui fournit un CacheInterceptor et peut stocker dans Redis. Attention aussi : un cache par URL ne doit pas être utilisé sur des routes dont la réponse dépend de l'utilisateur connecté.
L'ordre complet d'une requête
Middleware, guard, intercepteur, pipe, handler, puis retour par l'intercepteur ; les filtres en cas d'erreur.
Pour le vérifier, chaque élément affiche son passage :
📄 src/trace.ts
import {
ArgumentsHost, CallHandler, CanActivate, Catch, ExceptionFilter, ExecutionContext, HttpException, Injectable,
NestInterceptor, NestMiddleware, PipeTransform,
} from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { Observable, tap } from 'rxjs';
@Injectable()
export class TraceMiddleware implements NestMiddleware {
use(req: Request, res: Response, next: NextFunction) { console.log('1. middleware'); next(); }
}
@Injectable()
export class TraceGuard implements CanActivate {
canActivate(): boolean { console.log('2. guard'); return true; }
}
@Injectable()
export class TraceInterceptor implements NestInterceptor {
intercept(ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
console.log('3. intercepteur (avant)');
return next.handle().pipe(tap(() => console.log('6. intercepteur (après)')));
}
}
@Injectable()
export class TracePipe implements PipeTransform {
transform(v: string) {
console.log('4. pipe');
if (v === 'erreur') throw new HttpException('valeur refusée par le pipe', 400);
return v;
}
}
@Catch(HttpException)
export class TraceFilter implements ExceptionFilter {
catch(e: HttpException, host: ArgumentsHost) {
console.log('→ filtre d\'exception');
host.switchToHttp().getResponse<Response>().status(e.getStatus()).json({ filtre: true, message: e.message });
}
}
📄 src/cycle.controller.ts
import { Controller, Get, Param, UseFilters, UseGuards, UseInterceptors } from '@nestjs/common';
import { TraceFilter, TraceGuard, TraceInterceptor, TracePipe } from './trace';
@Controller('cycle')
@UseGuards(TraceGuard)
@UseInterceptors(TraceInterceptor)
@UseFilters(TraceFilter)
export class CycleController {
@Get(':v')
get(@Param('v', TracePipe) v: string) {
console.log('5. handler');
return { v };
}
}
Résultat réellement obtenu :
1. middleware
2. guard
3. intercepteur (avant)
4. pipe
5. handler
6. intercepteur (après)
GET /api/cycle/ok → 200 {"v":"ok"}
---
1. middleware
2. guard
3. intercepteur (avant)
4. pipe
→ filtre d'exception
GET /api/cycle/erreur → 400 {"filtre":true,"message":"valeur refusée par le pipe"}
| Élément | Rôle | Connaît le handler ? | Voit la réponse ? |
|---|---|---|---|
| Middleware | préparer la requête, journal | non | non (sauf via res) |
| Guard | autoriser ou refuser | oui | non |
| Intercepteur | logique avant/après, transformer la réponse | oui | oui |
| Pipe | valider et transformer les arguments | par metadata | non |
| Filtre | construire la réponse d'erreur | non (via host) | c'est lui qui la produit |
Avec plusieurs intercepteurs (global, contrôleur, méthode), la partie « avant » s'exécute dans l'ordre global → contrôleur → méthode, et la partie « après » dans l'ordre inverse, comme des poupées russes.
Activités
Activité 1 Masquer des champs
Écrivez MasquerChampsInterceptor qui supprime récursivement des réponses toute propriété nommée motDePasse ou motDePasseHache. Pourquoi est-ce une protection complémentaire, et non un remplacement des DTO de sortie (leçon 8.1) ?
Voir le corrigé
const SENSIBLES = new Set(['motDePasse', 'motDePasseHache']);
function nettoyer(v: unknown): unknown {
if (Array.isArray(v)) return v.map(nettoyer);
if (v && typeof v === 'object' && !(v instanceof Date)) {
return Object.fromEntries(Object.entries(v).filter(([k]) => !SENSIBLES.has(k)).map(([k, x]) => [k, nettoyer(x)]));
}
return v;
}
@Injectable()
export class MasquerChampsInterceptor implements NestInterceptor {
intercept(_: ExecutionContext, next: CallHandler) {
return next.handle().pipe(map(nettoyer));
}
}
C'est un filet de sécurité générique : il ne connaît que quelques noms. Le DTO de sortie, lui, liste explicitement les champs publics (approche « liste blanche »), ce qui protège aussi des champs sensibles qu'on aurait oublié d'ajouter à la liste.
Activité 2 Journaliser les erreurs
Modifiez DureeInterceptor pour qu'il affiche aussi la durée en cas d'erreur, avec le statut. Indice : l'opérateur tap accepte un objet { next, error }.
Voir le corrigé
return next.handle().pipe(
tap({
next: () => console.log(`[Duree] ${nom} : ${ms()} ms`),
error: (e) => console.log(`[Duree] ${nom} : ${ms()} ms (erreur ${e?.status ?? 500})`),
}),
);
L'erreur continue ensuite vers les filtres : tap observe sans intercepter.
Activité 3 Pagination automatique
Écrivez un intercepteur qui, si le handler renvoie un tableau et que la query string contient page et limite, renvoie seulement la tranche demandée avec { donnees, page, limite, total }. Est-ce une bonne idée avec une base de données de 100 000 lignes ?
Voir le corrigé
Techniquement possible avec map et context.switchToHttp().getRequest().query. Mais avec une base de données, le handler aurait déjà chargé les 100 000 lignes avant que l'intercepteur ne découpe : la pagination doit être faite dans la requête SQL (chapitre 11, LIMIT et OFFSET). Un intercepteur peut en revanche mettre en forme le résultat déjà paginé.
Activité 4 Prédire l'ordre
Un intercepteur global A et un intercepteur de méthode B affichent tous deux « avant » et « après ». Le handler affiche « handler ». Donnez l'ordre des cinq messages.
Voir le corrigé
A avant, B avant, handler, B après, A après. A entoure B, qui entoure le handler.
À retenir
- Un intercepteur implémente intercept(context, next) : code avant, next.handle(), puis opérateurs RxJS après.
- map transforme la réponse, tap observe, timeout limite la durée, catchError traduit une erreur.
- Renvoyer of(valeur) sans appeler next.handle() court-circuite le handler (cache).
- Ordre : middleware → guard → intercepteur (avant) → pipe → handler → intercepteur (après) ; filtre en cas d'erreur.
- Globaux avec useGlobalInterceptors ou APP_INTERCEPTOR (avec injection).
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 !