@rnskv/terror/package/index.js

Simple and understandable custom error handling.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

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, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    keys.push.apply(keys, Object.getOwnPropertySymbols(object));
  }

  if (enumerableOnly) keys = keys.filter(function (sym) {
    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
  });
  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(source, true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _construct(Parent, args, Class) {
  if (isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) _setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}

function _wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;

  _wrapNativeSuper = function _wrapNativeSuper(Class) {
    if (Class === null || !_isNativeFunction(Class)) return Class;

    if (typeof Class !== "function") {
      throw new TypeError("Super expression must either be null or a function");
    }

    if (typeof _cache !== "undefined") {
      if (_cache.has(Class)) return _cache.get(Class);

      _cache.set(Class, Wrapper);
    }

    function Wrapper() {
      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
    }

    Wrapper.prototype = Object.create(Class.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    return _setPrototypeOf(Wrapper, Class);
  };

  return _wrapNativeSuper(Class);
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, i;

  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }

  return target;
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

var DEFAULT_PARAMS = {
  name: 'UNEXPECTED_ERROR',
  message: 'Oooops. Something went wrong :/',
  code: 500
};

var TError =
/*#__PURE__*/
function (_Error) {
  _inherits(TError, _Error);

  function TError(params) {
    var _this;

    _classCallCheck(this, TError);

    if (!params) {
      throw new Error('Params is required in TError constructor');
    }

    if (!params.groupParams) {
      throw new Error('Params.groupParams is required in TError constructor');
    }

    var _params$message = params.message,
        message = _params$message === void 0 ? DEFAULT_PARAMS.message : _params$message,
        _params$code = params.code,
        code = _params$code === void 0 ? DEFAULT_PARAMS.code : _params$code,
        _params$name = params.name,
        name = _params$name === void 0 ? DEFAULT_PARAMS.name : _params$name;
    _this = _possibleConstructorReturn(this, _getPrototypeOf(TError).call(this, message));

    var _params$groupParams = params.groupParams,
        handler = _params$groupParams.handler,
        logger = _params$groupParams.logger,
        groupParams = _objectWithoutProperties(_params$groupParams, ["handler", "logger"]);

    _this.groupParams = groupParams;
    _this.message = message;
    _this.code = code;
    _this.name = name;

    _this.callLogger(logger);

    _this.callHandler(handler);

    Error.captureStackTrace(_assertThisInitialized(_this), _this.constructor);
    return _this;
  }

  _createClass(TError, [{
    key: "callLogger",
    value: function callLogger(logger) {
      if (logger) {
        logger(this);
      }
    }
  }, {
    key: "callHandler",
    value: function callHandler(handler) {
      if (handler) {
        handler(this);
      }
    }
  }, {
    key: "data",
    get: function get() {
      return {
        name: this.name,
        message: this.message,
        code: this.code,
        groupType: this.groupParams.type,
        stack: this.stack
      };
    }
  }]);

  return TError;
}(_wrapNativeSuper(Error));

var TErrorCurrying = function TErrorCurrying(groupParams, params) {
  return new TError(_objectSpread2({
    groupParams: groupParams
  }, params)).data;
};

var DefaultErrorsList = {
  'UNKNOWN_ERROR': {
    message: 'Unknown Error',
    name: 'UNKNOWN_ERROR',
    code: 500
  }
};

var DEFAULT_PARAMS$1 = {
  groupType: 'GLOBAL_ERROR',
  errorType: 'UNKNOWN_ERROR'
};

var TErrorGroup =
/*#__PURE__*/
function () {
  function TErrorGroup() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var errorsList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    _classCallCheck(this, TErrorGroup);

    this.type = params.type || DEFAULT_PARAMS$1.groupType;
    this.errorsList = _objectSpread2({}, errorsList, {}, DefaultErrorsList) || DefaultErrorsList;
    this.logger = null;
    this.handler = null;
  }

  _createClass(TErrorGroup, [{
    key: "setLogger",
    value: function setLogger(fn) {
      this.logger = fn;
      return this;
    }
  }, {
    key: "setHandler",
    value: function setHandler(fn) {
      this.handler = fn;
      return this;
    }
  }, {
    key: "create",
    value: function create() {
      var errorType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_PARAMS$1.errorType;
      var logger = this.logger,
          handler = this.handler,
          type = this.type,
          errorsList = this.errorsList;
      var groupParams = {
        type: type,
        logger: logger,
        handler: handler
      };
      var errorParams = errorsList[errorType];

      if (!errorParams) {
        throw new Error("Error ".concat(errorType, " is missing in errors list."));
      }

      return TErrorCurrying(groupParams, errorsList[errorType]);
    }
  }]);

  return TErrorGroup;
}();

exports.TError = TError;
exports.TErrorGroup = TErrorGroup;
exports.default = TErrorGroup;