Exception mapping interceptor in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when an exception is thrown inside the interceptor?

Consider a NestJS interceptor that catches exceptions and maps them to a custom error response. What will the client receive if the intercepted method throws a standard Error with message 'Failed operation'?

NestJS

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

@Injectable()
export class ExceptionMappingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err => {
        return throwError(() => new Error('Mapped: ' + err.message));
      }),
    );
  }
}

// Controller method throws new Error('Failed operation')

A The client receives a generic error message 'Internal server error'.

B The client receives the original error message 'Failed operation' without changes.

C The client receives an error response with message 'Mapped: Failed operation'.

D The interceptor swallows the error and the client receives a successful empty response.

💡 Hint

Think about how catchError modifies the error before rethrowing it.

The interceptor catches the original error and throws a new Error with the message prefixed by 'Mapped: '. This means the client will see the modified error message.

📝 Syntax

intermediate

Which option correctly implements an Exception Mapping Interceptor in NestJS?

Select the code snippet that correctly implements an interceptor that catches exceptions and maps them to a custom error message.

A

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

@Injectable()
export class MapExceptionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    try {
      return next.handle();
    } catch (err) {
      throw new Error('Custom error: ' + err.message);
    }
  }
}

B

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

@Injectable()
export class MapExceptionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err => throwError(() => new Error('Custom error: ' + err.message)))
    );
  }
}

C

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

@Injectable()
export class MapExceptionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err => {
        return throwError(() => new Error('Custom error: ' + err.message));
      })
    );
  }
}

D

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

@Injectable()
export class MapExceptionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err => throwError(() => new Error('Custom error: ' + err.message)))
    );
  }
}

💡 Hint

Remember that catchError must return an Observable, and throwError is used to rethrow errors in RxJS.

Option B correctly uses catchError with throwError(() => new Error(...)) which returns an Observable that emits an error. Other options either misuse try/catch with Observables, return an Error object instead of an Observable, or call throwError incorrectly.

🔧 Debug

advanced

Why does this Exception Mapping Interceptor fail to catch errors?

Given the following interceptor code, why does it not catch exceptions thrown by the controller method?

NestJS

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

@Injectable()
export class FaultyInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    try {
      return next.handle();
    } catch (err) {
      throw new Error('Intercepted error: ' + err.message);
    }
  }
}

A Because next.handle() returns an Observable, errors inside it are asynchronous and must be caught using RxJS operators, not try/catch.

B Because the interceptor is missing the @Catch decorator to catch exceptions.

C Because the interceptor must return a Promise instead of an Observable to catch errors.

D Because the try/catch block is placed after the next.handle() call, so it never executes.

💡 Hint

Think about how Observables handle errors asynchronously.

The try/catch block only catches synchronous errors. Since next.handle() returns an Observable, errors inside it happen asynchronously and must be caught with catchError operator.

❓ state_output

advanced

What is the final error message sent to the client?

An Exception Mapping Interceptor modifies errors by appending ' - intercepted' to the message. The controller throws new Error('Database failure'). What error message does the client receive?

NestJS

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

@Injectable()
export class AppendMessageInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err => {
        err.message += ' - intercepted';
        return throwError(() => err);
      }),
    );
  }
}

// Controller throws new Error('Database failure')

A The client receives an error with message 'Database failure'.

B The client receives a generic error message 'Internal server error'.

C The client receives an error with message ' - intercepted'.

D The client receives an error with message 'Database failure - intercepted'.

💡 Hint

The interceptor modifies the original error message before rethrowing it.

The interceptor appends ' - intercepted' to the original error message, so the client sees the combined message.

🧠 Conceptual

expert

Which statement about Exception Mapping Interceptors in NestJS is TRUE?

Select the correct statement about how Exception Mapping Interceptors work in NestJS.

A They can transform exceptions thrown by route handlers into custom error responses by catching errors in the Observable stream.

B They must be implemented as class decorators on controllers to work properly.

C They replace the need for global exception filters by handling all error mapping internally.

D They automatically catch all exceptions thrown anywhere in the application without needing to be applied.

💡 Hint

Think about the scope and purpose of interceptors versus filters.

Exception Mapping Interceptors catch errors in the Observable stream of a request and can transform them. They must be applied explicitly and do not replace global exception filters. They are not class decorators.