node-dependency-injection-express-middleware/dist/index.js

Node Dependency Injection Express Middleware

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _nodeDependencyInjection = require("node-dependency-injection");

var _path = _interopRequireDefault(require("path"));

var _ExtensionConfigurationFileNameException = _interopRequireDefault(require("./exception/ExtensionConfigurationFileNameException"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": 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, descriptor.key, descriptor); } }

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

/**
 * Dependency Injection middleware
 */
var Index =
/*#__PURE__*/
function () {
  /**
   * @param {string} serviceFilePath
   * @param {boolean} compile
   * @param {[]} compilerPass
   * @param {*} logger
   * @param {boolean} containerReferenceAsService
   * @param {String} defaultDir
   * @return {Index.middleware}
   */
  function Index(_ref) {
    var serviceFilePath = _ref.serviceFilePath,
        _ref$compile = _ref.compile,
        compile = _ref$compile === void 0 ? false : _ref$compile,
        _ref$compilerPass = _ref.compilerPass,
        compilerPass = _ref$compilerPass === void 0 ? [] : _ref$compilerPass,
        _ref$logger = _ref.logger,
        logger = _ref$logger === void 0 ? null : _ref$logger,
        _ref$containerReferen = _ref.containerReferenceAsService,
        containerReferenceAsService = _ref$containerReferen === void 0 ? false : _ref$containerReferen,
        _ref$defaultDir = _ref.defaultDir,
        defaultDir = _ref$defaultDir === void 0 ? null : _ref$defaultDir;

    _classCallCheck(this, Index);

    this._container = new _nodeDependencyInjection.ContainerBuilder(containerReferenceAsService, defaultDir);
    this.serviceFilePath = serviceFilePath;
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = compilerPass[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var pass = _step.value;

        this._container.addCompilerPass(pass);
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
          _iterator["return"]();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    if (logger) {
      this._container.logger = logger;
    }

    if (compile) {
      this._container.compile();
    }
  }
  /**
   * @param {string} serviceFilePath
   */


  _createClass(Index, [{
    key: "_getLoader",

    /**
     * @param extName
     * @return {YamlFileLoader|JsFileLoader|JsonFileLoader|FileLoader}
     * @private
     */
    value: function _getLoader(extName) {
      switch (extName) {
        case 'yaml':
        case 'yml':
          return new _nodeDependencyInjection.YamlFileLoader(this._container);

        case 'js':
          return new _nodeDependencyInjection.JsFileLoader(this._container);

        case 'json':
          return new _nodeDependencyInjection.JsonFileLoader(this._container);
      }

      throw new _ExtensionConfigurationFileNameException["default"]("".concat(extName, " is not supported"));
    }
    /**
     * @return {ContainerBuilder}
     */

  }, {
    key: "middleware",

    /**
     * @return {function}
     */
    value: function middleware() {
      var _this = this;

      return function (req, res, next) {
        req.container = _this._container;
        next();
      };
    }
  }, {
    key: "serviceFilePath",
    set: function set(serviceFilePath) {
      var extName = _path["default"].extname(serviceFilePath).replace('.', '');

      var loader = this._getLoader(extName);

      loader.load(serviceFilePath);
    }
  }, {
    key: "container",
    get: function get() {
      return this._container;
    }
  }]);

  return Index;
}();

exports["default"] = Index;