Interceptors omsluter exekveringen av en route handler, vilket låter dig köra logik före och efter den — och transformera requesten eller responsen. De är inspirerade av aspect-oriented programming och är ideala för cross-cutting concerns som logging, response-transformation, caching och timing.
()
{
(: , : ): <> {
.();
now = .();
next.().(
( .()),
);
}
}
En interceptor implementerar intercept(). Kod före next.handle() körs före handleren; next.handle() returnerar en RxJS Observable av responsen, och operatörer som tap/map låter dig agera på responsen efter att handleren är slutförd.
@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 }
);
}
}
Med hjälp av map kan en interceptor omforma varje respons — t.ex. genom att omsluta alla responsser i en standard-envelope, ett mycket vanligt mönster för konsistenta API-responsser.
// 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
Det definierade kännetecknet: interceptors kan köra logik efter handleren och transformera responsen — vilket middleware och guards inte kan göra på ett enkelt sätt.
Interceptors är en kraftfull NestJS-funktion för att hantera cross-cutting concerns på ett elegant sätt, och deras särskilda förmåga — att köra logik både före och efter handleren, och transformera responsen — gör dem till rätt verktyg för behov som middleware och guards inte kan adressera.
Det är viktigt att förstå dem eftersom många vanliga krav mappar naturligt till interceptors: konsistent responsformatering (omslutning av alla responsser i en standard-envelope { success, data }), logging/timing (mätning av handler-varaktighet), caching (returnering av cachade responsser), timeouts, error-transformation och serialisering (exkludering av känsliga fält).
Att förstå strukturen (RxJS Observable från next.handle(), med tap/map/catchError för att agera före/efter), de vanliga användningsfallen, och särskilt hur interceptors skiljer sig från middleware och guards (möjligheten att omsluta och transformera responsen) är en nyckelkomponent i NestJS-arkitektonisk kompetens.
Interceptors håller cross-cutting-logik DRY och centraliserad snarare än duplicerad över handlers, vilket gör dem till ett ofta använt, viktigt verktyg för att bygga rena, underhållsbara NestJS-applikationer.