Built‑in interceptor vs manual composition for request cancellation and timeout in NestJS

To achieve consistent request cancellation and timeouts in NestJS across Express and Fastify, a global interceptor combined with AsyncLocalStorage (ALS) is the superior approach. NestJS does not provide a built-in interceptor for this purpose, and manual composition in every controller leads to significant boilerplate and 'prop-drilling' AbortSignals through your service layer.

The Challenge: Adapter Disparity

The primary hurdle is how underlying platforms handle client disconnects. Express emits the close event immediately when a connection drops, whereas Fastify may wait until the response is flushed. Relying on manual listeners in controllers creates inconsistent behavior. Furthermore, an RxJS timeout operator only terminates the stream; it does not natively stop long-running asynchronous tasks like database queries unless those tasks are explicitly linked to a signal AbortSignal.

The Solution: Global Interceptor + ALS

By using a global interceptor, you can manage the lifecycle of the request in one place. Using AsyncLocalStorage allows you to propagate the cancellation signal to deep-nested services without modifying their function signatures.

Implementation Steps

1. Define an AsyncLocalStorage Store: Create a store instance to hold the AbortController per request.
2. Create a Global Interceptor:
   • Instantiate a new AbortController for every request.
   • Store the controller in the ALS context.
   • Listen to the close event on the raw request (handling the adapter difference) to call abort().
   • Apply the timeout() operator to the observable to handle processing deadlines.
3. Propagate to Services: In your database services, retrieve the signal from ALS and pass it to your driver (e.g., Prisma or TypeORM) which supports AbortSignal.

// Inside the Interceptor
const controller = new AbortController();
this.als.run(controller.signal, () => {
  return next(handle).pipe(
    timeout(requestTimeout),
    catchError(err => {
      if (err instanceof TimeoutError) controller.abort();
      throw err;
    })
  );
});

Trade-offs

• Global Interceptor: Low boilerplate and ensures consistent behavior across adapters. However, it requires careful handling to ensure context is not lost across asynchronous boundaries.
• Manual Composition: Provides fine-grained control per endpoint but results in high maintenance and increases the likelihood of developers forgetting to implement cancellation logic.

Note: Ensure your chosen database driver or external API client supports AbortSignal; if not, the cancellation will stop the Nest response but the server-side work will continue.