@gp_jcisneros/errors/src/LambdaResponseHandler.js

Error handling utilities for GreenPay microservices and validation middleware

/**
 * Response handler class for standardized API Gateway responses in AWS Lambda
 */
class LambdaResponseHandler {
  constructor(options = {}) {
    this.defaultSuccessMessage =
      options.defaultSuccessMessage || 'Operation completed successfully';
    this.defaultErrorMessage =
      options.defaultErrorMessage || 'Internal server error';
    this.defaultSuccessCode = options.defaultSuccessCode || 200;
    this.defaultErrorCode = options.defaultErrorCode || 500;
    this.includeStack = options.includeStack || false;
  }

  /**
   * Create a success response
   */
  success(data = {}, message = null, code = null, additionalData = {}) {
    const response = {
      code: code || this.defaultSuccessCode,
      status: 'success',
      message: message || this.defaultSuccessMessage,
      data: { ...data },
      additionalData: additionalData,
    };

    return {
      statusCode: response.code,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(response),
    };
  }

  /**
   * Create an error response
   */
  error(error, data = {}, message = null, code = null, additionalData = {}) {
    const errorCode = error?.errorCode || 'GP-500';
    const errorMessage = message || error?.message || this.defaultErrorMessage;
    const statusCode = code || error?.statusCode || this.defaultErrorCode;

    const response = {
      code: statusCode,
      status: 'failed',
      message: errorMessage,
      error: {
        code: errorCode,
        message: error?.description || errorMessage,
      },
      data: { ...data },
      additionalData: {
        ...additionalData,
        ...(this.includeStack && error?.stack && { stack: error.stack }),
      },
    };

    return {
      statusCode: response.code,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(response),
    };
  }

  /**
   * Create a response handler function
   */
  static createHandler(options = {}) {
    const handler = new LambdaResponseHandler(options);
    return (
      data = {},
      error = null,
      successMessage = null,
      errorMessage = null,
      code = null,
      additionalData = {}
    ) => {
      if (error) {
        return handler.error(error, data, errorMessage, code, additionalData);
      } else {
        return handler.success(data, successMessage, code, additionalData);
      }
    };
  }

  static createCustomHandler(successMessage, errorMessage, options = {}) {
    return LambdaResponseHandler.createHandler({
      defaultSuccessMessage: successMessage,
      defaultErrorMessage: errorMessage,
      ...options,
    });
  }

  static createTransactionHandler(options = {}) {
    return LambdaResponseHandler.createCustomHandler(
      'La transacción fue procesada correctamente',
      'La transacción fue rechazada por el banco',
      options
    );
  }

  static createCRUDHandler(options = {}) {
    return LambdaResponseHandler.createCustomHandler(
      'Operación completada exitosamente',
      'Error en la operación',
      options
    );
  }
}

module.exports = { LambdaResponseHandler };