@gp_jcisneros/errors/src/ResponseHandler.js

Error handling utilities for GreenPay microservices and validation middleware

/**
 * Response handler class for standardized API responses
 */
class ResponseHandler {
  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
   * @param {Object} res - Express response object
   * @param {Object} data - Response data
   * @param {string} message - Success message
   * @param {number} code - HTTP status code
   * @param {Object} additionalData - Additional data to include
   * @returns {Object} - Express response
   */
  success(res, data = {}, message = null, code = null, additionalData = {}) {
    const response = {
      code: code || this.defaultSuccessCode,
      status: 'success',
      message: message || this.defaultSuccessMessage,
      data: {...data},
      additionalData: additionalData
    };

    return res.status(response.code).json(response);
  }

  /**
   * Create an error response
   * @param {Object} res - Express response object
   * @param {Error|CustomError} error - Error object
   * @param {Object} data - Additional data
   * @param {string} message - Override error message
   * @param {number} code - Override HTTP status code
   * @param {Object} additionalData - Additional data to include
   * @returns {Object} - Express response
   */
  error(res, error, data = {}, message = null, code = null, additionalData = {}) {
    // Determine error details
    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 res.status(response.code).json(response);
  }

  /**
   * Create a response handler function
   * @param {Object} options - Handler options
   * @returns {Function} - Response handler function
   */
  static createHandler(options = {}) {
    const handler = new ResponseHandler(options);    
    return (res, data ={}, error = null, successMessage = null, errorMessage = null, code = null, additionalData = {}) => {
      if (error) {
        return handler.error(res, error, data, errorMessage, code, additionalData);
      } else {
        return handler.success(res, data, successMessage, code, additionalData);
      }
    };
  }

  /**
   * Create a response handler with custom success and error messages
   * @param {string} successMessage - Default success message
   * @param {string} errorMessage - Default error message
   * @param {Object} options - Additional options
   * @returns {Function} - Response handler function
   */
  static createCustomHandler(successMessage, errorMessage, options = {}) {
    return ResponseHandler.createHandler({
      defaultSuccessMessage: successMessage,
      defaultErrorMessage: errorMessage,
      ...options
    });
  }

  /**
   * Create a standardized response handler for transactions
   * @param {Object} options - Handler options
   * @returns {Function} - Transaction response handler
   */
  static createTransactionHandler(options = {}) {
    return ResponseHandler.createCustomHandler(
      'La transacción fue procesada correctamente',
      'La transacción fue rechazada por el banco',
      options
    );
  }

  /**
   * Create a standardized response handler for CRUD operations
   * @param {Object} options - Handler options
   * @returns {Function} - CRUD response handler
   */
  static createCRUDHandler(options = {}) {
    return ResponseHandler.createCustomHandler(
      'Operación completada exitosamente',
      'Error en la operación',
      options
    );
  }
}

module.exports = { ResponseHandler };