Why interceptors add cross-cutting logic in NestJS - See It in Action

Why interceptors add cross-cutting logic

📖 Scenario: You are building a NestJS backend application that needs to log the time taken by each request and modify the response before sending it back.This is a common real-world need where you want to add behavior that applies to many parts of your app without changing each controller method.

🎯 Goal: Build a simple NestJS interceptor that adds cross-cutting logic to log request duration and modify the response message.

📋 What You'll Learn

Create a basic NestJS controller with one GET route returning a string

Create an interceptor class implementing NestInterceptor

Add logic in the interceptor to log the time taken for the request

Modify the response data in the interceptor before sending it back

Apply the interceptor to the controller route

💡 Why This Matters

🌍 Real World

In real backend applications, interceptors help add features like logging, caching, or transforming responses without repeating code in every controller method.

💼 Career

Understanding interceptors is important for backend developers working with NestJS or similar frameworks to write clean, maintainable, and scalable server-side code.

1

Create a basic NestJS controller

Create a NestJS controller class called AppController with a GET route method getHello that returns the string 'Hello World'.

NestJS

import { Controller, Get } from '@nestjs/common';

@Controller()
export class AppController {
  // Your code here
}

Need a hint?

Use @Controller() decorator and define a method getHello with @Get() decorator returning the exact string.

2

Create an interceptor class

Create a class called LoggingInterceptor that implements NestInterceptor from @nestjs/common. Import CallHandler and ExecutionContext as well. Add an empty intercept method with parameters context: ExecutionContext and next: CallHandler returning next.handle().

NestJS

import { Controller, Get, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';

@Controller()
export class AppController {
  @Get()
  getHello(): string {
    return 'Hello World';
  }
}

// Your code here

Need a hint?

Implement the intercept method returning next.handle() to pass control to the next handler.

3

Add timing and response modification logic in interceptor

Inside the intercept method of LoggingInterceptor, record the current time before calling next.handle(). Use pipe with map from rxjs/operators to calculate elapsed time after the handler completes. Log the elapsed time with console.log. Modify the response by appending ' - Processed by interceptor' to the original data.

NestJS

import { map } from 'rxjs/operators';

export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable {
    // Your code here
  }
}

Need a hint?

Use Date.now() to get current time, then use pipe and map to modify the response and log elapsed time.

4

Apply the interceptor to the controller route

Import UseInterceptors from @nestjs/common. Add the decorator @UseInterceptors(LoggingInterceptor) above the getHello method in AppController to apply the interceptor to that route.

NestJS

import { UseInterceptors } from '@nestjs/common';

@Controller()
export class AppController {
  @Get()
  // Your code here
  getHello(): string {
    return 'Hello World';
  }
}

export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable {
    const now = Date.now();
    return next.handle().pipe(
      map(data => {
        const elapsed = Date.now() - now;
        console.log(`Request took ${elapsed}ms`);
        return data + ' - Processed by interceptor';
      })
    );
  }
}

Need a hint?

Use the @UseInterceptors(LoggingInterceptor) decorator above the getHello method.