Global exception filters in NestJS - Step-by-Step Execution

Concept Flow - Global exception filters

Request received

↓

Controller or Service executes

↓

Exception thrown?

No→Send normal response

Yes↓

Global Exception Filter catches

↓

Process exception (log, format)

↓

Send error response to client

When a request causes an error, the global exception filter catches it, processes it, and sends a formatted error response.

Execution Sample

NestJS

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

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

This code defines a global exception filter that catches all exceptions and sends a 500 error response with a message.

Execution Table

Step	Action	Exception Thrown?	Filter Catches?	Response Sent
1	Request received and controller method called	No	No	Normal response sent
2	Controller throws an exception	Yes	Yes	Filter catches exception
3	Filter processes exception	Yes	Yes	Sends JSON error response with status 500
4	Request ends	No	No	Response sent to client

💡 Execution stops after sending error response or normal response to client

Variable Tracker

Variable	Start	After Exception	After Filter	Final
exception	undefined	Error object	Handled by filter	Handled
response.statusCode	200	200	500	500
response.body	Normal data	Not set	{"message":"Error occurred"}	{"message":"Error occurred"}

Key Moments - 3 Insights

Why does the filter catch exceptions thrown anywhere in the app?

Because it is registered globally, it listens for exceptions from all controllers and services, as shown in execution_table step 2 and 3.

What happens if no exception is thrown?

The filter does not run and the normal response is sent, as shown in execution_table step 1.

How does the filter change the HTTP response?

It sets the status code to 500 and sends a JSON error message, as tracked in variable_tracker for response.statusCode and response.body.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the filter catch the exception?

A Step 2

B Step 1

C Step 4

D Step 3

💡 Hint

Check the 'Filter Catches?' column in execution_table rows

According to variable_tracker, what is the response status code after the filter processes the exception?

A 200

B 404

C 500

D 400

💡 Hint

Look at response.statusCode after filter in variable_tracker

If the controller does not throw an exception, what response is sent?

A Error response with status 500

B Normal response

C No response

D Exception filter response

💡 Hint

See execution_table step 1 where no exception is thrown

Concept Snapshot

Global Exception Filters in NestJS:
- Catch exceptions thrown anywhere in app
- Registered globally to handle all errors
- Modify HTTP response (status, body)
- Send formatted error messages
- Keeps error handling centralized and consistent

Full Transcript

Global exception filters in NestJS catch errors thrown during request handling anywhere in the app. When a controller or service throws an exception, the global filter catches it, processes it by setting the HTTP status code and response body, then sends a formatted error response to the client. If no exception occurs, the filter does not run and the normal response is sent. This centralizes error handling and keeps responses consistent.

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