maestro/src/utils/ErrorBuilder.ts

import { HttpStatus, HttpException, Logger } from '@nestjs/common';
import { RpcException } from '@nestjs/microservices';

import ErrorCodes from './errorCodes';

export function EnrichErrorCode(code: string) {
  switch (code) {
    case ErrorCodes.AUTH.WRONG_CREDENTIALS:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Usuário ou senha incorretos',
        code,
      };

    case ErrorCodes.AUTH.WRONG_PASSWORD_CONFIRMATION:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Senha incorreta',
        message: 'Confirmação de senha incorreta',
        code,
      };

    case ErrorCodes.AUTH.TOTP_NOT_ENABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator não está habilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_ALREADY_ENABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator já está habilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_ALREADY_DISABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator já está desabilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_REQUIRED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Informe o token de autenticação multifator',
        code,
      };

    case ErrorCodes.AUTH.CODE_MISMATCH:
    case ErrorCodes.AUTH.CODE_ALREADY_USED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Token de autenticação multifator inválido',
        code,
      };

    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_EXPIRED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não permitido',
        message: 'Token para recuperar senha expirado',
        code,
      };

    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_INVALID:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não permitido',
        message: 'Token para recuperar senha inválido',
        code,
      };

    case ErrorCodes.AUTH.WEAK_NEW_PASSWORD:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Não permitido',
        message: 'Senha muito fraca. Escolha uma senha mais forte',
        code,
      };

    case ErrorCodes.TERMS_OF_USE.UP_TO_DATE:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Não autorizado',
        message: 'Você já assinou os termos de uso',
        code,
      };

    case ErrorCodes.TERMS_OF_USE.REQUIRED:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Não autorizado',
        message: 'É necessário aceitar os termos de uso para prosseguir',
        code,
      };

    case ErrorCodes.RATE_LIMIT:
      return {
        statusCode: HttpStatus.TOO_MANY_REQUESTS,
        error: 'Limite excedido',
        message:
          'Você tentou realizar essa operação muitas vezes. Tente novamente mais tarde',
        code,
      };

    case ErrorCodes.AUTH.UNAUTHORIZED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'É necessário estar logado para realizar essa operação',
        code,
      };

    case ErrorCodes.AUTH.FORBIDDEN:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Não autorizado',
        message:
          'Você não tem permissões suficientes para realizar essa operação',
        code,
      };

    case ErrorCodes.ROLE.ALREADY_EXIST:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Grupo já existe',
        message: 'Não é possível criar um grupo com esse nome',
        code,
      };
    case ErrorCodes.ROLE.NOT_FOUND:
    case ErrorCodes.ROLE.FROM_ANOTHER_CUSTOMER:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Grupo não encontrado',
        message: 'Grupo solicitado não encontrado',
        code: ErrorCodes.ROLE.NOT_FOUND,
      };
    case ErrorCodes.ROLE.CANNOT_EDIT_PUBLIC_ROLE:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Grupo público',
        message: 'Você não tem permissão para editar esse grupo',
        code,
      };
    case ErrorCodes.USER.NOT_FOUND:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Usuário não encontrado',
        message: 'Usuário solicitado não encontrado',
        code,
      };
    case ErrorCodes.USER.ALREADY_EXISTS:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Usuário encontrado',
        message: 'Nome de usuário já existente',
        code,
      };
    case ErrorCodes.USER.INVALID_ID:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Id inválido',
        message: 'Id encontra-se num formato inválido',
        code,
      };
    case ErrorCodes.CONNECTION_TEST.ERROR:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Erro ao realizar o teste',
        message: 'Verifique os dados de conexão e tente novamente',
        code,
      };

    case ErrorCodes.CONNECTION_TEST.EXPIRED:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Teste de conexão expirado',
        message: 'Favor realizar novo teste',
        code,
      };

    case ErrorCodes.CONNECTION_TEST.TIMEOUT:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Tempo limite excedido',
        message:
          'O teste excedeu o tempo limite. Verifique os dados de conexão e tente novamente',
        code,
      };

    case ErrorCodes.INTERNAL:
    case ErrorCodes.UNKNOWN:
    default:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Desconhecido',
        message:
          'Erro desconhecido. Tente novamente ou entre em contato com o suporte',
        code: ErrorCodes.UNKNOWN,
        details: code,
      };
  }
}

const logger = new Logger();

export default class ErrorBuilder extends HttpException {
  code: string;

  constructor(code: string | RpcException = '') {
    if (typeof code !== 'string') {
      logger.log(code?.stack);
      code = (code as any)?.details as string;
    } else {
      logger.log(code);
    }

    const {
      statusCode,
      message,
      error,
      code: rCode,
      details,
    } = EnrichErrorCode(code);
    super({ statusCode, message, error, code: rCode, details }, statusCode);
    this.code = code;
  }
}