Global exception filters in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a global exception filter catches an HTTP exception?

Consider a NestJS app with a global exception filter that catches all exceptions and returns a JSON with { status: 'error', message: error.message }. What will the client receive if a controller throws new HttpException('Not Found', 404)?

NestJS

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';

@Catch()
export class GlobalFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const message = exception.message || 'Unknown error';
    response.status(500).json({ status: 'error', message });
  }
}

// Controller throws: throw new HttpException('Not Found', 404);

A {"status":"error","message":"Unknown error"}

B {"status":"error","message":"Not Found"}

C HTTP 404 with default NestJS error page

D HTTP 500 with empty body

💡 Hint

The filter catches all exceptions and uses exception.message for the response message.

The global filter catches the HttpException, extracts its message 'Not Found', and returns it with status 500 in JSON format. So the client sees the JSON with status 'error' and message 'Not Found'.

❓ lifecycle

intermediate

When is a global exception filter executed in NestJS request lifecycle?

In NestJS, at what point does a global exception filter run during handling a request?

A Only after all middleware have completed

B Before the controller method is called

C After the controller method throws an exception but before the response is sent

D Only after the response is sent to the client

💡 Hint

Exception filters catch errors thrown during controller execution.

Global exception filters catch exceptions thrown by controllers or services before the response is sent. They allow custom handling or formatting of errors.

🔧 Debug

advanced

Why does this global exception filter not catch exceptions?

Given this global exception filter code, why might it fail to catch exceptions thrown in controllers?

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';

@Catch(Error)
export class MyFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    response.status(500).json({ message: 'Error caught' });
  }
}

A The filter is not registered globally in the main.ts file

B The filter must use @Catch() without arguments to catch all exceptions globally

C The filter is missing the @Injectable() decorator

D The filter only catches exceptions of type Error, but NestJS throws HttpException which is not a subclass of Error

💡 Hint

Check how global filters are applied in NestJS.

Defining a filter class alone does not activate it globally. It must be registered globally using app.useGlobalFilters(new MyFilter()) in main.ts.

📝 Syntax

advanced

Which option correctly implements a global exception filter that logs and rethrows exceptions?

Choose the correct global exception filter code that logs the exception message and then rethrows it to let NestJS handle it.

A

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';

@Catch()
export class LogFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    console.log(exception.message);
    throw exception;
  }
}

B

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';

@Catch()
export class LogFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    console.log(exception.message);
  }
}

C

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';

@Catch()
export class LogFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    console.log(exception.message);
    return exception;
  }
}

D

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';

@Catch()
export class LogFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    console.log(exception.message);
    host.next();
  }
}

💡 Hint

To rethrow an exception, use throw inside catch method.

Option A logs the message and rethrows the exception, allowing NestJS to handle it further. Other options either swallow the exception or use invalid syntax.

🧠 Conceptual

expert

What is the main benefit of using a global exception filter in NestJS?

Why would a developer choose to implement a global exception filter instead of handling exceptions individually in each controller?

A To improve performance by skipping error handling in controllers

B To prevent exceptions from being logged anywhere

C To automatically retry failed requests without additional code

D To centralize error handling logic and provide consistent error responses across the entire application

💡 Hint

Think about code reuse and consistency in user experience.

Global exception filters let developers write error handling once and apply it everywhere, ensuring consistent responses and easier maintenance.