@cognima/banners/src/error-handler.js

Biblioteca avançada para geração de banners dinâmicos para diversas plataformas e aplicações

"use strict";

/**
 * Módulo de tratamento de erros
 * 
 * Este módulo fornece funções para tratar erros do módulo @cognima/banners.
 * 
 * @module error-handler
 * @author Cognima Team (melhorado)
 * @version 2.0.0
 */

// Configuração padrão
let config = {
    debug: false, // Se deve mostrar mensagens de debug
    logErrors: true, // Se deve registrar erros no console
    throwErrors: true, // Se deve lançar erros
    useErrorCodes: true, // Se deve usar códigos de erro
    useErrorTranslation: true, // Se deve traduzir mensagens de erro
    language: 'pt-BR' // Idioma padrão para mensagens de erro
};

// Códigos de erro
const errorCodes = {
    INVALID_PARAMETER: 'ERR_INVALID_PARAMETER',
    MISSING_PARAMETER: 'ERR_MISSING_PARAMETER',
    IMAGE_LOAD_ERROR: 'ERR_IMAGE_LOAD',
    IMAGE_PROCESS_ERROR: 'ERR_IMAGE_PROCESS',
    BANNER_CREATION_ERROR: 'ERR_BANNER_CREATION',
    INTERNAL_ERROR: 'ERR_INTERNAL',
    FILE_SYSTEM_ERROR: 'ERR_FILE_SYSTEM',
    NETWORK_ERROR: 'ERR_NETWORK',
    CACHE_ERROR: 'ERR_CACHE',
    OPTIMIZATION_ERROR: 'ERR_OPTIMIZATION'
};

// Traduções de mensagens de erro
const errorTranslations = {
    'pt-BR': {
        [errorCodes.INVALID_PARAMETER]: 'Parâmetro inválido: {0}',
        [errorCodes.MISSING_PARAMETER]: 'Parâmetro obrigatório ausente: {0}',
        [errorCodes.IMAGE_LOAD_ERROR]: 'Erro ao carregar imagem: {0}',
        [errorCodes.IMAGE_PROCESS_ERROR]: 'Erro ao processar imagem: {0}',
        [errorCodes.BANNER_CREATION_ERROR]: 'Erro ao criar banner: {0}',
        [errorCodes.INTERNAL_ERROR]: 'Erro interno: {0}',
        [errorCodes.FILE_SYSTEM_ERROR]: 'Erro de sistema de arquivos: {0}',
        [errorCodes.NETWORK_ERROR]: 'Erro de rede: {0}',
        [errorCodes.CACHE_ERROR]: 'Erro de cache: {0}',
        [errorCodes.OPTIMIZATION_ERROR]: 'Erro de otimização: {0}'
    },
    'en-US': {
        [errorCodes.INVALID_PARAMETER]: 'Invalid parameter: {0}',
        [errorCodes.MISSING_PARAMETER]: 'Missing required parameter: {0}',
        [errorCodes.IMAGE_LOAD_ERROR]: 'Error loading image: {0}',
        [errorCodes.IMAGE_PROCESS_ERROR]: 'Error processing image: {0}',
        [errorCodes.BANNER_CREATION_ERROR]: 'Error creating banner: {0}',
        [errorCodes.INTERNAL_ERROR]: 'Internal error: {0}',
        [errorCodes.FILE_SYSTEM_ERROR]: 'File system error: {0}',
        [errorCodes.NETWORK_ERROR]: 'Network error: {0}',
        [errorCodes.CACHE_ERROR]: 'Cache error: {0}',
        [errorCodes.OPTIMIZATION_ERROR]: 'Optimization error: {0}'
    }
};

/**
 * Formata uma mensagem de erro
 * 
 * @param {string} template - Template da mensagem
 * @param {Array<string>} args - Argumentos para substituir no template
 * @returns {string} - Mensagem formatada
 */
function formatMessage(template, args) {
    if (!args || !args.length) return template;
    
    return template.replace(/\{(\d+)\}/g, (match, index) => {
        const argIndex = parseInt(index, 10);
        return argIndex < args.length ? args[argIndex] : match;
    });
}

/**
 * Traduz uma mensagem de erro
 * 
 * @param {string} code - Código de erro
 * @param {Array<string>} args - Argumentos para substituir no template
 * @returns {string} - Mensagem traduzida
 */
function translateError(code, args) {
    if (!config.useErrorTranslation) return code;
    
    const translations = errorTranslations[config.language] || errorTranslations['en-US'];
    const template = translations[code] || code;
    
    return formatMessage(template, args);
}

