express-locator/es/Locator.js

a service locator

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _objectWithoutProperties(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]; } 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 _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; }

import ControlledError from './ControlledError';
import Instance from './Instance';

/**
 * @description A class to manage dependencies and configuration on a node application
 * @export
 * @class Locator
 */
var Locator =
/*#__PURE__*/
function () {
  function Locator() {
    _classCallCheck(this, Locator);

    this.registry = {
      Error: {},
      Instance: {}
    };
    this.cache = {
      Error: ControlledError,
      Instance: Instance
    };
  }

  _createClass(Locator, [{
    key: "config",
    value: function config(configs) {
      this.configs = configs;

      for (var _len = arguments.length, dependencies = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        dependencies[_key - 1] = arguments[_key];
      }

      this.register.apply(this, dependencies);
    }
  }, {
    key: "register",
    value: function register() {
      var _this = this;

      var invokers = [];

      var addDependency = function addDependency(dependency) {
        if (Array.isArray(dependency)) dependency.forEach(addDependency);else if (typeof dependency === 'string') _this.registry[dependency] = {
          construct: dependency
        };else {
          var name = dependency.name,
              dependencies = dependency.dependencies,
              config = dependency.config,
              construct = dependency.construct,
              invoke = dependency.invoke,
              rest = _objectWithoutProperties(dependency, ["name", "dependencies", "config", "construct", "invoke"]);

          if (name) {
            _this.registry[name] = {
              config: config,
              construct: construct,
              dependencies: dependencies
            };
            invoke && invokers.push(name);
          } else if (!name && Object.keys(rest).length === 1) {
            var _Object$keys = Object.keys(rest),
                _Object$keys2 = _slicedToArray(_Object$keys, 1),
                derivedName = _Object$keys2[0];

            var derivedConstruct = rest[derivedName];
            _this.registry[derivedName] = {
              config: config,
              construct: derivedConstruct,
              dependencies: dependencies
            };
            invoke && invokers.push(derivedName);
          } else throw new Error('No dependency name has been provided');
        }
      };

      for (var _len2 = arguments.length, dependencyType = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        dependencyType[_key2] = arguments[_key2];
      }

      dependencyType.forEach(addDependency);
      invokers.forEach(function (name) {
        return _this.get(name);
      });
    }
  }, {
    key: "get",
    value: function get(dependencyName) {
      if (typeof this.registry[dependencyName] === 'undefined') throw new Error("".concat(dependencyName, ": Attempting to retrieve unknown dependency"));

      if (typeof this.cache[dependencyName] === 'undefined') {
        var thisDependency = this.registry[dependencyName];
        var construct = thisDependency.construct,
            _thisDependency$depen = thisDependency.dependencies,
            dependencies = _thisDependency$depen === void 0 ? [] : _thisDependency$depen,
            config = thisDependency.config;

        if (construct) {
          if (typeof construct === 'string') {
            var name = construct;
            this.cache[dependencyName] = require(name);
          } else {
            var props = {
              config: this.configs && (config ? this.configs : this.configs[dependencyName]),
              locator: this
            };

            if (construct.prototype instanceof Instance) {
              var Construct = construct;
              this.cache[dependencyName] = new Construct(props, dependencies);
            } else if (typeof construct === 'function') this.cache[dependencyName] = construct(props, dependencies);
          }
        }
      }

      if (!this.cache[dependencyName]) throw new Error("".concat(dependencyName, ": Dependency construction object is invalid"));
      return this.cache[dependencyName];
    }
  }, {
    key: "clear",
    value: function clear() {
      this.registry = {
        Error: {},
        Instance: {}
      };
      this.cache = {
        Error: ControlledError,
        Instance: Instance
      };
    }
  }]);

  return Locator;
}();

export { Locator as default };
export var locator = new Locator();