@gp_jcisneros/errors/src/LambdaZodErrorHandler.js

Error handling utilities for GreenPay microservices and validation middleware

const { ZodError: ZodValidationError } = require('zod');
const { ZodError } = require('./ZodError');

/**
 * Convierte errores de Zod a ZodError estandarizado
 */
const convertZodErrorToValidationErrorLambda = (
  zodError,
  integration = 'default-integration',
  customValidation = null
) => {
  const error = ZodError.fromZodError(zodError, integration);
  if (customValidation) {
    error.additionalData = {
      ...error.additionalData,
      customValidation,
    };
  }
  return error;
};

/**
 * Crea un ZodError para campos requeridos
 */
const createRequiredFieldErrorLambda = (
  field,
  integration = 'default-integration',
  customValidation = null
) => {
  const error = ZodError.required(field, integration);
  if (customValidation) {
    error.additionalData = { validation: customValidation };
  }
  return error;
};

/**
 * Crea un ZodError para proveedores no soportados
 */
const createUnsupportedProviderErrorLambda = (
  provider,
  transactionType,
  integration = 'default-integration',
  customValidation = null
) => {
  const error = ZodError.unsupportedProvider(
    provider,
    transactionType,
    integration
  );
  if (customValidation) {
    error.additionalData = { validation: customValidation };
  }
  return error;
};

/**
 * Crea un ZodError genérico para errores inesperados
 */
const createGenericValidationErrorLambda = (
  error,
  integration = 'default-integration'
) => {
  return ZodError.generic(error, integration);
};

/**
 * Valida usando schema dinámico en AWS Lambda
 */
const validateDynamicSchemaLambda = async (
  event,
  createDynamicSchema,
  transactionType,
  customExtensions = {},
  integration = 'default-integration',
  getCustomValidation = null
) => {
  try {
    const body =
      typeof event.body === 'string' ? JSON.parse(event.body) : event.body;
    const query = event.queryStringParameters || {};
    const params = event.pathParameters || {};

    const provider =
      body?.requestData?.paymentMethod?.bankProvider ||
      body?.paymentMethod?.bankProvider ||
      query?.bankProvider;

    if (!provider) {
      const customValidation = getCustomValidation
        ? await getCustomValidation('ZOD-002')
        : null;
      const error = createRequiredFieldErrorLambda(
        'bankProvider',
        integration,
        customValidation
      );

      return {
        statusCode: error.statusCode,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          code: error.statusCode,
          status: 'failed',
          message: error.message,
          error: { code: error.errorCode, message: error.description },
          additionalData: error.additionalData,
        }),
      };
    }

    const schema = createDynamicSchema(
      provider,
      transactionType,
      customExtensions
    );

    if (!schema) {
      const customValidation = getCustomValidation
        ? await getCustomValidation('ZOD-003')
        : null;
      const error = createUnsupportedProviderErrorLambda(
        provider,
        transactionType,
        integration,
        customValidation
      );

      return {
        statusCode: error.statusCode,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          code: error.statusCode,
          status: 'failed',
          message: error.message,
          error: { code: error.errorCode, message: error.description },
          additionalData: error.additionalData,
        }),
      };
    }

    await schema.parseAsync({ body, params, query });
    return null; // null indica que no hay errores
  } catch (error) {
    if (error instanceof ZodValidationError) {
      const customValidation = getCustomValidation
        ? await getCustomValidation('ZOD-001')
        : null;
      const validationError = convertZodErrorToValidationErrorLambda(
        error,
        integration,
        customValidation
      );

      return {
        statusCode: validationError.statusCode,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          code: validationError.statusCode,
          status: 'failed',
          message: validationError.message,
          error: {
            code: validationError.errorCode,
            message: validationError.description,
          },
          additionalData: validationError.additionalData,
        }),
      };
    }

    const genericError = createGenericValidationErrorLambda(error, integration);
    return {
      statusCode: genericError.statusCode,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        code: genericError.statusCode,
        status: 'failed',
        message: genericError.message,
        error: {
          code: genericError.errorCode,
          message: genericError.description,
        },
        additionalData: genericError.additionalData,
      }),
    };
  }
};

/**
 * Valida usando schema base en AWS Lambda
 */
const validateBaseSchemaLambda = async (
  event,
  baseSchema,
  customExtensions = {},
  integration = 'default-integration',
  getCustomValidation = null
) => {
  try {
    const body =
      typeof event.body === 'string' ? JSON.parse(event.body) : event.body;
    const query = event.queryStringParameters || {};
    const params = event.pathParameters || {};

    const schema = baseSchema.extend(customExtensions);
    await schema.parseAsync({ body, params, query });
    return null; // null indica que pasó la validación
  } catch (error) {
    if (error instanceof ZodValidationError) {
      const customValidation = getCustomValidation
        ? await getCustomValidation('ZOD-001')
        : null;
      const validationError = convertZodErrorToValidationErrorLambda(
        error,
        integration,
        customValidation
      );

      return {
        statusCode: validationError.statusCode,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          code: validationError.statusCode,
          status: 'failed',
          message: validationError.message,
          error: {
            code: validationError.errorCode,
            message: validationError.description,
          },
          additionalData: validationError.additionalData,
        }),
      };
    }

    const genericError = createGenericValidationErrorLambda(error, integration);
    return {
      statusCode: genericError.statusCode,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        code: genericError.statusCode,
        status: 'failed',
        message: genericError.message,
        error: {
          code: genericError.errorCode,
          message: genericError.description,
        },
        additionalData: genericError.additionalData,
      }),
    };
  }
};

module.exports = {
  convertZodErrorToValidationErrorLambda,
  createRequiredFieldErrorLambda,
  createUnsupportedProviderErrorLambda,
  createGenericValidationErrorLambda,
  validateDynamicSchemaLambda,
  validateBaseSchemaLambda,
};