@rapharacing/lambda-utils/dist/index.js

Lambda Utils

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.formatAuthorizationToken = exports.requestConfig = exports.cognitoErrorResponse = exports.errorResponse = void 0;

var _constants = require("./constants");

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

/**
 * Formatted Error
 *
 * @private
 * @param {number} [error.code=500] error.code Error code
 * @param {string} error.key Error key
 * @param {string} error.message Error message
 */
const formattedError = ({
  code,
  key,
  message
} = {
  code: 500
}) => ({
  code,
  key,
  message
});
/**
 * Formatted Errors
 *
 * @private
 * @param {number} [error.code=500] error.code Error code
 * @param {(Object|string)} error.err Error object / error string
 * @param {string} [error.message] Error message
 */


const formattedErrors = ({
  code,
  err,
  message
} = {
  code: 500
}) => {
  if (Array.isArray(err)) return {
    errors: err.map(e => formattedError({
      code,
      key: e.type,
      message: e.message
    }))
  };
  return {
    errors: [formattedError({
      code,
      key: err,
      message
    })]
  };
};
/**
 * Formatted cognito error
 *
 * @private
 * @param {string)} error error string
 */


const formattedCognitoError = error => {
  return `: ${error}`;
};
/**
 * Returns a Error Object
 * @param {Object} error Error response from AWS or CC
 * @param {string} customKey Custom error key to overwrite stack errors
 * @param {string} customMessage Custom error message to overwrite stack errors
 * @returns {Object} Error
 */


const errorResponse = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator(function* (error, customKey, customMessage) {
    if (!error) return formattedErrors({
      code: 500,
      err: _constants.INTERNAL_FAILURE,
      message: "Missing error param"
    });
    const stack = error.stack,
          _error$response = error.response,
          ccResponse = _error$response === void 0 ? {} : _error$response,
          awsErrorCode = error.code,
          awsStatusCode = error.statusCode,
          awsMessage = error.message;
    const _ccResponse$data = ccResponse.data,
          ccData = _ccResponse$data === void 0 ? {} : _ccResponse$data,
          status = ccResponse.status;
    const responseError = ccData.error,
          responseErrors = ccData.errors,
          errorDescription = ccData.error_message; // Invalid Request

    if (stack && stack.includes(_constants.INVALID_VALUE_ERROR)) {
      if (customKey && customMessage) {
        return formattedErrors({
          code: 400,
          err: customKey,
          description: customMessage
        });
      }

      return formattedErrors({
        code: 500,
        err: _constants.INTERNAL_FAILURE,
        description: "Internal Failure"
      });
    } // AWS


    if (awsErrorCode) {
      return formattedErrors({
        code: awsStatusCode,
        err: awsErrorCode,
        message: awsMessage
      });
    } // CC Errors


    if (ccResponse && ccData) {
      // Array of Errors
      if (responseErrors) return formattedErrors({
        code: status,
        err: responseErrors
      }); // Single error

      return formattedErrors({
        code: status,
        err: responseError,
        message: errorDescription
      });
    } // Fallback


    return formattedErrors({
      code: 500,
      err: _constants.INTERNAL_FAILURE,
      message: "Internal Failure"
    });
  });

  return function errorResponse(_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
}();
/**
 * Returns a Error key
 * @param {Object} error Error response from AWS or CC
 * @param {string} customMessage Custom error message to overwrite stack errors
 * @returns {string} Error key
 */


exports.errorResponse = errorResponse;

const cognitoErrorResponse = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator(function* (error, customMessage) {
    if (!error && !customMessage) return formattedCognitoError(_constants.INTERNAL_FAILURE);

    if (!error) {
      return formattedCognitoError(customMessage);
    }

    const stack = error.stack,
          _error$response2 = error.response,
          ccResponse = _error$response2 === void 0 ? {} : _error$response2,
          awsErrorCode = error.code;
    const _ccResponse$data2 = ccResponse.data,
          ccData = _ccResponse$data2 === void 0 ? {} : _ccResponse$data2;
    const responseError = ccData.error,
          responseErrors = ccData.errors; // Invalid Request

    if (stack && stack.includes(_constants.INVALID_VALUE_ERROR)) {
      return formattedCognitoError(_constants.INCOMPLETE_SIGNATURE);
    } // AWS


    if (awsErrorCode) {
      return formattedCognitoError(awsErrorCode);
    } // CC Errors


    if (ccResponse && ccData) {
      // Array of Errors
      if (responseErrors) return formattedCognitoError(responseErrors[0].type); // Single error

      return formattedCognitoError(responseError);
    } // Fallback


    return formattedCognitoError(_constants.INTERNAL_FAILURE);
  });

  return function cognitoErrorResponse(_x4, _x5) {
    return _ref2.apply(this, arguments);
  };
}();
/**
 * Returns a configuration object for axios
 *
 * @param {string} config.url URL
 * @param {string} config.method HTTP method
 * @param {string} config.token Authorization token
 * @param {Object} data Data to be sent as the request body
 * @returns {Object} Configuration object
 */


exports.cognitoErrorResponse = cognitoErrorResponse;

const requestConfig = /*#__PURE__*/function () {
  var _ref3 = _asyncToGenerator(function* ({
    url,
    method,
    token,
    data
  }) {
    return {
      url,
      method,
      data,
      headers: {
        Authorization: token
      }
    };
  });

  return function requestConfig(_x6) {
    return _ref3.apply(this, arguments);
  };
}();
/**
 * Format Authorization Token
 *
 * @param {string} token Token
 * @returns {string} Token
 */


exports.requestConfig = requestConfig;

const formatAuthorizationToken = token => token.startsWith("Bearer ") ? token.slice(7, token.length) : token;

exports.formatAuthorizationToken = formatAuthorizationToken;