Interceptors huzungushia utekelezaji wa route handler, zikikuruhusu kuendesha logic kabla na baada yake — na kubadilisha request au response. Zimechochewa na aspect-oriented programming, zinafaa kwa mambo ya kupita pande mbalimbali kama logging, ubadilishaji wa response, caching, na timing.
()
{
(: , : ): <> {
.();
now = .();
next.().(
( .()),
);
}
}
Interceptor hutekeleza intercept(). Code kabla ya next.handle() huendeshwa kabla ya handler; next.handle() hurudisha RxJS Observable ya response, na operators kama tap/map zinakuruhusu kutenda juu ya response baada ya handler kukamilika.
@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 }
);
}
}
Kwa kutumia map, interceptor inaweza kuunda upya kila response — mfano kuzungushia responses zote katika envelope ya kawaida, muundo wa kawaida sana kwa API responses thabiti.
// 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
Kipengele kinachofafanua: interceptors zinaweza kuendesha logic baada ya handler na kubadilisha response — jambo ambalo middleware na guards haziwezi kufanya kwa usafi.
Interceptors ni kipengele chenye nguvu cha NestJS cha kushughulikia mambo ya kupita pande mbalimbali kwa ustadi, na uwezo wao wa kipekee — kuendesha logic kabla na baada ya handler, na kubadilisha response — huwafanya kuwa chombo sahihi kwa mahitaji ambayo middleware na guards haziwezi kushughulikia.
Kuzielewa ni muhimu kwa sababu mahitaji mengi ya kawaida huendana kiasili na interceptors: uundaji thabiti wa response (kuzungushia responses zote katika envelope ya kawaida { success, data }), logging/timing (kupima muda wa handler), caching (kurudisha cached responses), timeouts, ubadilishaji wa makosa, na serialization (kuondoa fields nyeti).
Kujua muundo (Observable ya next.handle(), pamoja na tap/map/catchError kutenda kabla/baada), matumizi ya kawaida, na hasa jinsi interceptors zinavyotofautiana na middleware na guards (uwezo wa kuzungushia na kubadilisha response) ni sehemu muhimu ya umahiri wa kiusanifu wa NestJS.
Interceptors huweka logic ya kupita pande mbalimbali ikiwa DRY na ya kati badala ya kurudiwa katika handlers nyingi, jambo linalozifanya kuwa chombo kinachotumika mara kwa mara, muhimu kwa kujenga programu za NestJS safi na zinazoweza kudumishwa.