@app-masters/js-lib/dist/httpErrorHandler.js

JS lib

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _rollbar = _interopRequireDefault(require("./rollbar"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
var HttpErrorHandler = /*#__PURE__*/function () {
  function HttpErrorHandler() {
    _classCallCheck(this, HttpErrorHandler);
  }
  _createClass(HttpErrorHandler, null, [{
    key: "setup",
    value: function setup(callback) {
      // console.log("HttpErrorHandler - setup");
      // More callbacks can be added if necessary in the future
      if (!callback || !callback.onConnectionFail || !callback.onAPIFail) {
        console.warn('You must pass callback parameter to AppBootstrap.setup, with onConnectionFail and onAPIFail methods.');
      } else {
        HttpErrorHandler.callback['onAPIFail'] = callback.onAPIFail;
        HttpErrorHandler.callback['onConnectionFail'] = callback.onConnectionFail;
        HttpErrorHandler.callback['errorCatcher'] = callback.errorCatcher; // Optional
      }
    }
  }, {
    key: "handle",
    value: function handle(error, method, url, body) {
      var errorObj = {
        payload: error
      }; // Keep the original error on payload

      // TypeError can have different meanings, so check the message
      if (error.name !== 'TypeError') {
        errorObj.name = error.name;
        errorObj.message = error.message;
      } else {
        errorObj.name = error.message;
        errorObj.message = error.message;
      }
      errorObj.stack = new Error().stack;
      errorObj.level = 'error'; // Default level

      errorObj.method = method;
      errorObj.url = url;
      errorObj.body = body;
      var handler = errorLibrary[errorObj.name];
      if (handler) {
        if (handler.message) {
          errorObj.message = handler.message;
        }
        if (handler.callback && HttpErrorHandler.callback[handler.callback]) {
          HttpErrorHandler.callback[handler.callback](errorObj);
          errorObj.sentToAnotherErrorHandler = true;
        }
        if (handler.level === null) {
          return errorObj;
        } else {
          errorObj.level = handler.level;
        }
      }

      // Send to rollbar or defined errorCatcher
      if (this.callback.errorCatcher) {
        this.callback.errorCatcher(errorObj);
      } else {
        _rollbar.default[errorObj.level](errorObj);
      }
      errorObj.sentToAnotherErrorHandler = true;
      return errorObj;
    }
  }, {
    key: "mount",
    value: function mount(response) {
      var error = {};
      error.headers = response.headers;
      error.name = response.status;
      return response.text().then(function (message) {
        error.message = message || 'Error with no message';
        throw error;
      });
    }
  }]);
  return HttpErrorHandler;
}(); // Http errors that need a special handle.
var errorLibrary = {
  '400': {
    level: null //Don't send to rollbar
  },

  '404': {
    level: 'error',
    // Send to rollbar as error
    message: 'Não encontrado.',
    // Change de message to the view
    callback: 'onAPIFail' // Call onAPIFail callback
  },

  '500': {
    level: 'warning',
    message: 'Falha do servidor. Tente novamente.',
    callback: 'onConnectionFail'
  },
  '503': {
    level: 'warning',
    message: 'Falha do servidor. Tente novamente.',
    callback: 'onConnectionFail'
  },
  'ValidatorError': {
    level: 'critical',
    message: 'Um campo foi preenchido com valor não permitido.',
    callback: 'onAPIFail'
  },
  'MongoError': {
    level: 'warning',
    message: 'Falha de comunicação com o servidor.',
    callback: 'onConnectionFail'
  },
  'Failed to fetch': {
    level: 'warning',
    message: 'Falha de comunicação com o servidor.',
    callback: 'onConnectionFail'
  },
  'FetchError': {
    level: 'warning',
    message: 'Falha de comunicação com o servidor.',
    callback: 'onConnectionFail'
  }
};
HttpErrorHandler.callback = {};
var _default = HttpErrorHandler;
exports.default = _default;