@tsed/di 7.0.0-alpha.2 → 7.0.0-beta.1

package/lib/index.js

@@ -1,2269 +0,0 @@
-var core = require('@tsed/core');
-var logger = require('@tsed/logger');
-var tslib = require('tslib');
-var chalk = require('chalk');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
-
-const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
-const DI_PARAMS = "DI:PARAMS";
-const DI_PARAM_OPTIONS = "DI:PARAM:OPTIONS";
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-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;
-}
-
-var id = 0;
-
-function _classPrivateFieldLooseKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-
-function _classPrivateFieldLooseBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-
-  return receiver;
-}
-
-exports.ProviderScope = void 0;
-
-(function (ProviderScope) {
-  ProviderScope["SINGLETON"] = "singleton";
-  ProviderScope["REQUEST"] = "request";
-  ProviderScope["INSTANCE"] = "instance";
-})(exports.ProviderScope || (exports.ProviderScope = {}));
-
-exports.ProviderType = void 0;
-
-(function (ProviderType) {
-  ProviderType["VALUE"] = "value";
-  ProviderType["FACTORY"] = "factory";
-  ProviderType["SERVICE"] = "service";
-  ProviderType["PROVIDER"] = "provider";
-  ProviderType["MODULE"] = "module";
-  ProviderType["CONTROLLER"] = "controller";
-  ProviderType["INTERCEPTOR"] = "interceptor";
-  ProviderType["MIDDLEWARE"] = "middleware";
-})(exports.ProviderType || (exports.ProviderType = {}));
-
-class Provider {
-  constructor(token, options = {}) {
-    this.type = exports.ProviderType.PROVIDER;
-    this.provide = token;
-    this.useClass = token;
-    Object.assign(this, options);
-  }
-
-  get token() {
-    return this._provide;
-  }
-
-  get provide() {
-    return this._provide;
-  }
-
-  set provide(value) {
-    if (value) {
-      this._provide = core.getClassOrSymbol(value);
-      this._tokenStore = this._store = core.Store.from(value);
-    }
-  }
-
-  get useClass() {
-    return this._useClass;
-  }
-  /**
-   * Create a new store if the given value is a class. Otherwise the value is ignored.
-   * @param value
-   */
-
-
-  set useClass(value) {
-    if (core.isClass(value)) {
-      this._useClass = core.classOf(value);
-      this._store = core.Store.from(value);
-    }
-  }
-
-  get className() {
-    return this.name;
-  }
-
-  get name() {
-    return core.nameOf(this.provide);
-  }
-
-  get store() {
-    return this._store;
-  }
-  /**
-   * Get the scope of the provider.
-   *
-   * ::: tip Note
-   * Async provider is always a SINGLETON
-   * :::
-   *
-   * @returns {boolean}
-   */
-
-
-  get scope() {
-    if (this.isAsync()) {
-      return exports.ProviderScope.SINGLETON;
-    }
-
-    return this.get("scope");
-  }
-  /**
-   * Change the scope value of the provider.
-   * @param scope
-   */
-
-
-  set scope(scope) {
-    this.store.set("scope", scope);
-  }
-
-  get configuration() {
-    return this.get("configuration");
-  }
-
-  set configuration(configuration) {
-    this.store.set("configuration", configuration);
-  }
-
-  get(key) {
-    return this.store.get(key) || this._tokenStore.get(key);
-  }
-
-  isAsync() {
-    return !!this.useAsyncFactory;
-  }
-
-  clone() {
-    return new (core.classOf(this))(this._provide, this);
-  }
-
-  toString() {
-    return ["Token", this.name, this.useClass && core.nameOf(this.useClass), this.useFactory && "Factory", this.useValue && "Value", this.useAsyncFactory && "AsyncFactory"].filter(Boolean).join(":");
-  }
-
-}
-
-var _settings = /*#__PURE__*/_classPrivateFieldLooseKey("settings");
-
-class GlobalProviderRegistry extends Map {
-  constructor() {
-    super(...arguments);
-    Object.defineProperty(this, _settings, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldLooseBase(this, _settings)[_settings] = new Map();
-  }
-
-  /**
-   * The get() method returns a specified element from a Map object.
-   * @param key Required. The key of the element to return from the Map object.
-   * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
-   */
-  get(key) {
-    return super.get(core.getClassOrSymbol(key));
-  }
-  /**
-   * The has() method returns a boolean indicating whether an element with the specified key exists or not.
-   * @param key
-   * @returns {boolean}
-   */
-
-
-  has(key) {
-    return super.has(core.getClassOrSymbol(key));
-  }
-  /**
-   * The set() method adds or updates an element with a specified key and value to a Map object.
-   * @param key Required. The key of the element to add to the Map object.
-   * @param metadata Required. The value of the element to add to the Map object.
-   */
-
-
-  set(key, metadata) {
-    super.set(core.getClassOrSymbol(key), metadata);
-    return this;
-  }
-  /**
-   *
-   * @param target
-   * @param options
-   */
-
-
-  merge(target, options) {
-    const meta = this.createIfNotExists(target, options);
-    Object.keys(options).forEach(key => {
-      meta[key] = options[key];
-    });
-    this.set(target, meta);
-  }
-  /**
-   * The delete() method removes the specified element from a Map object.
-   * @param key Required. The key of the element to remove from the Map object.
-   * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
-   */
-
-
-  delete(key) {
-    return super.delete(core.getClassOrSymbol(key));
-  }
-
-  createRegistry(type, model, options = {}) {
-    const defaultOptions = this.getRegistrySettings(type);
-    options = Object.assign(defaultOptions, _extends({}, options, {
-      model
-    }));
-
-    _classPrivateFieldLooseBase(this, _settings)[_settings].set(type, options);
-
-    return this;
-  }
-
-  onInvoke(provider, locals, deps) {
-    const settings = _classPrivateFieldLooseBase(this, _settings)[_settings].get(provider.type);
-
-    if (settings != null && settings.onInvoke) {
-      settings.onInvoke(provider, locals, deps);
-    }
-  }
-
-  getRegistrySettings(target) {
-    let type = "provider";
-
-    if (typeof target === "string") {
-      type = target;
-    } else {
-      const provider = this.get(target);
-
-      if (provider) {
-        type = provider.type;
-      }
-    }
-
-    return _classPrivateFieldLooseBase(this, _settings)[_settings].get(type) || {
-      model: Provider
-    };
-  }
-
-  createRegisterFn(type) {
-    return (provider, instance) => {
-      // istanbul ignore next
-      if (!provider.provide) {
-        provider = {
-          provide: provider
-        };
-      }
-
-      provider = Object.assign({
-        instance
-      }, provider, {
-        type
-      });
-      this.merge(provider.provide, provider);
-    };
-  }
-  /**
-   *
-   * @param key
-   * @param options
-   */
-
-
-  createIfNotExists(key, options) {
-    const type = options.type || exports.ProviderType.PROVIDER;
-
-    if (!this.has(key)) {
-      const {
-        model = Provider
-      } = _classPrivateFieldLooseBase(this, _settings)[_settings].get(type) || {};
-      const item = new model(key);
-      this.set(key, item);
-    }
-
-    return this.get(key);
-  }
-
-}
-/**
- *
- * @type {GlobalProviders}
- */
-// tslint:disable-next-line: variable-name
-
-const GlobalProviders = new GlobalProviderRegistry();
-
-class LocalsContainer extends Map {
-  /**
-   * Emit an event to all service. See service [lifecycle hooks](/docs/services.md#lifecycle-hooks).
-   * @param eventName The event name to emit at all services.
-   * @param args List of the parameters to give to each services.
-   * @returns {Promise<any[]>} A list of promises.
-   */
-  async emit(eventName, ...args) {
-    for (const handler of this.getListeners(eventName)) {
-      await handler(...args);
-    }
-  }
-  /**
-   * @param eventName
-   * @param value
-   * @param args
-   */
-
-
-  alter(eventName, value, ...args) {
-    for (const handler of this.getListeners(eventName)) {
-      value = handler(value, ...args);
-    }
-
-    return value;
-  }
-  /**
-   * @param eventName
-   * @param value
-   * @param args
-   */
-
-
-  async alterAsync(eventName, value, ...args) {
-    for (const handler of this.getListeners(eventName)) {
-      value = handler(value, ...args);
-    }
-
-    return value;
-  }
-
-  toArray() {
-    return [...this.values()];
-  }
-
-  async destroy() {
-    await this.emit("$onDestroy");
-    this.clear();
-  }
-
-  getListeners(event) {
-    return this.toArray().reduce((listeners, instance) => {
-      if (typeof instance === "object" && instance && event in instance) {
-        return listeners.concat(instance[event].bind(instance));
-      }
-
-      return listeners;
-    }, []);
-  }
-
-}
-
-class Container extends LocalsContainer {
-  /**
-   *
-   * @param token
-   * @param settings
-   */
-  add(token, settings = {}) {
-    const provider = GlobalProviders.has(token) ? GlobalProviders.get(token).clone() : new Provider(token);
-    Object.assign(provider, settings);
-    return super.set(token, provider);
-  }
-  /**
-   * Add a provider to the
-   * @param token
-   * @param settings
-   */
-
-
-  addProvider(token, settings = {}) {
-    return this.add(token, settings);
-  }
-  /**
-   *
-   * @param token
-   */
-
-
-  hasProvider(token) {
-    return super.has(token);
-  }
-  /**
-   * Add a provider to the
-   * @param token
-   * @param provider
-   */
-
-
-  setProvider(token, provider) {
-    return super.set(token, provider);
-  }
-  /**
-   * The getProvider() method returns a specified element from a Map object.
-   * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
-   * @param token
-   */
-
-
-  getProvider(token) {
-    return super.get(token);
-  }
-  /**
-   * Get all providers registered in the injector container.
-   *
-   * @param {ProviderType} type Filter the list by the given ProviderType.
-   * @returns {[TokenProvider , Provider<any>][]}
-   */
-
-
-  getProviders(type) {
-    return Array.from(this).filter(([_, provider]) => type ? provider.type === type : true).map(([_, provider]) => provider);
-  }
-
-  addProviders(container) {
-    container.forEach(provider => {
-      if (!this.hasProvider(provider.provide)) {
-        this.setProvider(provider.provide, provider.clone());
-      }
-    });
-  }
-
-}
-
-exports.InjectablePropertyType = void 0;
-
-(function (InjectablePropertyType) {
-  InjectablePropertyType["METHOD"] = "method";
-  InjectablePropertyType["PROPERTY"] = "property";
-  InjectablePropertyType["CONSTANT"] = "constant";
-  InjectablePropertyType["VALUE"] = "value";
-  InjectablePropertyType["INTERCEPTOR"] = "interceptor";
-})(exports.InjectablePropertyType || (exports.InjectablePropertyType = {}));
-
-class ContextLogger {
-  constructor(logger$1, {
-    id,
-    url = "",
-    dateStart = new Date(),
-    ignoreUrlPatterns = [],
-    minimalRequestPicker,
-    completeRequestPicker,
-    level = "all",
-    maxStackSize = 30,
-    ignoreLog,
-    additionalProps
-  }) {
-    this.logger = logger$1;
-    this.stack = [];
-    this.id = id;
-    this.url = url;
-    this.additionalProps = additionalProps || {};
-    this.dateStart = dateStart;
-
-    this.ignoreLog = ignoreLog || (() => false);
-
-    this.minimalRequestPicker = minimalRequestPicker || (l => l);
-
-    this.completeRequestPicker = completeRequestPicker || (l => l); // @ts-ignore
-
-
-    this.level = logger.levels()[level.toUpperCase()] || logger.levels().ALL;
-    this.maxStackSize = maxStackSize;
-  }
-
-  info(obj) {
-    this.run(logger.levels().INFO, obj, obj => this.minimalRequestPicker(this.getData(obj)));
-    return this;
-  }
-
-  debug(obj, withRequest = true) {
-    this.run(logger.levels().DEBUG, obj, obj => {
-      obj = this.getData(obj);
-      return withRequest ? this.completeRequestPicker(obj) : obj;
-    });
-    return this;
-  }
-
-  warn(obj) {
-    this.run(logger.levels().WARN, obj, obj => this.completeRequestPicker(this.getData(obj)));
-    return this;
-  }
-
-  error(obj) {
-    this.run(logger.levels().ERROR, obj, obj => this.completeRequestPicker(this.getData(obj)));
-    return this;
-  }
-
-  trace(obj) {
-    this.run(logger.levels().TRACE, obj, obj => this.completeRequestPicker(this.getData(obj)));
-    return this;
-  }
-
-  flush() {
-    if (this.stack.length) {
-      this.stack.forEach(({
-        level,
-        data
-      }) => {
-        this.logger[level](data);
-      });
-      this.stack = [];
-    }
-  }
-
-  isLevelEnabled(otherLevel) {
-    return this.level.isLessThanOrEqualTo(otherLevel);
-  }
-
-  destroy() {
-    this.flush();
-    this.logger = undefined;
-    this.stack = undefined;
-  }
-  /**
-   * Return the duration between the time when LogIncomingRequest has handle the request and now.
-   * @returns {number}
-   */
-
-
-  getDuration() {
-    return new Date().getTime() - this.dateStart.getTime();
-  }
-
-  getData(obj) {
-    if (typeof obj === "string") {
-      obj = {
-        message: obj
-      };
-    }
-
-    return _extends({}, this.additionalProps, {
-      reqId: this.id,
-      time: new Date(),
-      duration: this.getDuration()
-    }, obj);
-  }
-
-  run(level, obj, mapper) {
-    if (!this.isLevelEnabled(level)) {
-      return;
-    }
-
-    if (!this.ignoreLog(obj)) {
-      this.stack.push({
-        level: level.levelStr.toLowerCase(),
-        data: mapper(obj)
-      });
-    }
-
-    if (this.maxStackSize < this.stack.length) {
-      this.flush();
-    }
-  }
-
-}
-
-const _excluded$2 = ["id", "injector", "logger", "ignoreLog"];
-class DIContext extends Map {
-  constructor(_ref) {
-    let {
-      id,
-      injector,
-      logger,
-      ignoreLog
-    } = _ref,
-        options = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-
-    super();
-    /**
-     * Date when request have been handled by the server. @@RequestLogger@@ use this date to log request duration.
-     */
-
-    this.dateStart = new Date();
-    /**
-     * The request container used by the Ts.ED DI. It contain all services annotated with `@Scope(ProviderScope.REQUEST)`
-     */
-
-    this.container = new LocalsContainer();
-    this.id = id;
-    injector && (this.injector = injector);
-    this.logger = new ContextLogger(logger, _extends({}, options, {
-      dateStart: this.dateStart,
-      id,
-      ignoreLog
-    }));
-  }
-
-  get env() {
-    return this.injector.settings.env;
-  }
-
-  async destroy() {
-    await this.container.destroy();
-    this.logger.destroy(); // @ts-ignore
-
-    delete this.container; // @ts-ignore
-
-    delete this.logger; // @ts-ignore
-
-    delete this.injector;
-  }
-
-  async emit(eventName, ...args) {
-    var _this$injector;
-
-    return (_this$injector = this.injector) == null ? void 0 : _this$injector.emit(eventName, ...args);
-  }
-
-}
-
-/**
- *
- * @param {"request" | "singleton" | ProviderScope} scope
- * @returns {Function}
- * @constructor
- */
-
-function Scope(scope = exports.ProviderScope.REQUEST) {
-  return core.StoreSet("scope", scope);
-}
-
-/**
- *
- */
-
-GlobalProviders.createRegistry(exports.ProviderType.CONTROLLER, Provider);
-/**
- * Register a provider configuration.
- * @param {IProvider<any>} provider
- */
-
-function registerProvider(provider) {
-  if (!provider.provide) {
-    throw new Error("Provider.provide is required");
-  }
-
-  GlobalProviders.merge(provider.provide, provider);
-}
-/**
- * Add a new value in the `ProviderRegistry`.
- *
- * #### Example with symbol definition
- *
- *
- * ```typescript
- * import {registerValue, InjectorService} from "@tsed/di";
- *
- * const MyValue = Symbol.from("MyValue")
- *
- * registerValue({token: MyValue, useValue: "myValue"});
- *
- * @Service()
- * export class OtherService {
- *      constructor(@Inject(MyValue) myValue: string){
- *          console.log(myValue); /// "myValue"
- *      }
- * }
- * ```
- */
-
-const registerValue = (provider, value) => {
-  if (!provider.provide) {
-    provider = {
-      provide: provider
-    };
-  }
-
-  provider = Object.assign({
-    scope: exports.ProviderScope.SINGLETON,
-    useValue: value
-  }, provider, {
-    type: exports.ProviderType.VALUE
-  });
-  GlobalProviders.merge(provider.provide, provider);
-};
-/**
- * Add a new controller in the `ProviderRegistry`. This controller will be built when `InjectorService` will be loaded.
- *
- * #### Example
- *
- * ```typescript
- * import {registerController, InjectorService} from "@tsed/di";
- *
- * export default class MyController {
- *     constructor(){}
- *     transform() {
- *         return "test";
- *     }
- * }
- *
- * registerController({provide: MyController});
- * // or
- * registerController(MyController);
- *
- * const injector = new InjectorService();
- * injector.load();
- *
- * const myController = injector.get<MyController>(MyController);
- * myController.getFoo(); // test
- * ```
- *
- * @param provider Provider configuration.
- */
-
-const registerController = GlobalProviders.createRegisterFn(exports.ProviderType.CONTROLLER);
-
-/**
- * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
- * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
- *
- * <<< @/docs/snippets/providers/getting-started-injectable.ts
- *
- * ::: tip
- * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
- * :::
- *
- * ### Options
- *
- * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
- * - scope (@@ProviderScope@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
- * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
- *
- * @returns {Function}
- * @decorator
- */
-
-function Injectable(options = {}) {
-  return provide => {
-    registerProvider(_extends({}, options, {
-      provide
-    }));
-  };
-}
-
-/**
- * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.
- * All services annotated with `@Service()` are constructed one time.
- *
- * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
- *
- * @returns {Function}
- * @decorator
- */
-
-function Service() {
-  return Injectable();
-}
-
-/**
- * Override a provider which is already registered in ProviderRegistry.
- * @returns {Function}
- * @decorators
- * @param originalProvider
- */
-
-function OverrideProvider(originalProvider) {
-  return target => {
-    GlobalProviders.get(originalProvider).useClass = target;
-  };
-}
-
-/**
- * Inject a provider to another provider.
- *
- * Use this decorator to inject a custom provider on constructor parameter or property.
- *
- * ```typescript
- * @Injectable()
- * export class MyService {
- *   @Inject(CONNECTION)
- *   connection: CONNECTION;
- * }
- * ```
- *
- * @param symbol
- * @param onGet Use the given name method to inject
- * @returns {Function}
- * @decorator
- */
-
-function Inject(symbol, onGet) {
-  return (target, propertyKey, descriptor) => {
-    const bindingType = core.decoratorTypeOf([target, propertyKey, descriptor]);
-
-    switch (bindingType) {
-      case core.DecoratorTypes.PARAM:
-      case core.DecoratorTypes.PARAM_CTOR:
-        if (symbol) {
-          const paramTypes = core.Metadata.getParamTypes(target, propertyKey);
-          paramTypes[descriptor] = symbol;
-          core.Metadata.setParamTypes(target, propertyKey, paramTypes);
-        }
-
-        break;
-
-      case core.DecoratorTypes.PROP:
-        core.Store.from(target).merge(INJECTABLE_PROP, {
-          [propertyKey]: {
-            bindingType,
-            propertyKey,
-            onGet,
-            useType: symbol || core.Metadata.getType(target, propertyKey)
-          }
-        });
-        break;
-
-      case core.DecoratorTypes.METHOD:
-        core.Store.from(target).merge(INJECTABLE_PROP, {
-          [propertyKey]: {
-            bindingType,
-            propertyKey
-          }
-        });
-        return descriptor;
-
-      default:
-        throw new core.UnsupportedDecoratorType(Inject, [target, propertyKey, descriptor]);
-    }
-  };
-}
-
-/**
- * Return value from Configuration.
- *
- * ## Example
- *
- * ```typescript
- * import {Env} from "@tsed/core";
- * import {Constant, Value} from "@tsed/di";
- *
- * export class MyClass {
- *
- *    @Constant("env")
- *    env: Env;
- *
- *    @Value("swagger.path")
- *    swaggerPath: string;
- *
- *    @Value("swagger.path", "defaultValue")
- *    swaggerPath: string;
- *
- *    constructor() {
- *       console.log(this.swaggerPath) // undefined. Not available on constructor
- *    }
- *
- *    $onInit() {
- *      console.log(this.swaggerPath)  // something
- *    }
- * }
- * ```
- *
- * @param {string} expression
- * @param defaultValue
- * @returns {(targetClass: any, attributeName: string) => any}
- * @decorator
- */
-
-function Constant(expression, defaultValue) {
-  return (target, propertyKey) => {
-    core.Store.from(target).merge(INJECTABLE_PROP, {
-      [propertyKey]: {
-        bindingType: exports.InjectablePropertyType.CONSTANT,
-        propertyKey,
-        expression,
-        defaultValue
-      }
-    });
-  };
-}
-
-/**
- * Return value from Configuration.
- *
- * ## Example
- *
- * ```typescript
- * import {Env} from "@tsed/core";
- * import {Constant, Value} from "@tsed/di";
- *
- * export class MyClass {
- *
- *    @Constant("env")
- *    env: Env;
- *
- *    @Value("swagger.path")
- *    swaggerPath: string;
- *
- *    @Value("swagger.path", "defaultValue")
- *    swaggerPath: string;
- *
- *    constructor() {
- *       console.log(this.swaggerPath) // undefined. Not available on constructor
- *    }
- *
- *    $onInit() {
- *      console.log(this.swaggerPath)  // something
- *    }
- * }
- * ```
- *
- * @param expression
- * @param defaultValue
- * @returns {(targetClass: any, attributeName: string) => any}
- * @decorator
- */
-
-function Value(expression, defaultValue) {
-  return (target, propertyKey) => {
-    core.Store.from(target).merge(INJECTABLE_PROP, {
-      [propertyKey]: {
-        bindingType: exports.InjectablePropertyType.VALUE,
-        propertyKey,
-        expression,
-        defaultValue
-      }
-    });
-  };
-}
-
-/**
- * Attaches interceptor to method call and executes the before and after methods
- *
- * @param interceptor
- * @param options
- * @decorator
- */
-
-function Intercept(interceptor, options) {
-  return (target, propertyKey, descriptor) => {
-    core.Store.from(target).merge(INJECTABLE_PROP, {
-      [propertyKey]: {
-        bindingType: exports.InjectablePropertyType.INTERCEPTOR,
-        propertyKey,
-        useType: interceptor,
-        options
-      }
-    });
-    return descriptor;
-  };
-}
-
-/**
- * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.
- * All services annotated with `@Service()` are constructed one time.
- *
- * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
- *
- * @returns {Function}
- * @decorator
- */
-
-function Interceptor() {
-  return Injectable({
-    type: exports.ProviderType.INTERCEPTOR
-  });
-}
-
-/**
- * Get or set Configuration on a class.
- *
- * @decorator
- */
-
-function Configuration(configuration = {}) {
-  return (...args) => {
-    switch (core.decoratorTypeOf(args)) {
-      case core.DecoratorTypes.CLASS:
-        core.StoreSet("configuration", configuration)(args[0]);
-        break;
-
-      default:
-      case core.DecoratorTypes.PARAM_CTOR:
-        return Inject(Configuration)(args[0], args[1], args[2]);
-    }
-  };
-}
-
-const _excluded$1 = ["scopes", "imports", "resolvers", "deps", "scope"];
-/**
- * Declare a new Ts.ED module
- *
- * ## Options
- * - imports: List of Provider which must be built by injector before invoking the module
- * - resolvers: List of external DI must be used to resolve unknown provider
- * - deps: List of provider must be injected to the module constructor (explicit declaration)
- *
- * @param options
- * @decorator
- */
-
-function Module(options = {}) {
-  const {
-    imports,
-    resolvers,
-    deps
-  } = options,
-        configuration = _objectWithoutPropertiesLoose(options, _excluded$1);
-
-  return core.useDecorators(Configuration(configuration), Injectable({
-    type: exports.ProviderType.MODULE,
-    scope: exports.ProviderScope.SINGLETON,
-    imports,
-    deps,
-    injectable: false,
-    resolvers
-  }));
-}
-
-/**
- * Get instance options. This options depending on his invocation context.
- *
- * ```typescript
- * import {Injectable, Opts, UseOpts} from "@tsed/di";
- *
- * @Injectable()
- * class MyConfigurableService {
- *   source: string;
- *   constructor(@Opts options: any = {}) {
- *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
- *
- *      this.source = options.source;
- *   }
- * }
- *
- * @Injectable()
- * class MyService1 {
- *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service1
- *   }
- * }
- *
- * @Injectable()
- * class MyService2 {
- *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service2
- *   }
- * }
- * ```
- *
- * ::: warning
- * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
- * :::
- *
- * @param target
- * @param propertyKey
- * @param index
- * @decorator
- */
-
-function Opts(target, propertyKey, index) {
-  Scope(exports.ProviderScope.INSTANCE)(core.classOf(target));
-  Inject(DI_PARAM_OPTIONS)(target, propertyKey, index);
-}
-
-/**
- * Add options to invoke the Service.
- *
- * ```typescript
- * import {Injectable, Opts, UseOpts} from "@tsed/di";
- *
- * @Injectable()
- * class MyConfigurableService {
- *   source: string;
- *   constructor(@Opts options: any = {}) {
- *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
- *
- *      this.source = options.source;
- *   }
- * }
- *
- * @Injectable()
- * class MyService1 {
- *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service1
- *   }
- * }
- *
- * @Injectable()
- * class MyService2 {
- *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service2
- *   }
- * }
- * ```
- *
- * ::: warning
- * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
- * :::
- *
- * @returns {Function}
- * @decorator
- * @param options
- */
-
-function UseOpts(options) {
-  return (target, propertyKey, index) => {
-    const bindingType = core.decoratorTypeOf([target, propertyKey, index]);
-
-    switch (bindingType) {
-      case core.DecoratorTypes.PARAM_CTOR:
-        core.Store.from(target).merge(`${DI_PARAM_OPTIONS}:${index}`, options);
-        break;
-
-      case core.DecoratorTypes.PROP:
-        core.Store.from(target).merge(INJECTABLE_PROP, {
-          [propertyKey]: {
-            options
-          }
-        });
-        break;
-
-      default:
-        throw new core.UnsupportedDecoratorType(UseOpts, [target, propertyKey, index]);
-    }
-  };
-}
-
-const _excluded = ["children"];
-
-function mapOptions(options) {
-  if (typeof options === "string" || options instanceof RegExp || core.isArrayOrArrayClass(options)) {
-    return {
-      path: options
-    };
-  }
-
-  return options;
-}
-/**
- * Declare a new controller with his Rest path. His methods annotated will be collected to build the routing list.
- * This routing listing will be built with the `express.Router` object.
- *
- * ::: tip
- * See [Controllers](/docs/controllers.md) section for more details
- * :::
- *
- * ```typescript
- *  @Controller("/calendars")
- *  export provide CalendarCtrl {
- *
- *    @Get("/:id")
- *    public get(
- *      @Req() request: Req,
- *      @Res() response: Res,
- *      @Next() next: Next
- *    ): void {
- *
- *    }
- *  }
- * ```
- *
- * @param options
- * @controller
- * @decorator
- * @classDecorator
- */
-
-
-function Controller(options) {
-  const _mapOptions = mapOptions(options),
-        {
-    children = []
-  } = _mapOptions,
-        opts = _objectWithoutPropertiesLoose(_mapOptions, _excluded);
-
-  return target => {
-    registerController(_extends({
-      provide: target
-    }, opts));
-    core.Store.from(target).set("childrenControllers", children);
-    children.forEach(childToken => {
-      core.Store.from(childToken).set("parentController", target);
-    });
-  };
-}
-
-class InjectionError extends Error {
-  constructor(token, origin) {
-    super(core.isString(origin) ? origin : "");
-    this.name = "INJECTION_ERROR";
-    this.tokens = [];
-    this.tokens = [token];
-
-    if (origin) {
-      if (core.isString(origin)) {
-        this.origin = {
-          message: origin,
-          stack: this.stack
-        };
-      } else {
-        if (origin.tokens) {
-          this.tokens = this.tokens.concat(origin.tokens);
-          this.origin = origin.origin;
-        } else {
-          this.origin = origin;
-          this.stack = origin.stack;
-        }
-      }
-    }
-
-    const originMessage = this.origin ? "\nOrigin: " + this.origin.message : "";
-    const tokensMessage = this.tokens.map(token => core.nameOf(token)).join(" > ");
-    this.message = `Injection failed on ${tokensMessage}${originMessage}`;
-  }
-
-  static throwInjectorError(token, currentDependency, error) {
-    if (currentDependency && core.isClass(token)) {
-      error.message = printDependencyInjectionError(token, _extends({}, currentDependency, {
-        message: error.message
-      }));
-    }
-
-    throw new InjectionError(token, error);
-  }
-
-}
-
-function printDependencyInjectionError(token, options) {
-  let erroredArg = "";
-  const args = core.getConstructorArgNames(token).map((arg, index) => {
-    if (options.index === index) {
-      erroredArg = arg;
-      arg = chalk__default['default'].red(arg);
-    }
-
-    return `${arg}: ${core.nameOf(options.deps[index])}`;
-  }).join(", ");
-  const signature = core.nameOf(token) + "->constructor(" + args + ")";
-  const indexOf = signature.indexOf(erroredArg) - 5;
-
-  const drawline = indexOf => " ".repeat(indexOf) + chalk__default['default'].red("^" + "‾".repeat(erroredArg.length - 1));
-
-  return "Unable to inject dependency. " + options.message + "\n\n" + signature + "\n" + (indexOf > -1 ? drawline(indexOf) : "");
-}
-
-class UndefinedTokenError extends Error {
-  constructor() {
-    super("Given token is undefined. Have you enabled emitDecoratorMetadata in your tsconfig.json or decorated your class with @Injectable, @Service, ... decorator ?");
-    this.name = "UNDEFINED_TOKEN_ERROR";
-  }
-
-}
-
-function createContainer(rootModule) {
-  const container = new Container(GlobalProviders.entries());
-
-  if (rootModule) {
-    container.delete(rootModule);
-  }
-
-  return container;
-}
-
-class DIConfiguration {
-  constructor(initialProps = {}) {
-    this.default = new Map();
-    this.map = new Map();
-    Object.entries(_extends({
-      scopes: {},
-      resolvers: [],
-      imports: []
-    }, initialProps)).forEach(([key, value]) => {
-      this.default.set(key, value);
-    });
-    return core.proxyDelegation(this, {
-      ownKeys(target) {
-        return [...target.default.keys(), ...target.map.keys()];
-      }
-
-    });
-  }
-
-  get scopes() {
-    return this.getRaw("scopes");
-  }
-
-  set scopes(value) {
-    this.setRaw("scopes", value);
-  }
-
-  get resolvers() {
-    return this.getRaw("resolvers");
-  }
-
-  set resolvers(resolvers) {
-    this.setRaw("resolvers", resolvers);
-  }
-
-  get imports() {
-    return this.getRaw("imports");
-  }
-
-  set imports(imports) {
-    this.setRaw("imports", imports);
-  }
-  /**
-   *
-   * @param callbackfn
-   * @param thisArg
-   */
-
-
-  forEach(callbackfn, thisArg) {
-    return new Set([...Array.from(this.default.keys()), ...Array.from(this.map.keys())]).forEach(key => {
-      callbackfn(this.getRaw(key), key, this.map);
-    }, thisArg);
-  }
-  /**
-   *
-   * @param propertyKey
-   * @param value
-   */
-
-
-  set(propertyKey, value) {
-    if (typeof propertyKey === "string") {
-      this.setRaw(propertyKey, value);
-    } else {
-      Object.entries(propertyKey).forEach(([key, value]) => {
-        this[key] = value;
-      });
-    }
-
-    return this;
-  }
-
-  setRaw(propertyKey, value) {
-    core.setValue(this.map, propertyKey, value);
-    return this;
-  }
-  /**
-   *
-   * @param propertyKey
-   * @param defaultValue
-   * @returns {undefined|any}
-   */
-
-
-  get(propertyKey, defaultValue) {
-    return this.resolve(this.getRaw(propertyKey, defaultValue));
-  }
-
-  getRaw(propertyKey, defaultValue) {
-    const value = core.getValue(this.map, propertyKey);
-
-    if (value !== undefined) {
-      return value;
-    }
-
-    return core.getValue(this.default, propertyKey, defaultValue);
-  }
-
-  merge(obj) {
-    Object.entries(obj).forEach(([key, value]) => {
-      const descriptor = Object.getOwnPropertyDescriptor(DIConfiguration.prototype, key);
-      const originalValue = this.get(key);
-      value = core.deepMerge(value, originalValue);
-
-      if (descriptor && !["default", "set", "map", "get"].includes(key)) {
-        this[key] = value;
-      }
-    });
-  }
-  /**
-   *
-   * @param value
-   * @returns {any}
-   */
-
-
-  resolve(value) {
-    if (typeof value === "object" && value !== null) {
-      if (![Array, Object].includes(core.classOf(value))) {
-        return value;
-      }
-
-      return Object.entries(value).reduce((o, [k, v]) => {
-        // @ts-ignore
-        o[k] = this.resolve(v);
-        return o;
-      }, Array.isArray(value) ? [] : {});
-    }
-
-    if (typeof value === "string") {
-      const replacer = (match, key) => core.getValue(this.map, key);
-
-      return value.replace(/\${([\w.]+)}/gi, replacer).replace(/<([\w.]+)>/gi, replacer).replace(/{{([\w.]+)}}/gi, replacer);
-    }
-
-    return value;
-  }
-
-  build() {
-    this.forEach((value, key) => this.map.set(key, this.resolve(value)));
-    this.set = this.setRaw;
-
-    this.get = this.getRaw = (propertyKey, defaultValue) => core.getValue(this.map, propertyKey, defaultValue);
-  }
-
-}
-
-var InjectorService_1;
-/**
- * This service contain all services collected by `@Service` or services declared manually with `InjectorService.factory()` or `InjectorService.service()`.
- *
- * ### Example:
- *
- * ```typescript
- * import {InjectorService} from "@tsed/di";
- *
- * // Import the services (all services are decorated with @Service()";
- * import MyService1 from "./services/service1";
- * import MyService2 from "./services/service2";
- * import MyService3 from "./services/service3";
- *
- * // When all services is imported you can load InjectorService.
- * const injector = new InjectorService()
- *
- * await injector.load();
- *
- * const myService1 = injector.get<MyService1>(MyServcice1);
- * ```
- */
-
-exports.InjectorService = InjectorService_1 = class InjectorService extends Container {
-  constructor() {
-    super();
-    this.settings = new DIConfiguration();
-    this.logger = console;
-    this.resolvedConfiguration = false;
-    const provider = this.addProvider(InjectorService_1).getProvider(InjectorService_1);
-    provider.instance = this;
-  }
-
-  get resolvers() {
-    return this.settings.resolvers;
-  }
-
-  get scopes() {
-    return this.settings.scopes || {};
-  }
-  /**
-   * Retrieve default scope for a given provider.
-   * @param provider
-   */
-
-
-  scopeOf(provider) {
-    return provider.scope || this.scopes[provider.type] || exports.ProviderScope.SINGLETON;
-  }
-  /**
-   * Clone a provider from GlobalProviders and the given token. forkProvider method build automatically the provider if the instance parameter ins't given.
-   * @param token
-   * @param settings
-   */
-
-
-  forkProvider(token, settings = {}) {
-    if (!this.hasProvider(token)) {
-      this.addProvider(token);
-    }
-
-    const provider = this.getProvider(token);
-    Object.assign(provider, settings);
-    provider.instance = this.invoke(token);
-    return provider;
-  }
-  /**
-   * Return a list of instance build by the injector.
-   */
-
-
-  toArray() {
-    return super.toArray().map(provider => provider.instance);
-  }
-  /**
-   * Get a service or factory already constructed from his symbol or class.
-   *
-   * #### Example
-   *
-   * ```typescript
-   * import {InjectorService} from "@tsed/di";
-   * import MyService from "./services";
-   *
-   * class OtherService {
-   *      constructor(injectorService: InjectorService) {
-   *          const myService = injectorService.get<MyService>(MyService);
-   *      }
-   * }
-   * ```
-   *
-   * @param token The class or symbol registered in InjectorService.
-   * @param options
-   * @returns {boolean}
-   */
-
-
-  get(token, options = {}) {
-    var _super$get;
-
-    const instance = (_super$get = super.get(core.getClassOrSymbol(token))) == null ? void 0 : _super$get.instance;
-
-    if (instance !== undefined) {
-      return instance;
-    }
-
-    if (!this.hasProvider(token)) {
-      for (const resolver of this.resolvers) {
-        const result = resolver.get(token, options);
-
-        if (result !== undefined) {
-          return result;
-        }
-      }
-    }
-  }
-  /**
-   * The has() method returns a boolean indicating whether an element with the specified key exists or not.
-   * @returns {boolean}
-   * @param token
-   */
-
-
-  has(token) {
-    return super.has(core.getClassOrSymbol(token)) && this.get(token) !== undefined;
-  }
-  /**
-   * Invoke the class and inject all services that required by the class constructor.
-   *
-   * #### Example
-   *
-   * ```typescript
-   * import {InjectorService} from "@tsed/di";
-   * import MyService from "./services";
-   *
-   * class OtherService {
-   *     constructor(injectorService: InjectorService) {
-   *          const myService = injectorService.invoke<MyService>(MyService);
-   *      }
-   *  }
-   * ```
-   *
-   * @param token The injectable class to invoke. Class parameters are injected according constructor signature.
-   * @param locals  Optional object. If preset then any argument Class are read from this object first, before the `InjectorService` is consulted.
-   * @param options
-   * @returns {T} The class constructed.
-   */
-
-
-  invoke(token, locals = new LocalsContainer(), options = {}) {
-    const provider = this.ensureProvider(token);
-    let instance;
-    !locals.has(Configuration) && locals.set(Configuration, this.settings);
-
-    if (locals.has(token)) {
-      return locals.get(token);
-    }
-
-    if (token === DI_PARAM_OPTIONS) {
-      return {};
-    }
-
-    if (!provider || options.rebuild) {
-      instance = this.resolve(token, locals, options);
-      this.hasProvider(token) && (this.getProvider(token).instance = instance);
-      return instance;
-    }
-
-    switch (this.scopeOf(provider)) {
-      case exports.ProviderScope.SINGLETON:
-        if (!this.has(token)) {
-          provider.instance = this.resolve(token, locals, options);
-
-          if (provider.isAsync()) {
-            provider.instance.then(instance => {
-              provider.instance = instance;
-            });
-          }
-        }
-
-        instance = this.get(token);
-        break;
-
-      case exports.ProviderScope.REQUEST:
-        instance = this.resolve(token, locals, options);
-        locals.set(token, instance);
-        break;
-
-      case exports.ProviderScope.INSTANCE:
-        instance = this.resolve(provider.provide, locals, options);
-        break;
-    }
-
-    return instance;
-  }
-  /**
-   * Build only providers which are asynchronous.
-   */
-
-
-  async loadAsync(locals = new LocalsContainer()) {
-    for (const [, provider] of this) {
-      if (!locals.has(provider.token)) {
-        if (provider.isAsync()) {
-          await this.invoke(provider.token, locals);
-        }
-
-        if (provider.instance) {
-          locals.set(provider.token, provider.instance);
-        }
-      }
-    }
-
-    return locals;
-  }
-
-  loadSync(locals = new LocalsContainer()) {
-    for (const [, provider] of this) {
-      if (!locals.has(provider.token) && this.scopeOf(provider) === exports.ProviderScope.SINGLETON) {
-        this.invoke(provider.token, locals);
-      }
-
-      if (provider.instance !== undefined) {
-        locals.set(provider.token, provider.instance);
-      }
-    }
-
-    return locals;
-  }
-  /**
-   * Boostrap injector from container and resolve configuration.
-   *
-   * @param container
-   */
-
-
-  bootstrap(container = createContainer()) {
-    // Clone all providers in the container
-    this.addProviders(container); // Resolve all configuration
-
-    this.resolveConfiguration();
-    return this;
-  }
-  /**
-   * Build all providers from given container (or GlobalProviders) and emit `$onInit` event.
-   *
-   * @param container
-   * @param rootModule
-   */
-
-
-  async load(container = createContainer(), rootModule) {
-    this.bootstrap(container); // build async and sync provider
-
-    let locals = await this.loadAsync();
-
-    if (rootModule) {
-      await this.invoke(rootModule);
-    } // load sync provider
-
-
-    locals = this.loadSync(locals);
-    await locals.emit("$onInit");
-    return locals;
-  }
-  /**
-   * Load all configurations registered on providers
-   */
-
-
-  resolveConfiguration() {
-    if (this.resolvedConfiguration) {
-      return;
-    }
-
-    const mergedConfiguration = new Map();
-    super.forEach(provider => {
-      if (provider.configuration) {
-        Object.entries(provider.configuration).forEach(([key, value]) => {
-          value = mergedConfiguration.has(key) ? core.deepMerge(mergedConfiguration.get(key), value) : core.deepClone(value);
-          mergedConfiguration.set(key, value);
-        });
-      }
-
-      if (provider.resolvers) {
-        this.resolvers.push(...provider.resolvers);
-      }
-    });
-    mergedConfiguration.forEach((value, key) => {
-      this.settings[key] = core.deepMerge(value, this.settings[key]);
-    });
-    this.settings.build();
-    this.resolvedConfiguration = true;
-  }
-  /**
-   *
-   * @param instance
-   * @param locals
-   * @param options
-   */
-
-
-  bindInjectableProperties(instance, locals, options) {
-    const properties = core.ancestorsOf(core.classOf(instance)).reduce((properties, target) => {
-      const store = core.Store.from(target);
-      return _extends({}, properties, store.get(INJECTABLE_PROP) || {});
-    }, {});
-    Object.values(properties).forEach(definition => {
-      switch (definition.bindingType) {
-        case exports.InjectablePropertyType.METHOD:
-          this.bindMethod(instance, definition);
-          break;
-
-        case exports.InjectablePropertyType.PROPERTY:
-          this.bindProperty(instance, definition, locals, options);
-          break;
-
-        case exports.InjectablePropertyType.CONSTANT:
-          this.bindConstant(instance, definition);
-          break;
-
-        case exports.InjectablePropertyType.VALUE:
-          this.bindValue(instance, definition);
-          break;
-
-        case exports.InjectablePropertyType.INTERCEPTOR:
-          this.bindInterceptor(instance, definition);
-          break;
-      }
-    });
-  }
-  /**
-   *
-   * @param instance
-   * @param {string} propertyKey
-   */
-
-
-  bindMethod(instance, {
-    propertyKey
-  }) {
-    const target = core.classOf(instance);
-    const originalMethod = instance[propertyKey];
-    const deps = core.Metadata.getParamTypes(core.prototypeOf(target), propertyKey);
-
-    instance[propertyKey] = () => {
-      const services = deps.map(dependency => this.get(dependency));
-      return originalMethod.call(instance, ...services);
-    };
-  }
-  /**
-   * Create an injectable property.
-   *
-   * @param instance
-   * @param {string} propertyKey
-   * @param {any} useType
-   * @param onGet
-   * @param options
-   * @param locals
-   * @param invokeOptions
-   */
-
-
-  bindProperty(instance, {
-    propertyKey,
-    useType,
-    onGet = f => f,
-    options
-  }, locals, invokeOptions) {
-    invokeOptions = _extends({}, invokeOptions);
-    locals.set(DI_PARAM_OPTIONS, _extends({}, options));
-    let bean = this.invoke(useType, locals, invokeOptions);
-    locals.delete(DI_PARAM_OPTIONS);
-
-    if (core.isPromise(bean)) {
-      bean.then(result => {
-        bean = result;
-      });
-    }
-
-    Object.defineProperty(instance, propertyKey, {
-      get: () => onGet(bean)
-    });
-  }
-  /**
-   *
-   * @param instance
-   * @param {string} propertyKey
-   * @param {any} useType
-   */
-
-
-  bindValue(instance, {
-    propertyKey,
-    expression,
-    defaultValue
-  }) {
-    const descriptor = {
-      get: () => this.settings.get(expression) || defaultValue,
-      set: value => this.settings.set(expression, value),
-      enumerable: true,
-      configurable: true
-    };
-    Object.defineProperty(instance, propertyKey, descriptor);
-  }
-  /**
-   *
-   * @param instance
-   * @param {string} propertyKey
-   * @param {any} useType
-   */
-
-
-  bindConstant(instance, {
-    propertyKey,
-    expression,
-    defaultValue
-  }) {
-    let bean;
-
-    const get = () => {
-      if (bean !== undefined) {
-        return bean;
-      }
-
-      const value = this.settings.get(expression, defaultValue);
-      bean = Object.freeze(core.deepClone(value));
-      return bean;
-    };
-
-    const descriptor = {
-      get,
-      enumerable: true,
-      configurable: true
-    };
-    Object.defineProperty(instance, propertyKey, descriptor);
-    return descriptor;
-  }
-  /**
-   *
-   * @param instance
-   * @param propertyKey
-   * @param useType
-   * @param options
-   */
-
-
-  bindInterceptor(instance, {
-    propertyKey,
-    useType,
-    options
-  }) {
-    const target = core.classOf(instance);
-    const originalMethod = instance[propertyKey];
-
-    instance[propertyKey] = (...args) => {
-      const next = err => {
-        if (!err) {
-          return originalMethod.apply(instance, args);
-        }
-
-        throw err;
-      };
-
-      const context = {
-        target,
-        propertyKey,
-        args,
-        options,
-        next
-      };
-      const interceptor = this.get(useType);
-      return interceptor.intercept(_extends({}, context, {
-        options
-      }), next);
-    };
-  }
-  /**
-   * Allow handler hack for AsyncHookContext plugin.
-   * @param ctx
-   * @param cb
-   * @protected
-   */
-
-
-  runInContext(ctx, cb) {
-    return cb();
-  }
-
-  ensureProvider(token) {
-    if (!this.hasProvider(token) && GlobalProviders.has(token)) {
-      this.addProvider(token);
-    }
-
-    return this.getProvider(token);
-  }
-  /**
-   * Invoke a class method and inject service.
-   *
-   * #### IInjectableMethod options
-   *
-   * * **target**: Optional. The class instance.
-   * * **methodName**: `string` Optional. The method name.
-   * * **designParamTypes**: `any[]` Optional. List of injectable types.
-   * * **locals**: `Map<Function, any>` Optional. If preset then any argument Class are read from this object first, before the `InjectorService` is consulted.
-   *
-   * #### Example
-   *
-   * @param target
-   * @param locals
-   * @param options
-   * @private
-   */
-
-
-  resolve(target, locals, options = {}) {
-    const {
-      token,
-      deps,
-      construct,
-      isBindable,
-      imports,
-      provider
-    } = this.mapInvokeOptions(target, locals, options);
-
-    if (provider) {
-      GlobalProviders.onInvoke(provider, locals, deps);
-    }
-
-    let instance;
-    let currentDependency = false;
-
-    try {
-      const invokeDependency = parent => (token, index) => {
-        currentDependency = {
-          token,
-          index,
-          deps
-        };
-
-        if (token !== DI_PARAM_OPTIONS) {
-          var _provider$store;
-
-          const options = provider == null ? void 0 : (_provider$store = provider.store) == null ? void 0 : _provider$store.get(`${DI_PARAM_OPTIONS}:${index}`);
-          locals.set(DI_PARAM_OPTIONS, options || {});
-        }
-
-        return core.isInheritedFrom(token, Provider, 1) ? provider : this.invoke(token, locals, {
-          parent
-        });
-      }; // Invoke manually imported providers
-
-
-      imports.forEach(invokeDependency()); // Inject dependencies
-
-      const services = deps.map(invokeDependency(token));
-      currentDependency = false;
-      instance = construct(services);
-    } catch (error) {
-      InjectionError.throwInjectorError(token, currentDependency, error);
-    }
-
-    if (instance === undefined) {
-      throw new InjectionError(token, `Unable to create new instance from undefined value. Check your provider declaration for ${core.nameOf(token)}`);
-    }
-
-    if (instance && isBindable) {
-      this.bindInjectableProperties(instance, locals, options);
-    }
-
-    return instance;
-  }
-  /**
-   * Create options to invoke a provider or class.
-   * @param token
-   * @param locals
-   * @param options
-   */
-
-
-  mapInvokeOptions(token, locals, options) {
-    let imports = options.imports;
-    let deps = options.deps;
-    let scope = options.scope;
-    let construct;
-    let isBindable = false;
-
-    if (!token) {
-      throw new UndefinedTokenError();
-    }
-
-    let provider;
-
-    if (!this.hasProvider(token)) {
-      provider = new Provider(token);
-      this.resolvers.forEach(resolver => {
-        const result = resolver.get(token, locals.get(DI_PARAM_OPTIONS));
-
-        if (result !== undefined) {
-          provider.useFactory = () => result;
-        }
-      });
-    } else {
-      provider = this.getProvider(token);
-    }
-
-    scope = scope || this.scopeOf(provider);
-    deps = deps || provider.deps;
-    imports = imports || provider.imports;
-
-    if (provider.useValue !== undefined) {
-      construct = () => core.isFunction(provider.useValue) ? provider.useValue() : provider.useValue;
-    } else if (provider.useFactory) {
-      construct = deps => provider.useFactory(...deps);
-    } else if (provider.useAsyncFactory) {
-      construct = async deps => {
-        deps = await Promise.all(deps);
-        return provider.useAsyncFactory(...deps);
-      };
-    } else {
-      // useClass
-      isBindable = true;
-      deps = deps || core.Metadata.getParamTypes(provider.useClass);
-
-      construct = deps => new provider.useClass(...deps);
-    }
-
-    return {
-      token,
-      scope: scope || core.Store.from(token).get("scope") || exports.ProviderScope.SINGLETON,
-      deps: deps || [],
-      imports: imports || [],
-      isBindable,
-      construct,
-      provider
-    };
-  }
-
-};
-exports.InjectorService = InjectorService_1 = tslib.__decorate([Injectable({
-  scope: exports.ProviderScope.SINGLETON,
-  global: true
-}), tslib.__metadata("design:paramtypes", [])], exports.InjectorService);
-
-registerProvider({
-  provide: logger.Logger,
-  deps: [exports.InjectorService],
-
-  useFactory(injector) {
-    return injector.logger;
-  }
-
-});
-
-/**
- * @ignore
- * @param injector
- */
-function setLoggerLevel(injector) {
-  var _injector$settings$lo;
-
-  const level = (_injector$settings$lo = injector.settings.logger) == null ? void 0 : _injector$settings$lo.level;
-
-  if (level) {
-    injector.logger.level = level;
-  }
-}
-
-/**
- * Tool to run test with lightweight DI sandbox.
- */
-
-class DITest {
-  static get injector() {
-    if (DITest._injector) {
-      return DITest._injector;
-    }
-    /* istanbul ignore next */
-
-
-    throw new Error("PlatformTest.injector is not initialized. Use PlatformTest.create(): Promise before PlatformTest.invoke() or PlatformTest.injector.\n" + "Example:\n" + "before(async () => {\n" + "   await PlatformTest.create()\n" + "   await PlatformTest.invoke(MyService, [])\n" + "})");
-  }
-
-  static set injector(injector) {
-    DITest._injector = injector;
-  }
-
-  static hasInjector() {
-    return !!DITest._injector;
-  }
-
-  static async create(settings = {}) {
-    DITest.injector = DITest.createInjector(settings);
-    const container = new Container();
-    DITest.injector.bootstrap(container);
-    await DITest.injector.load(container);
-  }
-  /**
-   * Create a new injector with the right default services
-   */
-
-
-  static createInjector(settings = {}) {
-    const injector = new exports.InjectorService();
-    injector.logger = logger.$log; // @ts-ignore
-
-    injector.settings.set(DITest.configure(settings));
-    setLoggerLevel(injector);
-    return injector;
-  }
-  /**
-   * Resets the test injector of the test context, so it won't pollute your next test. Call this in your `tearDown` logic.
-   */
-
-
-  static async reset() {
-    if (DITest.hasInjector()) {
-      await DITest.injector.destroy();
-      DITest._injector = null;
-    }
-  }
-  /**
-   * Invoke a provider and return a fresh instance
-   * @param target
-   * @param providers
-   */
-
-
-  static invoke(target, providers = []) {
-    const locals = new LocalsContainer();
-    providers.forEach(p => {
-      locals.set(p.token, p.use);
-    });
-    locals.set(exports.InjectorService, DITest.injector);
-    const instance = DITest.injector.invoke(target, locals, {
-      rebuild: true
-    });
-
-    if (instance && instance.$onInit) {
-      // await instance.$onInit();
-      const result = instance.$onInit();
-
-      if (result instanceof Promise) {
-        return result.then(() => instance);
-      }
-    }
-
-    return instance;
-  }
-  /**
-   * Return the instance from injector registry
-   * @param target
-   * @param options
-   */
-
-
-  static get(target, options = {}) {
-    return DITest.injector.get(target, options);
-  }
-
-  static configure(settings = {}) {
-    return _extends({}, settings, {
-      env: core.getValue(settings, "env", core.Env.TEST),
-      logger: _extends({}, core.getValue(settings, "logger", {}), {
-        level: core.getValue(settings, "logger.level", "off")
-      })
-    });
-  }
-
-}
-DITest._injector = null;
-
-function getConfiguration(module, configuration = {}) {
-  const store = core.Store.from(module).get("configuration") || {};
-
-  const config = _extends({}, store, configuration);
-
-  if (store.mount && configuration.mount) {
-    config.mount = core.deepMerge(store.mount, configuration.mount);
-  }
-
-  if (store.componentsScan && configuration.componentsScan) {
-    config.componentsScan = [...store.componentsScan, ...configuration.componentsScan];
-  }
-
-  return config;
-}
-
-exports.Configuration = Configuration;
-exports.Constant = Constant;
-exports.Container = Container;
-exports.ContextLogger = ContextLogger;
-exports.Controller = Controller;
-exports.DIConfiguration = DIConfiguration;
-exports.DIContext = DIContext;
-exports.DITest = DITest;
-exports.DI_PARAMS = DI_PARAMS;
-exports.DI_PARAM_OPTIONS = DI_PARAM_OPTIONS;
-exports.GlobalProviderRegistry = GlobalProviderRegistry;
-exports.GlobalProviders = GlobalProviders;
-exports.INJECTABLE_PROP = INJECTABLE_PROP;
-exports.Inject = Inject;
-exports.Injectable = Injectable;
-exports.InjectionError = InjectionError;
-exports.Intercept = Intercept;
-exports.Interceptor = Interceptor;
-exports.LocalsContainer = LocalsContainer;
-exports.Module = Module;
-exports.Opts = Opts;
-exports.OverrideProvider = OverrideProvider;
-exports.Provider = Provider;
-exports.Scope = Scope;
-exports.Service = Service;
-exports.UndefinedTokenError = UndefinedTokenError;
-exports.UseOpts = UseOpts;
-exports.Value = Value;
-exports.createContainer = createContainer;
-exports.getConfiguration = getConfiguration;
-exports.registerController = registerController;
-exports.registerProvider = registerProvider;
-exports.registerValue = registerValue;
-exports.setLoggerLevel = setLoggerLevel;
-//# sourceMappingURL=index.js.map