@tsed/di 6.79.0 → 6.81.0

package/lib/index.modern.js

@@ -1,8 +1,7 @@
-import { getClassOrSymbol, Store, isClass, classOf, nameOf, StoreSet, decoratorTypeOf, UnsupportedDecoratorType, DecoratorTypes, Metadata, useDecorators, isArrayOrArrayClass, isString, getConstructorArgNames, proxyDelegation, setValue, getValue, deepMerge, deepClone, ancestorsOf, prototypeOf, isPromise, catchError, isInheritedFrom, isFunction, Env } from '@tsed/core';
+import { getClassOrSymbol, Store, isClass, classOf, nameOf, StoreSet, DecoratorTypes, decoratorTypeOf, UnsupportedDecoratorType, Metadata, isPromise, importPackage, isString, isFunction, isBoolean, useDecorators, isArrayOrArrayClass, getConstructorArgNames, proxyDelegation, setValue, getValue, deepMerge, deepClone, ancestorsOf, prototypeOf, catchError, isInheritedFrom, Env } from '@tsed/core';
 import { levels, Logger, $log } from '@tsed/logger';
 import { Path, Children } from '@tsed/schema';
 import { __decorate, __metadata } from 'tslib';
-import chalk from 'chalk';
 
 const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
 const DI_PARAMS = "DI:PARAMS";
@@ -627,7 +626,7 @@ class ContextLogger {
 
 }
 
