@webex/http-core/dist/http-error.js

Core HTTP library for the Cisco Webex

"use strict";

var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
_Object$defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _defineProperties = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/define-properties"));
var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
var _lodash = require("lodash");
var _common = require("@webex/common");
var _httpErrorSubtypes = _interopRequireDefault(require("./http-error-subtypes"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /*!
 * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
 */
/**
 * Base HttpError class. Unlikely to be thrown directly, but handy for general
 * type comparison.
 */
var HttpError = exports.default = /*#__PURE__*/function (_Exception) {
  (0, _inherits2.default)(HttpError, _Exception);
  var _super = _createSuper(HttpError);
  function HttpError() {
    (0, _classCallCheck2.default)(this, HttpError);
    return _super.apply(this, arguments);
  }
  (0, _createClass2.default)(HttpError, [{
    key: "parse",
    value:
    /**
     * Parses HttpResponse objects for useful information (status, headers, etc)
     * as well as attempting to extract a useful error message.
     * @param {HttpResponse} res
     * @returns {string}
     */
    function parse(res) {
      // complexity is high here because of all the default values below.
      /* eslint complexity: [0] */
      var body = res.body;
      var message;
      switch ((0, _typeof2.default)(body)) {
        case 'string':
          try {
            body = JSON.parse(body);
            message = this.parseObject(body);
          } catch (err) {
            message = body;
          }
          break;
        case 'object':
          message = this.parseObject(body);
          break;
        default:
      }
      if (!message) {
        message = this.defaultMessage;
      }
      (0, _defineProperties.default)(this, {
        body: {
          enumerable: false,
          value: body
        },
        httpVersion: {
          enumerable: false,
          value: res.httpVersion
        },
        headers: {
          enumerable: false,
          value: res.headers || {}
        },
        rawHeaders: {
          enumerable: false,
          value: res.rawHeaders || []
        },
        trailers: {
          enumerable: false,
          value: res.trailers || {}
        },
        rawTrailers: {
          enumerable: false,
          value: res.rawTrailers || []
        },
        method: {
          enumerable: false,
          value: res.method
        },
        url: {
          enumerable: false,
          value: res.url
        },
        statusCode: {
          enumerable: false,
          value: res.statusCode
        },
        statusMessage: {
          enumerable: false,
          value: res.statusMessage
        },
        socket: {
          enumerable: false,
          value: res.socket
        },
        _res: {
          enumerable: false,
          value: res
        }
      });
      return message;
    }

    /**
     * Recursively parses an error body looking for a likely error candidate
     * @param {object} body
     * @returns {string}
     */
  }, {
    key: "parseObject",
    value: function parseObject(body) {
      // Search body for common names of error strings
      var messages = (0, _values.default)((0, _lodash.pick)(body, HttpError.errorKeys));

      // If no error candidate was found, stringify the entire body
      if (messages.length === 0) {
        return (0, _stringify.default)(body, null, 2);
      }

      // Assume the first key found was the error explanation
      var message = messages[0];

      // If the explanation is an object, recurse and try again
      if ((0, _typeof2.default)(message) === 'object') {
        return this.parseObject(message);
      }

      // Return the first key
      return message;
    }
  }]);
  return HttpError;
}(_common.Exception);
/**
 * @example Extend via
 * MyError extends HttpError {
 *  static errorKeys = HttpError.errorKeys.concat([
 *    `key1`,
 *    `key2`
 *  ])
 * }
 *
 * @type {Array}
 */
(0, _defineProperty2.default)(HttpError, "errorKeys", ['error', 'errorString', 'response', 'errorResponse', 'message', 'msg']);
/**
 * Default error string if no error can be extracted from the http response
 * @type {string}
 */
(0, _defineProperty2.default)(HttpError, "defaultMessage", 'An error was received while trying to fulfill the request');
(0, _httpErrorSubtypes.default)(HttpError);
HttpError.makeSubTypes = _httpErrorSubtypes.default;
//# sourceMappingURL=http-error.js.map