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.REQUIRED_PASSWORD_RESET:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não permitido',
        message: 'Seu usuário foi resetado por um administrador, resete a senha pelo link "Esqueci a senha", para prosseguir',
        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.INVALID_REFRESH_TOKEN:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Acesso expirado!',
        message: 'Seu acesso expirou, favor fazer login novamente.',
        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_EXISTS:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Grupo já existe',
        message: 'Não é possível criar um grupo com esse nome',
        code,
      };

    case ErrorCodes.ROLE.ALREADY_EXISTS_PUBLIC:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Grupo já existe',
        message: 'Nome conflita com grupo público da Dadosfera',
        code,
      };

    case ErrorCodes.ROLE.PERMISSION_ALREADY_GRANTED:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Permissão já inclusa',
        message: 'Permissão já consta nesse grupo',
        code,
      };

    case ErrorCodes.ROLE.PERMISSION_NOT_GRANTED:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Permissão não inclusa',
        message: 'Permissão já consta nesse grupo',
        code,
      };

    case ErrorCodes.ROLE.PRIVATE:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Não é possivel fazer alterações',
        message: 'Você não tem permissão para alterar esse grupo',
        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_CREATED:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Ocorreu um erro ao criar seu usúario',
        message: 'Tente novamente ou entre em contato com o suporte',
        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.NOT_FOUND:
    case ErrorCodes.CONNECTION.PLATFORM_NOT_FOUND:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Conexão não encontrada',
        message:
          'Não encontramos a conexão solicitada. Caso o erro persista, entre em contato com o suporte',
        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.CONNECTION_TEST.BAD_REQUEST:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Erro ao testar conexão',
        message:
          'Verifique se todas as informações foram preenchidas corretamente',
        code,
      };

    case ErrorCodes.PIPELINE.NOT_FOUND:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Não encontramos a pipeline solicitada',
        message:
          'Tente realizar a ação novamente. Caso o erro persista, entre em contato com o suporte',
        code,
      };

    case ErrorCodes.PIPELINE.PLATFORM_NOT_FOUND:
    case ErrorCodes.PIPELINE.PLATFORM_BAD_REQUEST:
    case ErrorCodes.PIPELINE.PLATFORM_UNKNOWN:
      return {
        statusCode: HttpStatus.BAD_GATEWAY,
        error: 'Oops... Não foi possível realizar sua ação',
        message:
          'Houve um erro interno ao buscar por sua pipeline. Caso o erro persista, entre em contato com o suporte',
        code,
      };
    case ErrorCodes.INPUT.NOT_FOUND:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Oops... O recurso que você buscou não está disponível',
        message:
          'Não encontramos o recurso buscado. Caso o erro persista, entre em contato com o suporte',
        code,
      };
    case ErrorCodes.NOT_IMPLEMENTED:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Oops... O serviço que você está tentando acessar não existe!',
        message: 'Caso o erro persista, entre em contato com o suporte',
        code,
      };
    case ErrorCodes.CATALOG.DATA_ASSET_NOT_FOUND:
      return {
        statusCode: HttpStatus.NOT_FOUND,
        error: 'Não encontramos o ativo solicitado',
        message:
          'Tente realizar a ação novamente. Caso o erro persista, entre em contato com o suporte',
        code,
      };
    case ErrorCodes.CATALOG.PREVIEW_TOO_BIG:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Erro ao buscar prévia',
        message: 'Ocorreu um erro devido ao tamanho da prévia do ativo.',
        code,
      };
    case ErrorCodes.CATALOG.METADATA_TOO_BIG:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Erro ao buscar informações',
        message: 'Ocorreu um erro devido ao tamanho das informações do ativo.',
        code,
      };
    case ErrorCodes.INTERNAL:
    case ErrorCodes.UNKNOWN:
    default:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Oops... Não foi possível realizar sua ação',
        message:
          'Ocorreu um erro desconhecido. Caso o erro persista, 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;
  }
}