dcos-core-monalisav2-latam 1.0.0

package/src/common/utils/account-error-handler.js

@@ -0,0 +1,279 @@
+const ApiResponse = require("./api-response");
+const AccountErrorManager = require("../../integrations/accountErrors/AccountErrorManager");
+const Logger = require("./logger");
+
+const handler = async (event) => {
+  const { httpMethod, resource, pathParameters, queryStringParameters } = event;
+  
+  try {
+    switch (resource) {
+      case "/errors":
+        if (httpMethod === "GET") {
+          return await listErrors(queryStringParameters);
+        } else if (httpMethod === "POST") {
+          return await createErrors(event.body);
+        }
+        break;
+        
+      case "/errors/{errorCode}":
+        const { errorCode } = pathParameters || {};
+        if (!errorCode) {
+          return ApiResponse.response(400, { error: "Error code is required" });
+        }
+        
+        if (httpMethod === "GET") {
+          return await getError(errorCode);
+        } else if (httpMethod === "PUT") {
+          return await updateError(errorCode, event.body);
+        } else if (httpMethod === "DELETE") {
+          return await deleteError(errorCode);
+        }
+        break;
+        
+      default:
+        return ApiResponse.response(404, { error: "Resource not found" });
+    }
+    
+    return ApiResponse.response(405, { error: "Method not allowed" });
+    
+  } catch (error) {
+    Logger.error("Error in account errors handler:", error);
+    return ApiResponse.response(500, { error: "Internal server error", details: error.message });
+  }
+};
+
+const listErrors = async (queryParams = {}) => {
+  try {
+    const safeQueryParams = queryParams || {};
+    
+    const filters = {
+      limit: safeQueryParams.limit ? parseInt(safeQueryParams.limit) : 100,
+      category: safeQueryParams.category,
+      severity: safeQueryParams.severity,
+      lastEvaluatedKey: safeQueryParams.lastEvaluatedKey
+    };
+
+    const result = await AccountErrorManager.listErrors(filters);
+    
+    return ApiResponse.response(200, {
+      message: "Errors retrieved successfully",
+      data: result.items,
+      pagination: {
+        count: result.count,
+        lastEvaluatedKey: result.lastEvaluatedKey ? JSON.stringify(result.lastEvaluatedKey) : null,
+        hasMore: !!result.lastEvaluatedKey
+      }
+    });
+    
+  } catch (error) {
+    Logger.error("Error listing errors:", error);
+    return ApiResponse.response(500, { error: "Error retrieving errors", details: error.message });
+  }
+};
+
+const getError = async (errorCode) => {
+  try {
+    const error = await AccountErrorManager.getError(errorCode);
+    
+    if (!error) {
+      return ApiResponse.response(404, { error: "Error code not found" });
+    }
+    
+    return ApiResponse.response(200, {
+      message: "Error retrieved successfully",
+      data: error
+    });
+    
+  } catch (error) {
+    Logger.error(`Error getting error ${errorCode}:`, error);
+    return ApiResponse.response(500, { error: "Error retrieving error", details: error.message });
+  }
+};
+
+const createErrors = async (body) => {
+  try {
+    if (!body) {
+      return ApiResponse.response(400, { error: "Request body is required" });
+    }
+    
+    const requestData = JSON.parse(body);
+    const isArray = Array.isArray(requestData);
+    const errorsToCreate = isArray ? requestData : [requestData];
+    
+    Logger.info(`Creating ${errorsToCreate.length} error(s)`, {
+      isArray,
+      count: errorsToCreate.length
+    });
+
+    const validationErrors = [];
+    errorsToCreate.forEach((errorData, index) => {
+      const prefix = isArray ? `Error[${index}]` : 'Error';
+      
+      if (!errorData.ErrorCode) {
+        validationErrors.push(`${prefix}: ErrorCode is required`);
+      }
+      if (!errorData.HttpStatus || typeof errorData.HttpStatus !== 'number') {
+        validationErrors.push(`${prefix}: HttpStatus must be a valid number`);
+      }
+      if (!errorData.Message) {
+        validationErrors.push(`${prefix}: Message is required`);
+      }
+      if (!errorData.Category) {
+        validationErrors.push(`${prefix}: Category is required`);
+      }
+      if (!errorData.Severity) {
+        validationErrors.push(`${prefix}: Severity is required`);
+      }
+    });
+
+    if (validationErrors.length > 0) {
+      return ApiResponse.response(400, { 
+        error: "Validation failed", 
+        validationErrors: validationErrors 
+      });
+    }
+
+    const successfulCreations = [];
+    const failedCreations = [];
+
+    for (let i = 0; i < errorsToCreate.length; i++) {
+      const errorData = errorsToCreate[i];
+      const prefix = isArray ? `[${i}]` : '';
+      
+      try {
+        const createdError = await AccountErrorManager.createError(errorData);
+        
+        successfulCreations.push({
+          index: isArray ? i : null,
+          errorCode: errorData.ErrorCode,
+          status: 'created',
+          data: createdError
+        });
+        
+        Logger.debug(`Error ${prefix} created successfully:`, errorData.ErrorCode);
+        
+      } catch (error) {
+        failedCreations.push({
+          index: isArray ? i : null,
+          errorCode: errorData.ErrorCode,
+          status: 'failed',
+          error: error.message,
+          details: errorData
+        });
+        
+        Logger.error(`Error ${prefix} creation failed:`, {
+          errorCode: errorData.ErrorCode,
+          error: error.message
+        });
+      }
+    }
+
+    const totalCount = errorsToCreate.length;
+    const successCount = successfulCreations.length;
+    const failureCount = failedCreations.length;
+
+    let statusCode;
+    let message;
+    
+    if (failureCount === 0) {
+      statusCode = 201;
+      message = isArray 
+        ? `All ${totalCount} errors created successfully`
+        : "Error created successfully";
+    } else if (successCount === 0) {
+      statusCode = 400;
+      message = isArray 
+        ? `All ${totalCount} errors failed to create`
+        : "Error creation failed";
+    } else {
+      statusCode = 207;
+      message = `${successCount} of ${totalCount} errors created successfully`;
+    }
+
+    const responseData = {
+      message: message,
+      summary: {
+        total: totalCount,
+        successful: successCount,
+        failed: failureCount,
+        is_array: isArray
+      }
+    };
+
+    if (isArray || failureCount > 0) {
+      responseData.results = {
+        successful: successfulCreations,
+        failed: failedCreations
+      };
+    } else {
+      responseData.data = successfulCreations[0]?.data;
+    }
+
+    return ApiResponse.response(statusCode, responseData);
+    
+  } catch (error) {
+    Logger.error("Error in createErrors:", error);
+    
+    if (error.message && error.message.includes("already exists")) {
+      return ApiResponse.response(409, { error: error.message });
+    }
+    
+    return ApiResponse.response(500, { error: "Error creating errors", details: error.message });
+  }
+};
+
+const updateError = async (errorCode, body) => {
+  try {
+    if (!body) {
+      return ApiResponse.response(400, { error: "Request body is required" });
+    }
+    
+    const errorData = JSON.parse(body);
+    
+    if (errorData.HttpStatus && typeof errorData.HttpStatus !== 'number') {
+      return ApiResponse.response(400, { error: "HttpStatus must be a valid number" });
+    }
+    
+    const updatedError = await AccountErrorManager.updateError(errorCode, errorData);
+    
+    return ApiResponse.response(200, {
+      message: "Error updated successfully",
+      data: updatedError
+    });
+    
+  } catch (error) {
+    Logger.error(`Error updating error ${errorCode}:`, error);
+    
+    if (error.message.includes("not found")) {
+      return ApiResponse.response(404, { error: error.message });
+    }
+    
+    if (error.message.includes("No fields to update")) {
+      return ApiResponse.response(400, { error: error.message });
+    }
+    
+    return ApiResponse.response(500, { error: "Error updating error", details: error.message });
+  }
+};
+
+const deleteError = async (errorCode) => {
+  try {
+    await AccountErrorManager.deleteError(errorCode);
+    
+    return ApiResponse.response(200, {
+      message: "Error deleted successfully",
+      deleted: true
+    });
+    
+  } catch (error) {
+    Logger.error(`Error deleting error ${errorCode}:`, error);
+    
+    if (error.message.includes("not found")) {
+      return ApiResponse.response(404, { error: error.message });
+    }
+    
+    return ApiResponse.response(500, { error: "Error deleting error", details: error.message });
+  }
+};
+
+module.exports = { handler };

