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.

Practice

1. What is the main purpose of a global exception filter in a NestJS application?

easy

A. To catch and handle exceptions across the entire application in one place

B. To define routes for the application

C. To manage database connections

D. To serve static files

Solution

1. Step 1: Understand the role of exception filters

   Exception filters in NestJS are designed to catch errors and exceptions that occur during request processing.

2. Step 2: Identify the scope of global exception filters

   Global exception filters apply this error handling across the entire app, centralizing error management.

3. Final Answer:

   To catch and handle exceptions across the entire application in one place -> Option A

4. Quick Check:

   Global exception filters = app-wide error handling [OK]

Hint: Global filters catch errors everywhere in the app [OK]

Common Mistakes:

• Confusing filters with routing or database management
• Thinking filters serve static files
• Assuming filters only handle specific routes

2. Which of the following is the correct way to apply a global exception filter in the main.ts file of a NestJS app?

easy

A. app.useGlobalFilters(new MyExceptionFilter())

B. app.setGlobalFilters(new MyExceptionFilter())

C. app.applyGlobalFilters(MyExceptionFilter)

D. app.registerGlobalFilter(MyExceptionFilter)

Solution

1. Step 1: Recall the NestJS method for global filters

   The official method to apply global exception filters is useGlobalFilters() on the app instance.

2. Step 2: Check the syntax for passing the filter

   The filter must be instantiated with new before passing it to useGlobalFilters().

3. Final Answer:

   app.useGlobalFilters(new MyExceptionFilter()) -> Option A

4. Quick Check:

   Global filter method = useGlobalFilters() [OK]

Hint: Use app.useGlobalFilters(new Filter()) in main.ts [OK]

Common Mistakes:

• Using incorrect method names like setGlobalFilters
• Passing class without instantiation
• Confusing with middleware registration methods

3. Given this global exception filter code snippet, what will be the HTTP status code returned when an exception is thrown?

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

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();

    if (exception instanceof HttpException) {
      const status = exception.getStatus();
      response.status(status).json({ message: exception.message });
    } else {
      response.status(500).json({ message: 'Internal server error' });
    }
  }
}

medium

A. 200

B. 500

C. Depends on the exception type

D. 404

Solution

1. Step 1: Analyze the filter's catch method

   The filter checks if the exception is an instance of HttpException and uses its status code.

2. Step 2: Determine status code for other exceptions

   If not an HttpException, it returns status 500 with a generic error message.

3. Final Answer:

   Depends on the exception type -> Option C

4. Quick Check:

   HttpException status or 500 for others [OK]

Hint: Check if exception is HttpException for status code [OK]

Common Mistakes:

• Assuming always 500 status
• Ignoring HttpException status extraction
• Confusing 404 with 500 errors

4. Identify the error in this global exception filter implementation:

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

@Catch()
export class MyFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const response = host.getResponse();
    response.status(400).json({ error: 'Bad Request' });
  }
}

medium

A. Missing @Injectable() decorator on the filter class

B. The @Catch() decorator must specify exception types

C. The catch method must return a value

D. host.getResponse() is incorrect; should use host.switchToHttp().getResponse()

Solution

1. Step 1: Check how to get response object

   In NestJS, to get the HTTP response, use host.switchToHttp().getResponse(), not host.getResponse().

2. Step 2: Verify other parts

   The @Catch() decorator can be empty to catch all exceptions, and the catch method does not need to return a value. @Injectable() is not required for filters.

3. Final Answer:

   host.getResponse() is incorrect; should use host.switchToHttp().getResponse() -> Option D

4. Quick Check:

   Use switchToHttp() to access response [OK]

Hint: Use host.switchToHttp().getResponse() to get response [OK]

Common Mistakes:

• Calling host.getResponse() directly
• Thinking @Injectable() is mandatory for filters
• Expecting catch to return a value

5. You want to create a global exception filter that logs all exceptions and returns a JSON response with a custom message and status code 418 (I'm a teapot) for all errors except HttpExceptions, which should keep their original status. How should you implement the catch method?

hard

A. Always respond with status 418 and ignore HttpException status

B. Check if exception is HttpException, use its status; else log and respond with 418 and custom message

C. Only log exceptions but do not modify the response

D. Throw the exception again to let NestJS handle it

Solution

1. Step 1: Handle HttpException separately

   Check if the exception is an instance of HttpException to preserve its status and message.

2. Step 2: For other exceptions, log and respond with status 418

   Log the error details, then send a JSON response with status 418 and a custom message.

3. Final Answer:

   Check if exception is HttpException, use its status; else log and respond with 418 and custom message -> Option B

4. Quick Check:

   Preserve HttpException status, else respond 418 with log [OK]

Hint: Preserve HttpException status; else respond 418 with log [OK]

Common Mistakes:

• Ignoring HttpException status and always sending 418
• Not logging exceptions
• Re-throwing exceptions instead of handling