Timeout interceptor in NestJS - Step-by-Step Execution

Concept Flow - Timeout interceptor

Request received

↓

Interceptor starts

↓

Start timer

↓

Call next handler

↓

Wait for response or timeout

↓

Response

↓

Send response

↓

Request ends

The interceptor starts a timer, calls the next handler, waits for response or timeout, then either sends the response or throws a timeout error.

Execution Sample

NestJS

import { Injectable, NestInterceptor, ExecutionContext, CallHandler, RequestTimeoutException } from '@nestjs/common';
import { Observable, throwError } from 'rxjs';
import { timeout, catchError } from 'rxjs/operators';

@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      timeout(5000),
      catchError(err => throwError(() => new RequestTimeoutException())),
    );
  }
}

This interceptor sets a 5-second timeout on the request handling observable and throws a timeout exception if exceeded.

Execution Table

Step	Action	Timer State	Next Handler Called	Response or Timeout	Result
1	Request received, interceptor starts	Timer not started	No	No	Prepare to start timer
2	Start 5-second timer	Timer started (5s)	No	No	Timer counting down
3	Call next.handle() to process request	Timer running	Yes	No	Waiting for response or timeout
4	Response received before timeout	Timer running	Yes	Response received	Send response to client
5	Request ends	Timer stopped	Yes	Response sent	Complete request
6	OR timeout reached before response	Timer expired	Yes	Timeout error	Throw RequestTimeoutException
7	Request ends with error	Timer stopped	Yes	Error sent	Complete request with error

💡 Execution stops when either response is sent or timeout error is thrown.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4 or 6	Final
timer	not started	started (5s countdown)	running	stopped	stopped
nextHandlerCalled	false	false	true	true	true
responseReceived	false	false	false	true or false	true or false
timeoutReached	false	false	false	false or true	false or true

Key Moments - 3 Insights

Why does the interceptor use next.handle().pipe() instead of just calling next.handle()?

Because next.handle() returns an observable, and pipe() allows adding operators like timeout and catchError to control the flow and handle timeout errors as shown in execution_table step 3.

What happens if the response takes longer than 5 seconds?

The timeout operator triggers an error, caught by catchError, which throws a RequestTimeoutException as shown in execution_table steps 6 and 7.

Does the timer stop automatically when the response is received?

Yes, when the response arrives before timeout, the timer stops and the response is sent, as shown in execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the next handler called?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Check the 'Next Handler Called' column in execution_table rows.

According to variable_tracker, what is the state of 'timeoutReached' after step 4?

A true

B false

C undefined

D null

💡 Hint

Look at 'timeoutReached' values in variable_tracker after step 4.

If the timeout duration is increased to 10 seconds, how would the execution_table change?

A Next handler would be called twice

B Timer would start after response

C Timeout error would occur later or not at all if response is within 10s

D Response would be sent immediately

💡 Hint

Consider the 'Timer State' and 'Timeout error' timing in execution_table.

Concept Snapshot

Timeout Interceptor in NestJS:
- Intercepts requests to add a timeout limit
- Uses RxJS operators: timeout() and catchError()
- Throws RequestTimeoutException if exceeded
- Ensures slow requests don't hang forever
- Wraps next.handle() observable with timeout logic

Full Transcript

A Timeout Interceptor in NestJS watches how long a request takes. When a request comes in, the interceptor starts a timer and calls the next handler to process the request. It waits for the response or for the timer to run out. If the response comes before the timer ends, it sends the response back. If the timer runs out first, it throws a timeout error. This helps keep the app responsive by stopping requests that take too long. The interceptor uses RxJS's timeout and catchError operators to manage this flow cleanly.