Interceptor interface in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this NestJS interceptor do to the response?

Consider this NestJS interceptor code. What will be the output behavior when applied to a controller method that returns a string?

NestJS

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

@Injectable()
export class AppendInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => data + '!!!')
    );
  }
}

A The interceptor blocks the response and returns an empty string.

B The interceptor appends three exclamation marks to the original string response.

C The interceptor converts the response string to uppercase.

D The interceptor throws an error and stops the response.

💡 Hint

Look at the map operator inside the pipe and what it does to the data.

The interceptor uses RxJS map to modify the response data by appending '!!!' to it before sending it back.

❓ lifecycle

intermediate

When is the intercept() method called in a NestJS interceptor?

In the lifecycle of a NestJS request, at what point does the intercept() method of an interceptor run?

A Only during application startup.

B Only after the route handler finishes and sends the response.

C Before the route handler is executed and after the response is sent.

D Before the route handler executes and can modify the request or response stream.

💡 Hint

Interceptors wrap around the route handler execution.

The intercept() method runs before the route handler and can modify the request or the response stream by wrapping the handler's observable.

📝 Syntax

advanced

Which option correctly implements a NestJS interceptor that logs the time taken by a request?

Choose the correct interceptor code that logs the time taken to process a request.

A

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

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    return next.handle().pipe(
      tap(() => console.log(`Request took ${Date.now() - start}ms`))
    );
  }
}

B

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, delay, tap } from 'rxjs';

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    return next.handle().pipe(
      delay(1000),
      tap(() => console.log(`Request took ${Date.now() - start}ms`))
    );
  }
}

C

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

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    return next.handle().pipe(
      map(() => {
        console.log(`Request took ${Date.now() - start}ms`);
        return;
      })
    );
  }
}

D

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

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    next.handle().subscribe(() => console.log(`Request took ${Date.now() - start}ms`));
    return next.handle();
  }
}

💡 Hint

Use tap to perform side effects without changing the data stream.

Option A correctly uses tap to log the time after the observable completes without modifying the data. Option A subscribes twice causing duplicate calls. Option A uses map which changes the data to undefined. Option A adds an artificial delay which is not required.

🔧 Debug

advanced

Why does this interceptor cause a runtime error?

Identify the cause of the runtime error in this interceptor code.

NestJS

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

@Injectable()
export class ErrorInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => data.toUpperCase())
    );
  }
}

A The data might not be a string, so calling toUpperCase() causes a runtime error.

B The map operator is not imported from rxjs, causing a ReferenceError.

C The interceptor is missing the @Injectable decorator.

D The intercept method must return a Promise, not an Observable.

💡 Hint

Check the type of data before calling string methods.

If the response data is not a string, calling toUpperCase() will cause a runtime error because that method does not exist on other types.

🧠 Conceptual

expert

What is the main purpose of the NestJS Interceptor interface?

Choose the best description of what the Interceptor interface allows you to do in NestJS.

A To define custom decorators for controller methods.

B To directly access and modify the database before any controller logic runs.

C To modify incoming requests and outgoing responses by wrapping route handler execution with additional logic.

D To replace the entire routing system with custom logic for handling HTTP requests.

💡 Hint

Think about how interceptors wrap around the handler execution.

Interceptors allow you to run code before and after the route handler, modifying requests or responses, adding logging, caching, or transforming data.