Microservices and Custom exception filter in NestJS

• Nest offers a default exceptions layer to handle unhandled exceptions in an application. Global microservice exception filters aren't enabled by default when using a hybrid application.
• In the case of an error occurring on a microservice, it is recommended to use RpcException instead of HttpException.
• To catch RpcException on the client side, implementing "Exception filters" is a good practice. These filters offer greater control over the flow of the application and allow customization of the response returned to the client from the microservice.

To create a custom exception filter, extend the RpcException:

import { ArgumentsHost, Catch, ExceptionFilter } from "@nestjs/common";
import { RpcException } from "@nestjs/microservices";

@Catch(RpcException)
export class IIRpcExceptionFilter implements ExceptionFilter {
  catch(exception: RpcException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const error: any = exception.getError();
    const response = ctx.getResponse();
    const message = exception.message;

    // Customize the error response as desired
    response.status(error.status).json({
      status: error.status,
      message: message,
      error: "CustomException",
    });
  }
}

Use the @UseFilters() decorator to apply the filter to the controller or method you want to handle the RpcException error:

import { Controller, Get, UseFilters } from "@nestjs/common";
import { IRpcExceptionFilter } from "./rpc-exception.filter";
import { AppService } from "./app.service";

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  @UseFilters(IRpcExceptionFilter)
  async getHello(): Promise<string> {
    return this.appService.getHello();
  }
}

• To use the RpcException filter globally: main.ts

  import { NestFactory } from '@nestjs/core'
  import { AppModule } from './app.module'
  import { IRpcExceptionFilter } from './rpc-exception.filter'
  
  async function bootstrap() {
      const app = await NestFactory.create(AppModule)
  
      // Add Global Filter in main.ts
      app.useGlobalFilters(new IRpcExceptionFilter())
  
      await app.listen(3000)
  }
  bootstrap()
  

In the microservice client, throw an RpcException with the appropriate status code and message when an error occurs:

import { Controller } from "@nestjs/common";
import { MessagePattern, RpcException } from "@nestjs/microservices";

@Controller()
export class AppController {
  @MessagePattern({ cmd: "getHello" })
  async getHello(): Promise<string> {
    try {
      // ... some code that might throw an error
    } catch (error) {
      throw new RpcException({
        message: error,
        status: HttpStatus.BAD_REQUEST,
      });
    }
  }
}

With these steps, we have created a custom exception filter that handles RpcException errors thrown by a microservice in NestJS.