Error Handling in NestJS

Welcome back! In our previous lesson, we explored configuring middleware to enhance the robustness of your NestJS application. Now, let’s dive into another vital aspect of building stable applications: error handling.

In this lesson, you will learn how to effectively manage errors in your NestJS application using custom exception filters. This will help you provide clear, structured error messages and maintain consistency across your app.

By the end of this lesson, you’ll be able to:

• Understand the importance of effective error handling.
• Create and use custom HTTP exception filters in NestJS.
• Implement global error handling.
• Follow best practices for error handling.

These skills will help you build more robust and maintainable NestJS applications.

Exception filters in NestJS are used to manage and structure errors that occur during the request-response cycle. By creating custom exception filters, you can intercept various types of exceptions and transform them into informative and consistent responses. This approach enhances user experience, simplifies debugging, and prevents exposing sensitive information, improving the overall security and stability of your application.

Key Tasks of Exception Filters:

• Execute custom logic whenever an error occurs.
• Modify and standardize the structure of the error response.
• Optionally end the request-response cycle or pass control to the next handler.

Now, let’s see how to implement one.

Let’s start by creating a custom HTTP exception filter to catch and handle HTTP errors, allowing us to format the error response.

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

    const errorResponse = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    };

    response.status(status).json(errorResponse);
  }
}

How It Works:

• @Catch(HttpException): This decorator tells the filter to handle HttpException errors.
• catch() Method: The catch() method captures the exception, extracts the necessary information (like the request URL, status code, and timestamp), and builds a structured error response. It then sends this response back to the client as JSON.

This way, your clients will receive informative error messages with details like the status code, timestamp, request path, and error message.

Next, we’ll apply the custom exception filter to a specific route in our TodoController:

@Controller('todos')
export class TodoController {
  @Post()
  @UseFilters(HttpExceptionFilter)
  async create(@Body() createTodoDto: CreateTodoDto) {
    // Simulating an error for demonstration
    throw new BadRequestException('This is a test exception from the create method.');
  }
}

What This Does:

• @UseFilters(HttpExceptionFilter): Binds the custom exception filter to the create method of the TodoController.
• When a BadRequestException is thrown (as demonstrated in the code), the filter catches it and sends a structured error response to the client.

You can also apply the custom exception filter at the controller level, which will handle exceptions for all routes within the controller:

@UseFilters(HttpExceptionFilter)
@Controller('todos')
export class TodoController {
  @Post()
  async create(@Body() createTodoDto: CreateTodoDto) {
    // Simulating an error for demonstration
    throw new BadRequestException('This is a test exception from the create method.');
  }
}

Instead of adding the exception filter to each controller or method individually, we can apply it globally. This way, all HTTP exceptions in your application will be handled consistently.

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(3000);
}
bootstrap();

By calling app.useGlobalFilters(new HttpExceptionFilter()) in the bootstrap function, the filter is applied globally to all controllers and routes. This is especially useful in larger applications, where you want consistent error handling without manually applying the filter everywhere.

Effective error handling is essential for improving user experience, debugging, security, and overall application stability.

Key Benefits:

• User Experience: Provides clear, consistent error messages to the user.
• Debugging and Maintenance: Makes tracking down issues easier with informative error responses.
• Security: Prevents exposing sensitive information by standardizing error responses.
• Stability: Helps manage unexpected scenarios gracefully, preventing application crashes.

Now that you've learned how to create and apply custom exception filters, it's time to put that knowledge into practice. Implement the filter in your application and observe how it handles various types of exceptions effectively. Let's get started!