@gp_jcisneros/errors/examples/zod_error_example.js

Error handling utilities for GreenPay microservices and validation middleware

const { z } = require('zod');
const { ZodError } = require('../src/ZodError');

// Ejemplo de schema de validación
const userSchema = z.object({
  name: z.string().min(2, 'El nombre debe tener al menos 2 caracteres'),
  email: z.string().email('Email inválido'),
  age: z.number().min(18, 'Debe ser mayor de edad'),
});

// Ejemplo 1: Manejo de error de validación de Zod
function validateUser(userData) {
  try {
    return userSchema.parse(userData);
  } catch (error) {
    if (error.name === 'ZodError') {
      // Convertir error de Zod a ZodError estandarizado
      const zodError = ZodError.fromZodError(error, 'user-service');
      throw zodError;
    }
    throw error;
  }
}

// Ejemplo 2: Crear errores específicos
function createCustomZodErrors() {
  // Error de campo requerido
  const requiredError = ZodError.required('email', 'auth-service');
  
  // Error de proveedor no soportado
  const providerError = ZodError.unsupportedProvider(
    'paypal', 
    'credit-card', 
    'payment-service'
  );
  
  // Error genérico
  const genericError = ZodError.generic(
    new Error('Error interno de validación'), 
    'validation-service'
  );
  
  return { requiredError, providerError, genericError };
}

// Ejemplo 3: Middleware de validación
// eslint-disable-next-line no-unused-vars
function createValidationMiddleware(schema, integration = 'default') {
  return (req, res, next) => {
    try {
      schema.parse(req.body);
      next();
    } catch (error) {
      if (error.name === 'ZodError') {
        const zodError = ZodError.fromZodError(error, integration);
        
        return res.status(zodError.statusCode).json({
          code: zodError.statusCode,
          status: 'failed',
          message: zodError.message,
          error: {
            code: zodError.errorCode,
            message: zodError.description,
          },
          additionalData: zodError.additionalData,
        });
      }
      
      const genericError = ZodError.generic(error, integration);
      return res.status(genericError.statusCode).json({
        code: genericError.statusCode,
        status: 'failed',
        message: genericError.message,
        error: {
          code: genericError.errorCode,
          message: genericError.description,
        },
      });
    }
  };
}

// Ejemplo de uso
console.log('=== Ejemplo de uso de ZodError ===\n');

// Ejemplo 1: Validación con error
console.log('1. Validación con error:');
try {
  validateUser({
    name: 'A', // Muy corto
    email: 'invalid-email', // Email inválido
    age: 16, // Menor de edad
  });
} catch (error) {
  if (error instanceof ZodError) {
    console.log('Error de validación:', {
      message: error.message,
      errorCode: error.errorCode,
      description: error.description,
      integration: error.integration,
      statusCode: error.statusCode,
      field: error.field,
      value: error.value,
      validationErrors: error.getValidationErrors(),
    });
  }
}

console.log('\n2. Errores personalizados:');
const { requiredError, providerError, genericError } = createCustomZodErrors();

console.log('Error de campo requerido:', {
  message: requiredError.message,
  errorCode: requiredError.errorCode,
  description: requiredError.description,
});

console.log('Error de proveedor no soportado:', {
  message: providerError.message,
  errorCode: providerError.errorCode,
  description: providerError.description,
});

console.log('Error genérico:', {
  message: genericError.message,
  errorCode: genericError.errorCode,
  description: genericError.description,
});

console.log('\n3. Detalles del error:');
const errorDetails = requiredError.getZodDetails();
console.log('Detalles completos:', errorDetails);

console.log('\n4. Verificar si tiene detalles de Zod:');
console.log('Tiene detalles de Zod:', requiredError.hasZodDetails());