package/src/common/utils/account-error-helper.js

@@ -0,0 +1,231 @@
+const AccountErrorManager = require("../../integrations/accountErrors/AccountErrorManager");
+const Logger = require("./logger");
+
+/**
+ * Clase helper moderna para gestión de errores de Account
+ * 100% basada en DynamoDB, con fallbacks robustos
+ */
+class AccountErrors {
+  
+  /**
+   * Crea una respuesta de error
+   * @param {string} errorCode - Código de error
+   * @param {Object} replacements - Variables para reemplazar
+   * @returns {Promise<Object>} Respuesta de error
+   */
+  static async createError(errorCode, replacements = {}) {
+    try {
+      return await AccountErrorManager.createResponse(errorCode, replacements);
+    } catch (error) {
+      Logger.error(`Critical error in createError for ${errorCode}:`, error);
+      
+      // Fallback de emergencia
+      return this._emergencyFallback(errorCode, error);
+    }
+  }
+
+  /**
+   * Manejo de errores con contexto específico
+   * @param {string} errorCode - Código de error
+   * @param {Object} context - Contexto adicional
+   * @returns {Promise<Object>} Respuesta de error
+   */
+  static async handleError(errorCode, context = {}) {
+    const { variables = {}, logDetails = null } = context;
+    
+    // Log del error si se proporcionan detalles
+    if (logDetails) {
+      Logger.error(`Account Error ${errorCode}:`, logDetails);
+    }
+    
+    return await this.createError(errorCode, variables);
+  }
+
+  /**
+   * Crea error con logging automático
+   * @param {string} errorCode - Código de error
+   * @param {Error} originalError - Error original para logging
+   * @param {Object} variables - Variables para reemplazar
+   * @returns {Promise<Object>} Respuesta de error
+   */
+  static async createWithLogging(errorCode, originalError = null, variables = {}) {
+    if (originalError) {
+      Logger.error(`Account Error ${errorCode} - Original:`, {
+        message: originalError.message,
+        stack: originalError.stack,
+        name: originalError.name
+      });
+    }
+    
+    return await this.createError(errorCode, variables);
+  }
+
+  /**
+   * Valida y crea error con fallback
+   * @param {string} errorCode - Código de error
+   * @param {Object} variables - Variables para reemplazar
+   * @param {string} fallbackMessage - Mensaje de fallback
+   * @returns {Promise<Object>} Respuesta de error
+   */
+  static async createSafe(errorCode, variables = {}, fallbackMessage = "An error occurred") {
+    try {
+      return await this.createError(errorCode, variables);
+    } catch (error) {
+      Logger.error(`Failed to create error ${errorCode}:`, error);
+      
+      return this._manualFallback(errorCode, fallbackMessage, variables);
+    }
+  }
+
+  /**
+   * ✅ NUEVO: Inicializa errores básicos del sistema
+   * @returns {Promise<Object>} Resultado de la inicialización
+   */
+  static async initializeSystemErrors() {
+    try {
+      const results = await AccountErrorManager.initializeBasicErrors();
+      return {
+        success: true,
+        message: "System errors initialized successfully",
+        results: results
+      };
+    } catch (error) {
+      Logger.error("Failed to initialize system errors:", error);
+      return {
+        success: false,
+        message: "Failed to initialize system errors",
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * ✅ NUEVO: Verifica la salud del sistema de errores
+   * @returns {Promise<Object>} Estado del sistema
+   */
+  static async healthCheck() {
+    try {
+      // Intentar obtener un error básico
+      const testError = await AccountErrorManager.getError('ACCOUNT_001');
+      
+      return {
+        status: 'healthy',
+        dynamodb_connection: 'ok',
+        basic_errors_available: !!testError,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      return {
+        status: 'unhealthy',
+        dynamodb_connection: 'failed',
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Fallback de emergencia cuando todo falla
+   * @private
+   */
+  static _emergencyFallback(errorCode, originalError) {
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        error: errorCode || 'CRITICAL_SYSTEM_ERROR',
+        message: "A critical system error occurred. Please contact support immediately.",
+        emergency_fallback: true,
+        timestamp: new Date().toISOString(),
+        trace_id: Math.random().toString(36).substring(2, 15)
+      }, null, 2),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+  }
+
+  /**
+   * Fallback manual con mensaje personalizado
+   * @private
+   */
+  static _manualFallback(errorCode, fallbackMessage, variables = {}) {
+    // Intentar reemplazar variables en el mensaje de fallback
+    let message = fallbackMessage;
+    Object.keys(variables).forEach(key => {
+      const placeholder = `{${key}}`;
+      message = message.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), variables[key]);
+    });
+
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        error: errorCode,
+        message: message,
+        manual_fallback: true,
+        timestamp: new Date().toISOString()
+      }, null, 2),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+  }
+
+  /**
+   * Métodos helper rápidos para errores comunes
+   */
+  
+  // Errores críticos del sistema
+  static async systemError(details = null) {
+    return await this.createWithLogging('ACCOUNT_026', details);
+  }
+  
+  // Error de entrada básico
+  static async invalidInput(field = 'data') {
+    return await this.createError('ACCOUNT_001');
+  }
+  
+  // Error de cuenta no encontrada (genérico)
+  static async notFound(accountName = null) {
+    return await this.createError('ACCOUNT_028', { accountName: accountName || 'Unknown' });
+  }
+  
+  // Error de validación de coordenadas
+  static async coordinatesError(accountName, coordinates = 'N/A') {
+    return await this.createError('ACCOUNT_010', { 
+      AccountName: accountName, 
+      context: 'coordinates',
+      latitude: 'N/A',
+      longitude: 'N/A'
+    });
+  }
+  
+  // Error de seller en marketplace
+  static async sellerError(sellerId) {
+    return await this.createError('ACCOUNT_014', { SellerId: sellerId });
+  }
+
+  /**
+   * ✅ NUEVO: Helper para migrar desde JSON (útil para desarrollo)
+   * @param {Object} jsonErrors - Errores del JSON original
+   * @returns {Promise<Object>} Resultado de la migración
+   */
+  static async migrateFromJson(jsonErrors) {
+    try {
+      const results = await AccountErrorManager.migrateFromJson(jsonErrors);
+      return {
+        success: true,
+        message: "Migration completed",
+        results: results
+      };
+    } catch (error) {
+      Logger.error("Migration failed:", error);
+      return {
+        success: false,
+        message: "Migration failed",
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = AccountErrors;