Interceptors umwickeln die Ausführung eines Route Handlers, sodass Sie Logik vor und nach ihm ausführen können — und die Request oder Response transformieren. Sie sind von aspect-oriented programming inspiriert und ideal für Cross-Cutting Concerns wie Logging, Response-Transformation, Caching und Timing.
()
{
(: , : ): <> {
.();
now = .();
next.().(
( .()),
);
}
}
Ein Interceptor implementiert intercept(). Code vor next.handle() wird vor dem Handler ausgeführt; next.handle() gibt ein RxJS Observable der Response zurück, und Operatoren wie tap/map ermöglichen es Ihnen, auf die Response zu reagieren, nachdem der Handler abgeschlossen ist.
@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 }
);
}
}
Mit map kann ein Interceptor jede Response umgestalten — z.B. alle Responses in einen Standard-Envelope wrappen, ein sehr häufiges Muster für konsistente API-Responses.
// 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
Das definierende Merkmal: Interceptors können Logik nach dem Handler ausführen und die Response transformieren — was Middleware und Guards nicht sauber können.
Interceptors sind ein leistungsstarkes NestJS-Feature zur eleganten Behandlung von Cross-Cutting Concerns, und ihre unterscheidende Fähigkeit — Logik sowohl vor als auch nach dem Handler auszuführen und die Response zu transformieren — macht sie zum richtigen Werkzeug für Anforderungen, die Middleware und Guards nicht lösen können.
Das Verständnis ist wichtig, da viele häufige Anforderungen natürlich auf Interceptors abgebildet werden: konsistente Response-Formatierung (alle Responses in einen Standard-{ success, data }-Envelope wrappen), Logging/Timing (Messung der Handler-Dauer), Caching (Rückgabe gecachter Responses), Timeouts, Error-Transformation und Serialisierung (Ausschluss sensibler Felder).
Die Struktur zu kennen (das next.handle() Observable mit tap/map/catchError zur Aktion vor/nach), die häufigen Use Cases und besonders wie sich Interceptors von Middleware und Guards unterscheiden (die Fähigkeit, die Response zu wrappen und zu transformieren) ist ein wichtiger Teil der NestJS-Architektur-Kompetenz.
Interceptors halten Cross-Cutting-Logik DRY und zentralisiert, anstatt sie über Handler verteilt zu duplizieren, was sie zu einem häufig verwendeten, wichtigen Werkzeug für die Erstellung von sauberen, wartbaren NestJS-Anwendungen macht.