exception-handler.filter.ts

/**
 * @see https://github.com/mikemajesty/nestjs-microservice-boilerplate-api/blob/master/guides/middlewares/exception-handler.filter.md
 */
import { ArgumentsHost, Catch, ExceptionFilter as AppExceptionFilter, HttpException } from '@nestjs/common'
import { AxiosError } from 'axios'
import { ZodError } from 'zod'

import { ILoggerAdapter } from '@/infra/logger/adapter'
import { DateUtils } from '@/utils/date'
import { ApiBadRequestException, ApiErrorType, ApiInternalServerException, BaseException } from '@/utils/exception'
import { DefaultErrorMessage } from '@/utils/http-status'
import { ObjectUtil } from '@/utils/object'
import { AnyType } from '@/utils/types'

@Catch()
export class ExceptionHandlerFilter implements AppExceptionFilter {
  constructor(private readonly loggerService: ILoggerAdapter) {}

  catch(exception: BaseException, host: ArgumentsHost): void {
    const context = host.switchToHttp()
    const response = context.getResponse()
    const request = context.getRequest()

    const status = this.getStatus(exception)

    const requestId = (request as { id: string }).id
    exception.traceid = [exception.traceid, requestId].find(Boolean) as string

    response.status(status)
    this.loggerService.logger(request, response)
    this.logError(exception)
    const message = this.getErrorMessage(exception, status)

    const errorResponse: ApiErrorType = {
      error: {
        code: status,
        traceid: exception.traceid,
        context: exception.context ?? ObjectUtil.reach(exception, (o) => o.parameters.context),
        details: ObjectUtil.reach(exception, (o) => o.parameters.details),
        name: exception.name || ObjectUtil.reach(exception, (o) => o.constructor.name, Error.name),
        message,
        timestamp: DateUtils.build({ format: 'yyyy-MM-dd HH:mm:ss', type: 'iso' }),
        path: request.url
      }
    }

    response.json(errorResponse)
  }

  private logError(exception: BaseException): void {
    this.loggerService.error(exception)
  }

  private getErrorMessage(exception: BaseException, status: number): string[] {
    const defaultError = DefaultErrorMessage[String(status)]
    if (defaultError) {
      return [defaultError]
    }

    if (exception instanceof ZodError) {
      return this.formatZodErrors(exception)
    }

    if (exception instanceof AxiosError) {
      return this.formatAxiosError(exception)
    }

    return this.formatBaseException(exception)
  }

  private formatZodErrors(exception: ZodError): string[] {
    return exception.issues.map((issue: AnyType) => {
      const isUnrecognizedKeys = issue.code === 'unrecognized_keys'

      const path = isUnrecognizedKeys
        ? (issue as ZodUnrecognizedKeysIssue).keys?.join('.')
        : issue.path?.join('.') || 'key'

      const arrayPositionMatch = /^\d+/.exec(path)
      if (arrayPositionMatch?.[0]) {
        const position = Number(arrayPositionMatch[0])
        const property = path.replace(/^\d+\./, '')
        return `array position: ${position}, property: ${property}: ${issue.message.toLowerCase()}`
      }

      return `${path}: ${issue.message}`
    })
  }

  private formatAxiosError(exception: AxiosError): string[] {
    if (ObjectUtil.reach(exception, (o) => o.response.data)) {
      const responseData = ObjectUtil.reach(exception, (o) => o.response.data) as AnyType
      if (typeof responseData === 'string') {
        return [responseData]
      }
      if (responseData.message) {
        return Array.isArray(responseData.message) ? responseData.message : [responseData.message]
      }
    }

    return [exception.message || 'External API request failed']
  }

  private formatBaseException(exception: BaseException): string[] {
    const response = exception.getResponse()

    if (Array.isArray(response)) {
      return response as string[]
    }

    if (typeof response === 'object' && response !== null && 'message' in response) {
      const message = (response as { message: string | string[] }).message
      return Array.isArray(message) ? message : [message]
    }

    return [exception.message || 'An unexpected error occurred']
  }

  private getStatus(exception: BaseException): number {
    if (exception instanceof ZodError) {
      return ApiBadRequestException.STATUS
    }

    if (exception instanceof HttpException) {
      return exception.getStatus()
    }

    return exception['status'] || ApiInternalServerException.STATUS
  }
}

type ZodUnrecognizedKeysIssue = {
  code: 'unrecognized_keys'
  keys: string[]
  path: (string | number)[]
  message: string
}