dcos-core-monalisav2-latam 1.0.0

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

@@ -0,0 +1,355 @@
+// src/functions/utils/account-properties-handler.js
+
+const fs = require('fs');
+const path = require('path');
+const ApiResponse = require('./api-response');
+const Logger = require('./logger');
+
+/**
+ * Procesa recursivamente las propiedades del schema para extraer toda la información
+ * @param {Object} properties - Propiedades del schema
+ * @param {Array} requiredFields - Campos requeridos en este nivel
+ * @param {String} parentPath - Ruta padre para propiedades anidadas
+ * @returns {Object} Estructura procesada con metadatos
+ */
+const processSchemaProperties = (properties, requiredFields = [], parentPath = '') => {
+    const processedProperties = {};
+
+    for (const [key, value] of Object.entries(properties)) {
+        const currentPath = parentPath ? `${parentPath}.${key}` : key;
+        const isRequired = requiredFields.includes(key);
+
+        processedProperties[key] = {
+            path: currentPath,
+            type: value.type,
+            required: isRequired,
+            description: value.description || null
+        };
+
+        // Agregar información adicional según el tipo
+        if (value.minLength !== undefined) {
+            processedProperties[key].minLength = value.minLength;
+        }
+
+        if (value.maxLength !== undefined) {
+            processedProperties[key].maxLength = value.maxLength;
+        }
+
+        if (value.pattern !== undefined) {
+            processedProperties[key].pattern = value.pattern;
+        }
+
+        if (value.enum !== undefined) {
+            processedProperties[key].enum = value.enum;
+        }
+
+        if (value.minimum !== undefined) {
+            processedProperties[key].minimum = value.minimum;
+        }
+
+        if (value.maximum !== undefined) {
+            processedProperties[key].maximum = value.maximum;
+        }
+
+        if (value.minProperties !== undefined) {
+            processedProperties[key].minProperties = value.minProperties;
+        }
+
+        if (value.additionalProperties !== undefined) {
+            processedProperties[key].additionalProperties = value.additionalProperties;
+        }
+
+        // Procesar propiedades anidadas para objetos
+        if (value.type === 'object' && value.properties) {
+            processedProperties[key].nested_properties = processSchemaProperties(
+                value.properties,
+                value.required || [],
+                currentPath
+            );
+        }
+
+        // Procesar items para arrays
+        if (value.type === 'array' && value.items) {
+            if (value.items.type === 'object' && value.items.properties) {
+                processedProperties[key].items = {
+                    type: value.items.type,
+                    properties: processSchemaProperties(
+                        value.items.properties,
+                        value.items.required || [],
+                        `${currentPath}[]`
+                    )
+                };
+            } else {
+                processedProperties[key].items = {
+                    type: value.items.type
+                };
+            }
+        }
+
+        // Manejar patternProperties para objetos dinámicos
+        if (value.patternProperties) {
+            processedProperties[key].patternProperties = {};
+            for (const [pattern, patternValue] of Object.entries(value.patternProperties)) {
+                processedProperties[key].patternProperties[pattern] = {
+                    type: patternValue.type,
+                    properties: patternValue.properties ? processSchemaProperties(
+                        patternValue.properties,
+                        patternValue.required || [],
+                        `${currentPath}.${pattern}`
+                    ) : undefined
+                };
+            }
+        }
+    }
+
+    return processedProperties;
+};
+
+/**
+ * Obtiene un resumen de campos requeridos de manera plana
+ * @param {Object} processedSchema - Schema procesado
+ * @param {String} parentPath - Ruta padre
+ * @returns {Array} Lista de rutas de campos requeridos
+ */
+const getRequiredFieldsPaths = (processedSchema, parentPath = '') => {
+    const requiredPaths = [];
+
+    for (const [key, value] of Object.entries(processedSchema)) {
+        const currentPath = parentPath ? `${parentPath}.${key}` : key;
+
+        if (value.required) {
+            requiredPaths.push(currentPath);
+        }
+
+        if (value.nested_properties) {
+            requiredPaths.push(...getRequiredFieldsPaths(value.nested_properties, currentPath));
+        }
+
+        if (value.items && value.items.properties) {
+            requiredPaths.push(...getRequiredFieldsPaths(value.items.properties, `${currentPath}[]`));
+        }
+
+        if (value.patternProperties) {
+            for (const [pattern, patternValue] of Object.entries(value.patternProperties)) {
+                if (patternValue.properties) {
+                    requiredPaths.push(...getRequiredFieldsPaths(patternValue.properties, `${currentPath}.${pattern}`));
+                }
+            }
+        }
+    }
+
+    return requiredPaths;
+};
+
+/**
+ * Obtiene estadísticas del schema
+ * @param {Object} processedSchema - Schema procesado
+ * @returns {Object} Estadísticas del schema
+ */
+const getSchemaStatistics = (processedSchema) => {
+    let totalFields = 0;
+    let requiredFields = 0;
+    let optionalFields = 0;
+    let objectFields = 0;
+    let arrayFields = 0;
+    let primitiveFields = 0;
+
+    const countFields = (schema) => {
+        for (const [key, value] of Object.entries(schema)) {
+            totalFields++;
+
+            if (value.required) {
+                requiredFields++;
+            } else {
+                optionalFields++;
+            }
+
+            switch (value.type) {
+                case 'object':
+                    objectFields++;
+                    break;
+                case 'array':
+                    arrayFields++;
+                    break;
+                default:
+                    primitiveFields++;
+            }
+
+            if (value.nested_properties) {
+                countFields(value.nested_properties);
+            }
+
+            if (value.items && value.items.properties) {
+                countFields(value.items.properties);
+            }
+
+            if (value.patternProperties) {
+                for (const [pattern, patternValue] of Object.entries(value.patternProperties)) {
+                    if (patternValue.properties) {
+                        countFields(patternValue.properties);
+                    }
+                }
+            }
+        }
+    };
+
+    countFields(processedSchema);
+
+    return {
+        total_fields: totalFields,
+        required_fields: requiredFields,
+        optional_fields: optionalFields,
+        object_fields: objectFields,
+        array_fields: arrayFields,
+        primitive_fields: primitiveFields
+    };
+};
+
+/**
+ * Handler principal para obtener las propiedades del schema de Account
+ */
+const getAccountProperties = async () => {
+    try {
+        // Ruta al archivo del schema - ajustar según estructura del proyecto
+        const schemaPath = path.join(__dirname, '../../../json/schema-valid-json-account.json');
+
+        // Verificar que el archivo existe
+        if (!fs.existsSync(schemaPath)) {
+            Logger.error('Account schema file not found:', schemaPath);
+            return ApiResponse.response(404, {
+                error: 'Schema file not found',
+                details: 'The account schema definition file could not be located'
+            });
+        }
+
+        // Leer y parsear el schema
+        const schemaContent = fs.readFileSync(schemaPath, 'utf8');
+        const accountSchema = JSON.parse(schemaContent);
+
+        // Procesar el schema
+        const processedSchema = processSchemaProperties(
+            accountSchema.properties,
+            accountSchema.required || []
+        );
+
+        // Obtener rutas de campos requeridos
+        const requiredPaths = getRequiredFieldsPaths(processedSchema);
+
+        // Obtener estadísticas
+        const statistics = getSchemaStatistics(processedSchema);
+
+        // Construir respuesta
+        const response = {
+            schema_info: {
+                title: accountSchema.title || 'Account Schema',
+                description: accountSchema.description || 'Schema definition for Account entity',
+                schema_version: accountSchema.$schema || 'http://json-schema.org/draft-07/schema#',
+                total_root_properties: Object.keys(accountSchema.properties || {}).length,
+                total_required_root_properties: (accountSchema.required || []).length,
+                schema_type: accountSchema.type || 'object',
+                generated_at: new Date().toISOString()
+            },
+            properties: processedSchema,
+            required_fields_summary: requiredPaths,
+            statistics: statistics
+        };
+
+        Logger.info('Account properties processed successfully');
+        return ApiResponse.response(200, response);
+
+    } catch (error) {
+        Logger.error('Error processing account properties:', error);
+
+        if (error instanceof SyntaxError) {
+            return ApiResponse.response(400, {
+                error: 'Invalid schema format',
+                details: 'The schema file contains invalid JSON'
+            });
+        }
+
+        return ApiResponse.response(500, {
+            error: 'Error processing account properties',
+            details: error.message
+        });
+    }
+};
+
+/**
+ * Handler para obtener solo los campos requeridos
+ */
+const getRequiredFields = async () => {
+    try {
+        const schemaPath = path.join(__dirname, '../../json/schema-valid-json-account.json');
+
+        if (!fs.existsSync(schemaPath)) {
+            return ApiResponse.response(404, {
+                error: 'Schema file not found'
+            });
+        }
+
+        const schemaContent = fs.readFileSync(schemaPath, 'utf8');
+        const accountSchema = JSON.parse(schemaContent);
+
+        const processedSchema = processSchemaProperties(
+            accountSchema.properties,
+            accountSchema.required || []
+        );
+
+        const requiredPaths = getRequiredFieldsPaths(processedSchema);
+
+        return ApiResponse.response(200, {
+            required_fields: requiredPaths,
+            count: requiredPaths.length,
+            root_required: accountSchema.required || [],
+            generated_at: new Date().toISOString()
+        });
+
+    } catch (error) {
+        Logger.error('Error getting required fields:', error);
+        return ApiResponse.response(500, {
+            error: 'Error processing required fields',
+            details: error.message
+        });
+    }
+};
+
+/**
+ * Handler principal que maneja las rutas de propiedades de account
+ */
+const handler = async (event) => {
+    const { resource, httpMethod } = event;
+
+    try {
+        switch (resource) {
+            case "/accounts/properties":
+                if (httpMethod === "GET") {
+                    return await getAccountProperties();
+                }
+                break;
+
+            case "/accounts/properties/required":
+                if (httpMethod === "GET") {
+                    return await getRequiredFields();
+                }
+                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 properties handler:", error);
+        return ApiResponse.response(500, {
+            error: "Internal server error",
+            details: error.message
+        });
+    }
+};
+
+module.exports = {
+    handler,
+    getAccountProperties,
+    getRequiredFields
+};

package/src/common/utils/api-response.js

@@ -0,0 +1,62 @@
+const Logger = require("./logger");
+
+/**
+ * @param {number} statusCode
+ * @param {string} message
+ * @returns {import("aws-lambda").APIGatewayProxyResult}
+ * @example
+ * return response(404, "Account not found");
+ * @example
+ * return response(200, "Account found");
+ * */
+const response = (statusCode, message, headers = {}) => {
+  if (message && typeof message === "string") {
+    message = JSON.stringify({ message }, null, 2);
+  } else if (message && typeof message === "object") {
+    message = JSON.stringify(message, null, 2);
+  } else {
+    message = JSON.stringify({ message: "Unknown error" }, null, 2);
+  }
+  return {
+    statusCode: statusCode || 500,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: message,
+  };
+};
+
+
+const responseNoCors = (statusCode, message) => {
+  if (message && typeof message === "string") {
+    message = JSON.stringify({ message }, null, 2);
+  } else if (message && typeof message === "object") {
+    message = JSON.stringify(message, null, 2);
+  } else {
+    message = JSON.stringify({ message: "Unknown error" }, null, 2);
+  }
+  return {
+    statusCode: statusCode || 500,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers": "*",
+      "Access-Control-Allow-Methods": "*",
+    },
+    body: message,
+  };
+};
+
+const validateRequiredParam = (name, evaluate) => {
+  if (!evaluate) {
+    Logger.error(`${name} is required`);
+    return response(400, `${name} is required`);
+  }
+};
+
+module.exports = {
+  response,
+  responseNoCors,
+  validateRequiredParam,
+};