/**
 * Cria um objeto de erro
 * 
 * @param {string} code - Código de erro
 * @param {string} message - Mensagem de erro
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function createError(code, message, originalError) {
    const error = new Error(message);
    error.code = code;
    error.originalError = originalError;
    return error;
}

/**
 * Trata um erro
 * 
 * @param {string} code - Código de erro
 * @param {Array<string>} args - Argumentos para substituir no template
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleError(code, args, originalError) {
    // Obtém a mensagem traduzida
    const message = translateError(code, args);
    
    // Cria o objeto de erro
    const error = createError(config.useErrorCodes ? code : undefined, message, originalError);
    
    // Registra o erro no console
    if (config.logErrors) {
        console.error(`[${code}] ${message}`);
        
        if (config.debug && originalError) {
            console.error('Erro original:', originalError);
        }
    }
    
    // Lança o erro se necessário
    if (config.throwErrors) {
        throw error;
    }
    
    return error;
}

/**
 * Trata um erro de parâmetro inválido
 * 
 * @param {string} paramName - Nome do parâmetro
 * @param {string} [reason] - Motivo da invalidação
 * @returns {Error} - Objeto de erro
 */
function handleInvalidParameter(paramName, reason) {
    const args = [paramName];
    if (reason) args.push(reason);
    return handleError(errorCodes.INVALID_PARAMETER, args);
}

/**
 * Trata um erro de parâmetro ausente
 * 
 * @param {string} paramName - Nome do parâmetro
 * @returns {Error} - Objeto de erro
 */
function handleMissingParameter(paramName) {
    return handleError(errorCodes.MISSING_PARAMETER, [paramName]);
}

/**
 * Trata um erro de carregamento de imagem
 * 
 * @param {string} url - URL da imagem
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleImageLoadError(url, originalError) {
    return handleError(errorCodes.IMAGE_LOAD_ERROR, [url], originalError);
}

/**
 * Trata um erro de processamento de imagem
 * 
 * @param {string} operation - Operação de processamento
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleImageProcessError(operation, originalError) {
    return handleError(errorCodes.IMAGE_PROCESS_ERROR, [operation], originalError);
}

/**
 * Trata um erro de criação de banner
 * 
 * @param {string} bannerType - Tipo de banner
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleBannerCreationError(bannerType, originalError) {
    return handleError(errorCodes.BANNER_CREATION_ERROR, [bannerType], originalError);
}

/**
 * Trata um erro interno
 * 
 * @param {string} message - Mensagem de erro
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleInternalError(message, originalError) {
    return handleError(errorCodes.INTERNAL_ERROR, [message], originalError);
}

/**
 * Trata um erro de sistema de arquivos
 * 
 * @param {string} operation - Operação de sistema de arquivos
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleFileSystemError(operation, originalError) {
    return handleError(errorCodes.FILE_SYSTEM_ERROR, [operation], originalError);
}

/**
 * Trata um erro de rede
 * 
 * @param {string} url - URL da requisição
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleNetworkError(url, originalError) {
    return handleError(errorCodes.NETWORK_ERROR, [url], originalError);
}

/**
 * Trata um erro de cache
 * 
 * @param {string} operation - Operação de cache
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleCacheError(operation, originalError) {
    return handleError(errorCodes.CACHE_ERROR, [operation], originalError);
}

/**
 * Trata um erro de otimização
 * 
 * @param {string} operation - Operação de otimização
 * @param {Error} [originalError] - Erro original
 * @returns {Error} - Objeto de erro
 */
function handleOptimizationError(operation, originalError) {
    return handleError(errorCodes.OPTIMIZATION_ERROR, [operation], originalError);
}

/**
 * Define se o modo de debug está habilitado
 * 
 * @param {boolean} debug - Se o modo de debug está habilitado
 */
function setDebug(debug) {
    config.debug = debug;
}

/**
 * Configura as opções de tratamento de erros
 * 
 * @param {Object} options - Opções de configuração
 * @param {boolean} [options.debug] - Se deve mostrar mensagens de debug
 * @param {boolean} [options.logErrors] - Se deve registrar erros no console
 * @param {boolean} [options.throwErrors] - Se deve lançar erros
 * @param {boolean} [options.useErrorCodes] - Se deve usar códigos de erro
 * @param {boolean} [options.useErrorTranslation] - Se deve traduzir mensagens de erro
 * @param {string} [options.language] - Idioma para mensagens de erro
 */
function configure(options) {
    config = { ...config, ...options };
}

/**
 * Obtém a configuração atual
 * 
 * @returns {Object} - Configuração atual
 */
function getConfig() {
    return { ...config };
}

module.exports = {
    errorCodes,
    handleError,
    handleInvalidParameter,
    handleMissingParameter,
    handleImageLoadError,
    handleImageProcessError,
    handleBannerCreationError,
    handleInternalError,
    handleFileSystemError,
    handleNetworkError,
    handleCacheError,
    handleOptimizationError,
    setDebug,
    configure,
    getConfig
};