dcos-core-monalisav2-latam 1.0.0

package/src/functions/vtex/vtex-helpers.js

@@ -0,0 +1,694 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const list_products_vtex = async (event) => {
+  const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+  let statusCode = 200;
+  let responseService = [];
+
+  const anRequest = event?.queryStringParameters?.an ?? null;
+  if(anRequest){
+    const validAccount = await ClientData.validateAccount(clientId, anRequest);
+    if (!validAccount) {
+      Logger.error("Data INVALID: ", validAccount);
+      return ApiResponse.response(404, "Account not found");
+    }
+  }
+
+  const listAccounts = anRequest ? null : await ClientData.getClient(clientId);
+  const an = listAccounts ? listAccounts?.AccountNames?.values[0] : anRequest;
+  if (!an) {
+    Logger.error("Error service: ", "AccountName not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccount = await AccountData.getAccountDataByAccountName(an);
+
+  if (!configAccount) {
+    Logger.error("Error service: ", "Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccountParent = configAccount?.AccountName === configAccount?.ParentAccountName ? configAccount : await AccountData.getAccountDataByAccountName(configAccount?.ParentAccountName);
+
+  if (!configAccountParent) {
+    Logger.error("Error service: ", "Parent Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+
+  try {
+    let productAll= event?.queryStringParameters?.ProductsAll ?? null;
+    
+    if(typeof productAll === "string"){
+      productAll= productAll.toLowerCase();
+    }
+
+    const apiClient = new VtexApi(configAccountParent?.AccountName, configAccountParent?.Credentials?.key, configAccountParent?.Credentials?.token);
+    const isActive= event?.queryStringParameters?.isActive ?? null;
+    const isVisible= event?.queryStringParameters?.isVisible ?? null;
+    const sc= event?.queryStringParameters?.sc ?? "1";
+    const lengthData= event?.queryStringParameters?.rows ?? 2000;
+    
+    if(productAll && (productAll===true || productAll==='true')){
+      responseService= await apiClient.getProductsAll(isActive, isVisible, sc, lengthData);
+    }else{
+      responseService= await apiClient.getProducts(event, isActive, isVisible, sc, lengthData);
+    }
+  } catch (error) {
+    Logger.error("Error service: ", error);
+    statusCode = 500;
+  }
+
+  return ApiResponse.response(statusCode, responseService);
+};
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const list_categories_vtex = async (event) => {
+  const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+  const anRequest = event?.queryStringParameters?.an ?? null;
+  if(anRequest){
+    const validAccount = await ClientData.validateAccount(clientId, anRequest);
+    if (!validAccount) {
+      Logger.error("Data INVALID: ", validAccount);
+      return ApiResponse.response(404, "Account not found");
+    }
+  }
+
+  const listAccounts = anRequest ? null : await ClientData.getClient(clientId);
+  const categoryLevels = event?.pathParameters?.categoryLevels;
+  let statusCode = 200;
+  let responseService = [];
+  const an = listAccounts ? listAccounts?.AccountNames?.values[0] : anRequest;
+  if (!an) {
+    Logger.error("Error service: ", "AccountName not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccount = await AccountData.getAccountDataByAccountName(an);
+
+  if (!configAccount) {
+    Logger.error("Error service: ", "Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccountParent = configAccount?.AccountName === configAccount?.ParentAccountName ? configAccount : await AccountData.getAccountDataByAccountName(configAccount?.ParentAccountName);
+
+  if (!configAccountParent) {
+    Logger.error("Error service: ", "Parent Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+
+  try {
+    const apiClient = new VtexApi(configAccountParent?.AccountName, configAccountParent?.Credentials?.key, configAccountParent?.Credentials?.token);
+    const response = await apiClient.fetch(`/catalog_system/pub/category/tree/${categoryLevels}`, {
+      method: "GET",
+      params: event?.queryStringParameters
+    });
+
+    if (response?.data) {
+      responseService = response?.data ?? [];
+    }
+  } catch (error) {
+    Logger.error("Error service: ", error);
+    statusCode = 500;
+  }
+
+  return ApiResponse.response(statusCode, responseService);
+};
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const list_brands_vtex = async (event) => {
+  const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+  const anRequest = event?.queryStringParameters?.an ?? null;
+  if(anRequest){
+    const validAccount = await ClientData.validateAccount(clientId, anRequest);
+    if (!validAccount) {
+      Logger.error("Data INVALID: ", validAccount);
+      return ApiResponse.response(404, "Account not found");
+    }
+  }
+
+  const listAccounts = anRequest ? null : await ClientData.getClient(clientId);
+  let statusCode = 200;
+  let responseService = [];
+  const an = listAccounts ? listAccounts?.AccountNames?.values[0] : anRequest;
+  if (!an) {
+    Logger.error("Error service: ", "AccountName not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccount = await AccountData.getAccountDataByAccountName(an);
+
+  if (!configAccount) {
+    Logger.error("Error service: ", "Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+  const configAccountParent = configAccount?.AccountName === configAccount?.ParentAccountName ? configAccount : await AccountData.getAccountDataByAccountName(configAccount?.ParentAccountName);
+
+  if (!configAccountParent) {
+    Logger.error("Error service: ", "Parent Account not found");
+    return ApiResponse.response(statusCode, []);
+  }
+
+  try {
+    const apiClient = new VtexApi(configAccountParent?.AccountName, configAccountParent?.Credentials?.key, configAccountParent?.Credentials?.token);
+    const response = await apiClient.fetch(`/catalog_system/pub/brand/list`, {
+      method: "GET",
+      params: event?.queryStringParameters
+    });
+
+    if (response?.data) {
+      responseService = response?.data ?? [];
+    }
+  } catch (error) {
+    Logger.error("Error service: ", error);
+    statusCode = 500;
+  }
+
+  return ApiResponse.response(statusCode, responseService);
+};
+
+/**
+ * Retrieves an order form by its unique identifier
+ * @param {string} orderFormId - Unique identifier of the order form
+ * @param {string} accountName - VTEX account name
+ * @param {string} key - API authentication key
+ * @param {string} token - API authentication token
+ * @returns {Promise<Object|null>} Order form details or null if not found
+ * @throws {Error} Network or API connection errors
+ * @description Fetches complete order form details from VTEX using the provided order form ID
+ * @example
+ * const orderForm = await getOrderFormById('123456', 'myAccount', 'apiKey', 'apiToken');
+ * // Returns order form object or null
+ */
+async function getOrderFormById(orderFormId, accountName, key, token) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token);
+    const responseOrderForm = await vtexApi.fetch(`/checkout/pub/orderForm/${orderFormId}?refreshOutdatedData=true`, { method: "GET" });
+
+    if (responseOrderForm.status !== 200){
+      Logger.error("Error getOrderFormById: ", responseOrderForm);
+      ApiResponse.response(404, { approved: false, message: "orderForm is not found" });
+    }
+
+    const { data } = responseOrderForm;
+
+    return data;
+  } catch (error) {
+    Logger.error("Error getOrderFormById: ", error);
+    return null;
+  }
+};
+
+/**
+ * Retrieves client information by email
+ * @param {string} email - Client's email address
+ * @param {string} accountName - VTEX account name
+ * @param {string} key - API authentication key
+ * @param {string} token - API authentication token
+ * @param {string} acronymClientVtex - Client data entity acronym in VTEX
+ * @returns {Promise<Object|null>} Client details or null if not found
+ * @throws {Error} Network or API connection errors
+ * @description Extracts client ID from email and fetches client details from VTEX master data
+ * @example
+ * const clientDetails = await getClientById('user@example.com', 'myAccount', 'apiKey', 'apiToken', 'CL');
+ * // Returns client object or null
+ */
+async function getClientById(email, accountName, key, token, acronymClientVtex) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token);
+    const clientId = email?.split("+")[1]?.split("@")[0];
+    const responseMasterDataCT = await vtexApi.fetch(
+      `/dataentities/${acronymClientVtex}/search?_fields=_all&id=${clientId}`, { method: "GET" }
+    );
+
+    if (responseMasterDataCT.status >= 200 && responseMasterDataCT.status < 300) {
+      return responseMasterDataCT.data[0];
+    } else {
+      Logger.error("Error getClientById: ", responseMasterDataCT);
+      return null;
+    }
+  } catch (error) {
+    Logger.error(error);
+    return null;
+  }
+}
+
+/**
+ * Deletes custom data from an order form
+ * @param {string} orderFormId - Unique identifier of the order form
+ * @param {string} accountName - VTEX account name
+ * @param {string} key - API authentication key
+ * @param {string} token - API authentication token
+ * @param {Object} configVtex - VTEX configuration object
+ * @param {Object} attachmentCredit - Credit attachment configuration
+ * @param {Object} customData - Custom data to be deleted
+ * @returns {Promise<boolean>} Indicates successful deletion
+ * @throws {Error} Deletion process errors
+ * @description Removes specific custom data and credit attachments from an order form
+ * @example
+ * const deleted = await deleteCustomData('123456', 'myAccount', 'apiKey', 'apiToken', configVtex, attachmentCredit, customData);
+ * // Returns true if deletion is successful
+ */
+async function deleteCustomData(orderFormId, accountName, key, token, configVtex, attachmentCredit, customData) {
+  try {
+    if (!customData) {
+      return true;
+    }
+    const vtexApi = new VtexApi(accountName, key, token);
+    const customApps = customData?.customApps ?? [];
+    const financialPolicy = customApps?.find(app => app.id === configVtex.id);
+    const fields = financialPolicy?.fields;
+
+    if (attachmentCredit && attachmentCredit?.name && attachmentCredit?.value) {
+      await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/attachments/${attachmentCredit?.name}`, { method: "POST" }, { value: null });
+    }
+
+    for (const field in fields) {
+      await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/customData/${configVtex.id}/${field}`, { method: "DELETE" });
+    }
+
+    return true;
+  } catch (error) {
+    Logger.error(error);
+    return ApiResponse.response(401, { approved: false, message: "Error deleting customData orderForm" });
+  }
+}
+
+/**
+ * Updates custom data in an order form
+ * @param {string} orderFormId - Unique identifier of the order form
+ * @param {string} accountName - VTEX account name
+ * @param {string} key - API authentication key
+ * @param {string} token - API authentication token
+ * @param {string} idConfigVtex - VTEX configuration ID
+ * @param {Object} customData - Custom data to be updated
+ * @param {Object} attachmentCredit - Credit attachment configuration
+ * @returns {Promise<Object|Error>} Updated order form data or error response
+ * @throws {Error} Update process errors
+ * @description Updates custom data and credit attachments in an order form
+ * @example
+ * const updatedData = await updateOrderFormCustomData('123456', 'myAccount', 'apiKey', 'apiToken', 'configId', customData, attachmentCredit);
+ * // Returns updated data or error response
+ */
+async function updateOrderFormCustomData(orderFormId, accountName, key, token, idConfigVtex, customData, attachmentCredit) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token);
+    const response = await vtexApi.fetchPub(
+      `/checkout/pub/orderForm/${orderFormId}/customData/${idConfigVtex}`,
+      { method: "PUT" },
+      customData
+    );
+
+    if (attachmentCredit && attachmentCredit?.name && attachmentCredit?.value) {
+      await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/attachments/${attachmentCredit?.name}`, { method: "POST" }, attachmentCredit?.value);
+    }
+
+    if (response.status !== 200){
+      Logger.error("Error updateOrderFormCustomData: ", response);
+      return ApiResponse.response(401, { approved: false, message: "Error updating customData orderForm" });
+    }
+
+    return response.data;
+  } catch (error) {
+    Logger.error(error);
+    return ApiResponse.response(401, { approved: false, message: "Error updating customData orderForm" });
+  }
+}
+
+/**
+ * Cleans custom data in an order form by resetting to default values
+ * @param {string} orderFormId - Unique identifier of the order form
+ * @param {string} accountName - VTEX account name
+ * @param {string} key - API authentication key
+ * @param {string} token - API authentication token
+ * @param {string} idConfigVtex - VTEX configuration ID for custom data
+ * @returns {Promise<Object>} Updated order form data or error response
+ * @throws {Error} API connection or update errors
+ * @description Resets custom data fields to default "clean" state
+ * @example
+ * const cleanedData = await cleanOrderFormCustomData('123456', 'myAccount', 'apiKey', 'apiToken', 'configId');
+ * // Returns cleaned order form data
+ */
+async function cleanOrderFormCustomData(orderFormId, accountName, key, token, idConfigVtex) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token,);
+    const customData = {
+      "approved": "false",
+      "withCredit": "false",
+      "paymentTerm": "-",
+      "maximumCreditAmount": "-",
+      "paymentMethodCode": "-",
+      "creditDays": "-",
+      "paymentMethodName": "-"
+    };
+    const response = await vtexApi.fetchPub(
+      `/checkout/pub/orderForm/${orderFormId}/customData/${idConfigVtex}`,
+      { method: "PUT" },
+      customData
+    );
+
+    if (response.status !== 200){
+      Logger.error("Error cleanOrderFormCustomData: ", response);
+      return ApiResponse.response(401, { approved: false, message: "Error deleting customData orderForm" });
+    }
+
+    return response.data;
+  } catch (error) {
+    Logger.error(error);
+    return ApiResponse.response(401, { approved: false, message: "Error cleaning customData orderForm" });
+  }
+}
+
+/**
+ * Formats and validates financial policy service response
+ * @param {Object} rawResponse - Original service response
+ * @param {boolean} rawResponse.approved - Approval status
+ * @param {boolean} rawResponse.withCredit - Credit eligibility
+ * @param {number|string} rawResponse.creditDays - Credit days
+ * @param {number|string} rawResponse.maximumCreditAmount - Maximum credit amount
+ * @param {string} [rawResponse.paymentMethodCode] - Payment method code
+ * @param {string} [rawResponse.paymentMethodName] - Payment method name
+ * @returns {Object} Formatted response with standardized types
+ * @description Transforms raw financial policy response to a consistent format
+ * @example
+ * const formatted = formatFinancialPolicyResponse({
+ *   approved: true,
+ *   withCredit: true,
+ *   creditDays: 30,
+ *   maximumCreditAmount: 10000
+ * });
+ * // Returns standardized response object
+ */
+function formatFinancialPolicyResponse(rawResponse) {
+  try {
+    const formattedResponse = {
+      approved: Boolean(rawResponse.approved),
+      withCredit: Boolean(rawResponse.withCredit),
+      paymentTerm: Number(rawResponse.creditDays) || 0,
+      maximumCreditAmount: parseFloat(rawResponse.maximumCreditAmount) || 0,
+      paymentMethodCode: rawResponse.withCredit ? String(rawResponse.paymentMethodCode || 'CONTADO') : 'CONTADO',
+      creditDays: Number(rawResponse.creditDays) || 0,
+      paymentMethodName: rawResponse.withCredit ? String(rawResponse.paymentMethodName || 'CONTADO') : 'CONTADO'
+    };
+
+    return formattedResponse;
+  } catch (error) {
+    return getDefaultResponse();
+  }
+}
+
+/**
+ * Collection of base data transformation functions
+ * @type {Object}
+ * @description Utility functions for converting values between types
+ */
+const baseTransforms = {
+  toString: value => String(value || ''),
+  toNumber: value => Number(value || 0),
+  toBoolean: value => Boolean(value),
+  toFloat: value => parseFloat(value || 0),
+  toInt: value => parseInt(value || 0, 10),
+  toOrderValue: value => Number(value || 0) / 100
+};
+
+/**
+ * Applies a specified transformation to a value
+ * @param {*} value - Input value to transform
+ * @param {string} transformType - Type of transformation to apply
+ * @returns {*} Transformed value
+ * @description Applies a predefined transformation if the type exists
+ * @example
+ * applyTransform('123', 'toNumber'); // Returns 123
+ * applyTransform('true', 'toBoolean'); // Returns true
+ */
+function applyTransform(value, transformType) {
+  if (!transformType || !baseTransforms[transformType]) return value;
+  return baseTransforms[transformType](value);
+}
+
+/**
+ * Updates the schema for a VTEX data entity
+ * @param {string} accountName - VTEX account name
+ * @param {string} entityName - Name of the data entity
+ * @param {Object} schemaData - Schema configuration object
+ * @returns {Promise<Object>} Updated schema details
+ */
+async function updateDataEntitySchema(accountName, key, token, entityName, schemaData) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token);
+    const response = await vtexApi.fetch(
+      `/dataentities/${entityName}/schemas/default`, 
+      { 
+        method: "PUT", 
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/vnd.vtex.ds.v2+json'
+        },
+        body: schemaData 
+      }
+    );
+    
+    return response.data;
+  } catch (error) {
+    Logger.error(`Error updating schema for ${entityName}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Creates a document in a VTEX data entity
+ * @param {string} accountName - VTEX account name
+ * @param {string} entityName - Name of the data entity
+ * @param {Object} documentData - Document data to create
+ * @returns {Promise<Object>} Created document details
+ */
+async function createDataEntityDocument(vtexApi, config, fileData) {
+  const documentData = {
+      fileName: fileData.fileName,
+      fileContent: fileData.fileContent,
+      isPublic: true,
+      contentType: 'text/csv'
+  };
+
+  try {
+      const response = await vtexApi.fetch(
+          `/dataentities/${config.fileUploadEntity}/documents`,
+          {
+              method: 'POST',
+              data: documentData,
+              headers: {
+                  'Cache-Control': 'no-cache',
+                  'Accept': 'application/vnd.vtex.ds.v10+json',
+                  'Content-Type': 'application/json'
+              }
+          }
+      );
+
+      if (response.status !== 201) {
+        Logger.error(`Failed to create document: ${response.statusText}`);
+        throw new Error(`Failed to create document: ${response.statusText}`);
+      }
+
+      // Generar URL pública
+      const publicUrl = `https://${config.AccountName}.vtexcommercestable.com.br/api/dataentities/${config.fileUploadEntity}/documents/${response.data.DocumentId}/attachments/${fileData.fileName}`;
+      
+      return {
+          ...response.data,
+          publicUrl
+      };
+  } catch (error) {
+    Logger.error(`Error creating document in ${config.fileUploadEntity}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Updates a specific document in a VTEX data entity
+ * @param {string} accountName - VTEX account name
+ * @param {string} entityName - Name of the data entity
+ * @param {string} documentId - ID of the document to update
+ * @param {Object} updateData - Data to update
+ * @returns {Promise<Object>} Updated document details
+ */
+async function updateDataEntityDocument(accountName, key, token, entityName, documentId, updateData) {
+  try {
+    const vtexApi = new VtexApi(accountName, key, token);
+    const response = await vtexApi.fetch(
+      `/dataentities/${entityName}/documents/${documentId}`, 
+      { 
+        method: "PATCH", 
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/vnd.vtex.ds.v2+json'
+        },
+        body: updateData 
+      }
+    );
+    
+    return response.data;
+  } catch (error) {
+    Logger.error(`Error updating document in ${entityName}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Formatea y valida campos para la entidad de leads
+ * @param {Object} lead - Los datos del lead a formatear
+ * @param {Object} fieldMapping - El mapeo de campos configurado
+ * @returns {Object} Lead formateado y validado
+ */
+const formatLeadFields = (lead, fieldMapping) => {
+  let formattedLead = {};
+  
+  // Procesar cada campo según el mapeo
+  for (const [outputField, inputConfig] of Object.entries(fieldMapping)) {
+      try {
+          if (typeof inputConfig === 'string') {
+              formattedLead[outputField] = baseTransforms.toString(lead[inputConfig] || '');
+          } else if (typeof inputConfig === 'object') {
+              const value = lead[inputConfig.field];
+              const transformer = new Function('value', `return ${inputConfig.transform}`);
+              formattedLead[outputField] = transformer(value);
+          }
+      } catch (error) {
+          Logger.error(`Error formatting field ${outputField}:`, error);
+          formattedLead[outputField] = '';
+      }
+  }
+
+  return formattedLead;
+};
+
+/**
+* Genera una URL de descarga para un documento en MasterData
+* @param {string} accountName - Nombre de la cuenta VTEX
+* @param {string} documentId - ID del documento
+* @param {string} entity - Nombre de la entidad
+* @param {string} [environment='vtexcommercestable'] - Ambiente VTEX
+* @returns {string} URL de descarga del documento
+*/
+const generateMasterDataDownloadUrl = (accountName, documentId, entity, environment = 'vtexcommercestable') => {
+  return `https://${accountName}.${environment}.com.br/api/dataentities/${entity}/documents/${documentId}/file`;
+};
+
+/**
+* Función para transformar datos entre diferentes formatos
+* @param {*} value - Valor a transformar
+* @param {string} transformType - Tipo de transformación a aplicar
+* @returns {*} Valor transformado
+*/
+const transformLeadData = (value, transformType) => {
+  if (!transformType || !baseTransforms[transformType]) {
+      return value;
+  }
+  return baseTransforms[transformType](value);
+};
+
+/**
+* Valida el formato y la estructura de un lead
+* @param {Object} lead - Lead a validar
+* @param {Object} requiredFields - Campos requeridos y sus validaciones
+* @returns {Object} Resultado de la validación
+*/
+const validateLead = (lead, requiredFields) => {
+  const errors = [];
+  
+  for (const [field, validation] of Object.entries(requiredFields)) {
+      const value = lead[field];
+      
+      if (validation.required && !value) {
+          errors.push(`Campo ${field} es requerido`);
+          continue;
+      }
+
+      if (validation.regex && value) {
+          const regex = new RegExp(validation.regex);
+          if (!regex.test(value)) {
+              errors.push(`Campo ${field} tiene formato inválido`);
+          }
+      }
+
+      if (validation.maxLength && value && value.length > validation.maxLength) {
+          errors.push(`Campo ${field} excede el máximo de ${validation.maxLength} caracteres`);
+      }
+  }
+
+  return {
+      isValid: errors.length === 0,
+      errors
+  };
+};
+
+/**
+* Función para generar el nombre del archivo CSV de leads
+* @param {string} accountName - Nombre de la cuenta
+* @param {string} dateRange - Rango de fechas del reporte
+* @returns {string} Nombre del archivo formateado
+*/
+const generateLeadReportFileName = (accountName, dateRange) => {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return `new-leads-${accountName}-${dateRange}-${timestamp}.csv`;
+};
+
+/**
+* Función para validar la configuración de leads de una cuenta
+* @param {Object} config - Configuración a validar
+* @returns {Object} Resultado de la validación
+*/
+const validateLeadsConfig = (config) => {
+  const requiredFields = [
+      'newLeadsEntity',
+      'fileUploadEntity',
+      'leadMap'
+  ];
+
+  const errors = [];
+
+  for (const field of requiredFields) {
+      if (!config[field]) {
+          errors.push(`Missing required field: ${field}`);
+      }
+  }
+
+  if (config.leadMap && typeof config.leadMap !== 'object') {
+      errors.push('leadMap must be an object');
+  }
+
+  return {
+      isValid: errors.length === 0,
+      errors
+  };
+};
+
+module.exports = {
+  list_products_vtex,
+  list_categories_vtex,
+  list_brands_vtex,
+  getOrderFormById,
+  getClientById,
+  deleteCustomData,
+  updateOrderFormCustomData,
+  cleanOrderFormCustomData,
+  formatFinancialPolicyResponse,
+  baseTransforms,
+  applyTransform,
+  updateDataEntitySchema,
+  createDataEntityDocument,
+  updateDataEntityDocument,
+  formatLeadFields,
+  generateMasterDataDownloadUrl,
+  transformLeadData,
+  validateLead,
+  generateLeadReportFileName,
+  validateLeadsConfig
+};