package/src/common/utils/aws-services.js

@@ -0,0 +1,186 @@
+const { SQS, SSM, SecretsManager, DynamoDB } = require("aws-sdk");
+const REGION_PROJECT = process.env.REGION_PROJECT;
+const GeneralRequiredError = require("../../common/validation/GeneralErrorValidation.js");
+const dynamoDb = new DynamoDB();
+const Logger = require("./logger");
+
+const sendSQSMessage = async (url, message) => {
+  const sqs = new SQS();
+  const params = {
+    MessageBody: JSON.stringify(message),
+    QueueUrl: url,
+  };
+  if (process.env.SQS_DELAY_SECONDS) {
+    params.DelaySeconds = process.env.SQS_DELAY_SECONDS;
+  }
+  await sqs.sendMessage(params).promise();
+  Logger.debug("Sending message to SQS", {
+    action: "SQS_SEND",
+    message: message,
+    url: URL
+  });
+};
+
+/**
+ * Envia un mensaje a una cola SQS.
+ * @param {string} url URL de la cola SQS a la que se enviará el mensaje.
+ * @param {object} message Objeto JSON con los datos a enviar a la cola.
+ * @returns 
+ */
+const sendMessageToSqs = async (url, message) => {
+  return new Promise((resolve, reject) => {
+    const sqs = new SQS()
+
+    // Si el "message" es un objeto, se hace una conversión a JSON String
+    if (typeof message === 'object') {
+      message = JSON.stringify(message);
+    }
+
+    const params = {
+      MessageBody: message,
+      QueueUrl: url
+    };
+    if (process?.env?.SQS_DELAY_SECONDS) {
+      params.DelaySeconds = process.env.SQS_DELAY_SECONDS;
+    }
+
+    // Se ejecuta la tarea de enviar el mensaje a SQS
+    sqs.sendMessage(params, (err, data) => {
+      if (err) {
+        Logger.error('Error in SQS:', err);
+        reject(err);
+      } else {
+        const { MessageId } = data;
+        Logger.info("Message sent", {
+          action: "SQS_SEND",
+          message,
+          url,
+          messageId: MessageId
+        })
+        resolve(data);
+      }
+    });
+  });
+};
+
+const getSecretValue = async (paramPath) => {
+  const ssm = new SSM();
+  const params = {
+    Name: paramPath,
+    WithDecryption: true,
+  };
+  try {
+    const response = await ssm.getParameter(params).promise();
+    const secretValue = response.Parameter.Value;
+    return secretValue;
+  } catch (error) {
+    Logger.error("Error getting secret value from SSM: ", error);
+    throw error;
+  }
+};
+
+const getSecretValueSecretsManager = async (secretName) => {
+  const client = new SecretsManager({ region: REGION_PROJECT });
+  const params = { SecretId: secretName };
+  try {
+    const response = await client.getSecretValue(params).promise();
+    if ('SecretString' in response) {
+      const secret = JSON.parse(response.SecretString);
+      return secret;
+    }
+    throw new GeneralRequiredError(`Secret information not found.`);
+  } catch (error) {
+    Logger.error("Error getting secret: ", error);
+    throw new GeneralRequiredError(`Error getting secret value from SecretsManager: ${error.message}`);
+  }
+};
+
+/**
+ * Convierte un objeto JavaScript a formato DynamoDB
+ * @param {object} data - Objeto JavaScript a convertir
+ * @returns {object} - Objeto en formato DynamoDB
+ */
+const marshall = (data) => {
+  try {
+    return DynamoDB.Converter.marshall(data);
+  } catch (error) {
+    Logger.error("Error marshalling data", { error: error.message });
+    throw new GeneralRequiredError(`Marshalling failed: ${error.message}`);
+  }
+};
+
+/**
+ * Convierte un objeto DynamoDB a JavaScript
+ * @param {object} data - Objeto DynamoDB a convertir
+ * @returns {object} - Objeto JavaScript
+ */
+const unmarshall = (data) => {
+  try {
+    return DynamoDB.Converter.unmarshall(data);
+  } catch (error) {
+    Logger.error("Error unmarshalling data", { error: error.message });
+    throw new GeneralRequiredError(`Unmarshalling failed: ${error.message}`);
+  }
+};
+
+/**
+ * Ejecuta una operación Scan en DynamoDB
+ * @param {object} params - Parámetros para la operación Scan
+ * @returns {Promise<object>} - Resultado del escaneo
+ */
+const dynamoScan = async (params) => {
+  try {
+    const result = await dynamoDb.scan(params).promise();
+    return result;
+  } catch (error) {
+    throw new Error(`DynamoDB Scan failed: ${error.message}`);
+  }
+};
+
+/**
+ * Ejecuta una operación Query en DynamoDB
+ * @param {object} params - Parámetros para la operación Query
+ * @returns {Promise<object>} - Resultado de la consulta
+ */
+const dynamoQuery = async (params) => {
+  try {
+    return await dynamoDb.query(params).promise();
+  } catch (error) {
+    Logger.error("DynamoDB query failed", {
+      action: "DYNAMO_QUERY_ERROR",
+      table: params.TableName,
+      error: error.message
+    });
+    throw new GeneralRequiredError(`DynamoDB query failed: ${error.message}`);
+  }
+};
+
+/**
+ * Ejecuta una operación BatchWrite en DynamoDB
+ * @param {object} params - Parámetros para la operación BatchWrite
+ * @returns {Promise<object>} - Resultado de la operación
+ */
+const dynamoBatchWrite = async (params) => {
+  try {
+    return await dynamoDb.batchWriteItem(params).promise();
+  } catch (error) {
+    Logger.error("DynamoDB batch write failed", {
+      action: "DYNAMO_BATCH_WRITE_ERROR",
+      table: Object.keys(params.RequestItems)[0],
+      error: error.message
+    });
+    throw new GeneralRequiredError(`DynamoDB batch write failed: ${error.message}`);
+  }
+};
+
+module.exports = {
+  sendSQSMessage,
+  sendMessageToSqs,
+  getSecretValue,
+  getSecretValueSecretsManager,
+  marshall,
+  unmarshall,
+  dynamoQuery,
+  dynamoScan,
+  dynamoBatchWrite
+};