http-exception.filter.ts

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

interface ErrorObject {
  [key: string]: {
    message: string;
  };
}

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost): void {
    const context = host.switchToHttp();
    const response = context.getResponse<Response>();
    const request = context.getRequest<Request>();

    const status = exception.getStatus();
    const exceptionResponse = exception.getResponse();
    const message = exception.message;
    const errors = this.parseErrors(exceptionResponse);

    const errorResponse = this.createErrorResponse(
      status,
      message,
      errors,
      request.url,
      exception.stack
    );

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

  private parseErrors(response: unknown): ErrorObject {
    const errors = this.extractMessage(response);
    return this.convertArrayToObject(errors);
  }

  private extractMessage(response: any): any[] {
    if (typeof response === 'string') return [];
    return response?.message || [];
  }

  private convertArrayToObject(input: any[]): ErrorObject {
    return input.reduce((acc, { property, message }) => {
      acc[property] = { message };
      return acc;
    }, {} as ErrorObject);
  }

  private createErrorResponse(
    status: number,
    message: string,
    errors: ErrorObject,
    path: string,
    trace?: string
  ): Record<string, any> {
    const baseResponse = {
      message,
      errors,
      timestamp: new Date().toISOString(),
    };

    if (process.env.NODE_ENV === 'development') {
      return {
        ...baseResponse,
        path,
        trace,
      };
    }

    return baseResponse;
  }
}