-const _excluded$2 = ["id", "injector", "logger", "ignoreLog"];
+const _excluded$3 = ["id", "injector", "logger", "ignoreLog"];
 class DIContext extends Map {
   constructor(_ref) {
     let {
@@ -636,7 +635,7 @@ class DIContext extends Map {
       logger,
       ignoreLog
     } = _ref,
-        options = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+        options = _objectWithoutPropertiesLoose(_ref, _excluded$3);
 
     super();
     /**
@@ -897,6 +896,15 @@ function OverrideProvider(originalProvider) {
   };
 }
 
+const _excluded$2 = ["options"];
+function injectProperty(target, propertyKey, options) {
+  Store.from(target).merge(INJECTABLE_PROP, {
+    [propertyKey]: _extends({
+      bindingType: DecoratorTypes.PROP,
+      propertyKey
+    }, options)
+  });
+}
 /**
  * Inject a provider to another provider.
  *
@@ -916,7 +924,7 @@ function OverrideProvider(originalProvider) {
  * @decorator
  */
 
-function Inject(symbol, onGet) {
+function Inject(symbol, onGet = bean => bean) {
   return (target, propertyKey, descriptor) => {
     const bindingType = decoratorTypeOf([target, propertyKey, descriptor]);
 
@@ -932,13 +940,31 @@ function Inject(symbol, onGet) {
         break;
 
       case DecoratorTypes.PROP:
-        Store.from(target).merge(INJECTABLE_PROP, {
-          [propertyKey]: {
-            bindingType,
-            propertyKey,
-            onGet,
-            useType: symbol || Metadata.getType(target, propertyKey)
+        injectProperty(target, propertyKey, {
+          resolver(injector, locals, _ref) {
+            let {
+              options
+            } = _ref,
+                invokeOptions = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+
+            locals.set(DI_PARAM_OPTIONS, _extends({}, options));
+            let bean;
+
+            if (!bean) {
+              const useType = symbol || Metadata.getType(target, propertyKey);
+              bean = injector.invoke(useType, locals, invokeOptions);
+              locals.delete(DI_PARAM_OPTIONS);
+            }
+
+            if (isPromise(bean)) {
+              bean.then(result => {
+                bean = result;
+              });
+            }
+
+            return () => onGet(bean);
           }
+
         });
         break;
 
@@ -957,6 +983,67 @@ function Inject(symbol, onGet) {
   };
 }
 
+function mapOptions$1(args) {
+  const options = args.reduce((options, item) => {
+    if (isString(item)) {
+      options.packageName = item;
+    } else if (isFunction(item)) {
+      options.resolver = item;
+    } else if (isBoolean(item)) {
+      options.optional = item;
+    }
+
+    return options;
+  }, {
+    optional: false
+  });
+
+  if (!options.packageName && options.resolver) {
+    options.packageName = options.resolver.toString();
+  }
+
+  if (!options.resolver) {
+    options.resolver = () => import(options.packageName);
+  }
+
+  return options;
+}
+
+function LazyInject(...args) {
+  const {
+    packageName,
+    resolver,
+    optional
+  } = mapOptions$1(args);
+  return (target, propertyKey) => {
+    let bean, token;
+    injectProperty(target, propertyKey, {
+      resolver(injector) {
+        return async () => {
+          if (!token) {
+            var _token;
+
+            token = await importPackage(packageName, resolver, optional);
+            token = ((_token = token) == null ? void 0 : _token.default) || token;
+
+            if (token && classOf(token) === Object && !optional) {
+              throw new Error(`Unable to lazy load the "${packageName}". Resolved token isn\'t a valid provider.`);
+            }
+
+            bean = await injector.lazyInvoke(token);
+          }
+
+          return bean;
+        };
+      }
+
+    });
+  };
+}
+function OptionalLazyInject(arg) {
+  return LazyInject(arg, true);
+}
+
 /**
  * Return value from Configuration.
  *
@@ -1309,6 +1396,9 @@ function Controller(options) {
   }, path && Path(path), Children(...children));
 }
 
+const colorIfAllowed = colorFn => text => !process.env.NO_COLOR ? colorFn(text) : text;
+
+const red = colorIfAllowed(text => `\x1B[31m${text}\x1B[39m`);
 class InjectionError extends Error {
   constructor(token, origin) {
     super(isString(origin) ? origin : "");
@@ -1355,7 +1445,7 @@ function printDependencyInjectionError(token, options) {
   const args = getConstructorArgNames(token).map((arg, index) => {
     if (options.index === index) {
       erroredArg = arg;
-      arg = chalk.red(arg);
+      arg = red(arg);
     }
 
     return `${arg}: ${nameOf(options.deps[index])}`;
@@ -1363,7 +1453,7 @@ function printDependencyInjectionError(token, options) {
   const signature = nameOf(token) + "->constructor(" + args + ")";
   const indexOf = signature.indexOf(erroredArg) - 5;
 
-  const drawline = indexOf => " ".repeat(indexOf) + chalk.red("^" + "‾".repeat(erroredArg.length - 1));
+  const drawline = indexOf => " ".repeat(indexOf) + red("^" + "‾".repeat(erroredArg.length - 1));
 
   return "Unable to inject dependency. " + options.message + "\n\n" + signature + "\n" + (indexOf > -1 ? drawline(indexOf) : "");
 }
@@ -1631,9 +1721,7 @@ let InjectorService = InjectorService_1 = class InjectorService extends Containe
 
 
   get(token, options = {}) {
-    var _super$get;
-
-    const instance = (_super$get = super.get(getClassOrSymbol(token))) == null ? void 0 : _super$get.instance;
+    const instance = this.getInstance(token);
 
     if (instance !== undefined) {
       return instance;
@@ -1890,7 +1978,7 @@ let InjectorService = InjectorService_1 = class InjectorService extends Containe
    * @param instance
    * @param {string} propertyKey
    * @param {any} useType
-   * @param onGet
+   * @param resolver
    * @param options
    * @param locals
    * @param invokeOptions
@@ -1899,23 +1987,15 @@ let InjectorService = InjectorService_1 = class InjectorService extends Containe
 
   bindProperty(instance, {
     propertyKey,
-    useType,
-    onGet = f => f,
-    options
+    resolver,
+    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 (isPromise(bean)) {
-      bean.then(result => {
-        bean = result;
-      });
-    }
-
+    let get;
+    get = resolver(this, locals, _extends({}, invokeOptions, {
+      options
+    }));
     catchError(() => Object.defineProperty(instance, propertyKey, {
-      get: () => onGet(bean)
+      get
     }));
   }
   /**
@@ -2022,6 +2102,22 @@ let InjectorService = InjectorService_1 = class InjectorService extends Containe
     return cb();
   }
 
+  async lazyInvoke(token) {
+    let instance = this.getInstance(token);
+
+    if (!instance) {
+      var _instance;
+
+      instance = await this.invoke(token);
+
+      if (isFunction((_instance = instance) == null ? void 0 : _instance.$onInit)) {
+        await instance.$onInit();
+      }
+    }
+
+    return instance;
+  }
+
   ensureProvider(token) {
     if (!this.hasProvider(token) && GlobalProviders.has(token)) {
       this.addProvider(token);
@@ -2029,6 +2125,12 @@ let InjectorService = InjectorService_1 = class InjectorService extends Containe
 
     return this.getProvider(token);
   }
+
+  getInstance(token) {
+    var _super$get;
+
+    return (_super$get = super.get(getClassOrSymbol(token))) == null ? void 0 : _super$get.instance;
+  }
   /**
    * Invoke a class method and inject service.
    *
@@ -2317,5 +2419,5 @@ function getConfiguration(module, configuration = {}) {
   return config;
 }
 
-export { Configuration, Constant, Container, ContextLogger, Controller, DIConfiguration, DIContext, DITest, DI_PARAMS, DI_PARAM_OPTIONS, GlobalProviderRegistry, GlobalProviders, INJECTABLE_PROP, Inject, Injectable, InjectablePropertyType, InjectionError, InjectorService, Intercept, Interceptor, LocalsContainer, Module, Opts, OverrideProvider, Provider, ProviderScope, ProviderType, Scope, Service, UndefinedTokenError, UseOpts, Value, createContainer, getConfiguration, registerController, registerFactory, registerProvider, registerValue, setLoggerLevel };
+export { Configuration, Constant, Container, ContextLogger, Controller, DIConfiguration, DIContext, DITest, DI_PARAMS, DI_PARAM_OPTIONS, GlobalProviderRegistry, GlobalProviders, INJECTABLE_PROP, Inject, Injectable, InjectablePropertyType, InjectionError, InjectorService, Intercept, Interceptor, LazyInject, LocalsContainer, Module, OptionalLazyInject, Opts, OverrideProvider, Provider, ProviderScope, ProviderType, Scope, Service, UndefinedTokenError, UseOpts, Value, createContainer, getConfiguration, injectProperty, registerController, registerFactory, registerProvider, registerValue, setLoggerLevel };
 //# sourceMappingURL=index.modern.js.map