Interceptors membalut pelaksanaan sesuatu route handler, membolehkan anda menjalankan logik sebelum dan selepas-nya — dan mengubah request atau response. Ia diilhamkan oleh aspect-oriented programming, sesuai untuk urusan rentas-keratan seperti logging, pengubahan response, caching, dan timing.
()
{
(: , : ): <> {
.();
now = .();
next.().(
( .()),
);
}
}
Satu interceptor melaksanakan intercept(). Kod sebelum next.handle() berjalan sebelum handler; next.handle() memulangkan satu Observable RxJS bagi response, dan operator seperti tap/map membolehkan anda bertindak ke atas response selepas handler selesai.
@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 }
);
}
}
Menggunakan map, satu interceptor boleh membentuk semula setiap response — cth. membalut semua response dalam satu envelope standard, satu corak yang sangat lazim untuk response API yang konsisten.
// 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
Ciri penentunya: interceptors boleh menjalankan logik selepas handler dan mengubah response — yang tidak boleh dilakukan oleh middleware dan guards dengan bersih.
Interceptors ialah satu ciri NestJS yang berkuasa untuk mengendalikan urusan rentas-keratan secara elegan, dan keupayaan tersendirinya — menjalankan logik kedua-dua sebelum dan selepas handler, serta mengubah response — menjadikannya alat yang betul untuk keperluan yang tidak boleh ditangani oleh middleware dan guards.
Memahaminya adalah penting kerana banyak keperluan biasa terpeta secara semula jadi kepada interceptors: pemformatan response yang konsisten (membalut semua response dalam satu envelope standard { success, data }), logging/timing (mengukur tempoh handler), caching (memulangkan response yang dicache), timeout, pengubahan ralat, dan serialization (mengecualikan medan sensitif).
Mengetahui strukturnya (Observable next.handle(), dengan tap/map/catchError untuk bertindak sebelum/selepas), kes penggunaan yang lazim, dan teristimewanya bagaimana interceptors berbeza daripada middleware dan guards (keupayaan membalut dan mengubah response) ialah sebahagian penting daripada kecekapan seni bina NestJS.
Interceptors mengekalkan logik rentas-keratan kekal DRY dan terpusat dan bukannya berulang merentas handlers, menjadikannya alat yang kerap digunakan dan penting untuk membina aplikasi NestJS yang bersih dan boleh diselenggara.