Interceptoarele încapsulează execuția unui handler de rută, permițând rularea logicii înainte și după acesta — și transformarea request-ului sau response-ului. Sunt inspirate de programarea orientată pe aspecte, ideale pentru preocupări transversale cum ar fi logging, transformarea response-ului, caching și timing.
()
{
(: , : ): <> {
.();
now = .();
next.().(
( .()),
);
}
}
Un interceptor implementează intercept(). Codul înainte de next.handle() se rulează înainte de handler; next.handle() returnează un RxJS Observable al response-ului, iar operatori precum tap/map vă permit să acționați asupra response-ului după ce handler-ul se completează.
@Injectable()
export class TransformInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler) {
return next.handle().pipe(
map(data => ({ success: true, data, timestamp: new Date().toISOString() })),
// wraps EVERY response in a consistent envelope: { success, data, timestamp }
);
}
}
Folosind map, un interceptor poate remodela fiecare response — de exemplu, încapsulând toate response-urile într-o anvelopă standard, un model foarte frecvent pentru response-uri API consistente.
// caching — return a cached response, skipping the handler entirely
// timeout — fail requests taking too long
return next.handle().pipe(timeout(5000));
// error mapping — transform exceptions
return next.handle().pipe(catchError(err => throwError(() => new BadGatewayException())));
// excluding fields (serialization) — ClassSerializerInterceptor strips @Exclude() fields
Common interceptor uses:
✓ Logging / timing requests (before + after)
✓ Transforming responses (consistent envelopes, field exclusion)
✓ Caching responses
✓ Adding timeouts
✓ Mapping/handling errors
@UseInterceptors(LoggingInterceptor) // method or controller level
app.useGlobalInterceptors(new TransformInterceptor()); // global
Middleware → runs BEFORE everything, with raw req/res (can't easily touch the response)
Guard → AUTHORIZATION decision (allow/block) before the handler
Interceptor → wraps the handler — runs BEFORE and AFTER, can TRANSFORM the response
Caracteristica definitorie: interceptoarele pot rula logică după handler și transforma response-ul — ceea ce middleware și guards nu pot face în mod curat.
Interceptoarele sunt o caracteristică puternică a NestJS pentru gestionarea preocupărilor transversale elegant, iar capacitatea lor distinctivă — rularea logicii atât înainte cât și după handler, și transformarea response-ului — le face instrumentul potrivit pentru necesități pe care middleware și guards nu le pot aborda. Înțelegerea lor este importantă deoarece multe cerințe comune se mapează natural la interceptoare: formatare consistentă a response-ului (încapsularea tuturor response-urilor într-o anvelopă standard { success, data }), logging/timing (măsurarea duratei handler-ului), caching (returnarea response-urilor în cache), timeout-uri, transformarea erorilor și serializare (excluderea câmpurilor sensibile).
Cunoașterea structurii (Observable-ul next.handle(), cu tap/map/catchError pentru a acționa înainte/după), cazurile de utilizare comune, și în special modul în care interceptoarele diferă de middleware și guards (capacitatea de a încapsul și transforma response-ul) este o parte cheie a competenței arhitecturale NestJS.
Interceptoarele mențin logica transversală DRY și centralizată în loc să fie duplicată în handler-uri, făcândul-e un instrument frecvent utilizat și important pentru construirea aplicațiilor NestJS curate și ușor de întreținut.