@tsed/di 6.80.1 → 6.84.0

package/lib/decorators/index.d.ts

@@ -2,6 +2,7 @@ export * from "./scope";
 export * from "./service";
 export * from "./overrideProvider";
 export * from "./inject";
+export * from "./lazyInject";
 export * from "./injectable";
 export * from "./constant";
 export * from "./value";

package/lib/decorators/inject.d.ts

@@ -1,3 +1,5 @@
+import type { InjectablePropertyOptions } from "../interfaces/InjectableProperties";
+export declare function injectProperty(target: any, propertyKey: string, options: Partial<InjectablePropertyOptions>): void;
 /**
  * Inject a provider to another provider.
  *

package/lib/decorators/lazyInject.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @LazyInject("@tsed/platform-exceptions") // work if the module have a class exported with "default"
+ *   exceptions: Promise<PlatformException>;
+ * }
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @LazyInject(() => import("@tsed/platform-exceptions")) // use this notation is you use webpack
+ *   exceptions: Promise<PlatformException>;
+ * }
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @LazyInject(async () => (await import("@tsed/platform-exceptions")).PlatformException)
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param packageName
+ * @param resolver
+ * @param optional
+ * @returns {Function}
+ * @decorator
+ */
+export declare function LazyInject(resolver: () => any, optional?: boolean): PropertyDecorator;
+export declare function LazyInject(packageName: string, optional?: boolean): PropertyDecorator;
+/**
+ * Optionally Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @OptionalLazyInject("@tsed/platform-exceptions")
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param packageName
+ * @param resolver
+ * @returns {Function}
+ * @decorator
+ */
+export declare function OptionalLazyInject(resolver: () => any): PropertyDecorator;
+export declare function OptionalLazyInject(packageName: string): PropertyDecorator;

package/lib/index.js

@@ -2,11 +2,26 @@ var core = require('@tsed/core');
 var logger = require('@tsed/logger');
 var schema = require('@tsed/schema');
 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);
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+  n['default'] = e;
+  return n;
+}
 
 const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
 const DI_PARAMS = "DI:PARAMS";
@@ -631,7 +646,7 @@ class ContextLogger {
 
 }
 
-const _excluded$2 = ["id", "injector", "logger", "ignoreLog"];
+const _excluded$3 = ["id", "injector", "logger", "ignoreLog"];
 class DIContext extends Map {
   constructor(_ref) {
     let {
@@ -640,7 +655,7 @@ class DIContext extends Map {
       logger,
       ignoreLog
     } = _ref,
-        options = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+        options = _objectWithoutPropertiesLoose(_ref, _excluded$3);
 
     super();
     /**
@@ -901,6 +916,15 @@ function OverrideProvider(originalProvider) {
   };
 }
 
+const _excluded$2 = ["options"];
+function injectProperty(target, propertyKey, options) {
+  core.Store.from(target).merge(INJECTABLE_PROP, {
+    [propertyKey]: _extends({
+      bindingType: core.DecoratorTypes.PROP,
+      propertyKey
+    }, options)
+  });
+}
 /**
  * Inject a provider to another provider.
  *
@@ -920,7 +944,7 @@ function OverrideProvider(originalProvider) {
  * @decorator
  */
 
-function Inject(symbol, onGet) {
+function Inject(symbol, onGet = bean => bean) {
   return (target, propertyKey, descriptor) => {
     const bindingType = core.decoratorTypeOf([target, propertyKey, descriptor]);
 
@@ -936,13 +960,31 @@ function Inject(symbol, onGet) {
         break;
 
       case core.DecoratorTypes.PROP:
-        core.Store.from(target).merge(INJECTABLE_PROP, {
-          [propertyKey]: {
-            bindingType,
-            propertyKey,
-            onGet,
-            useType: symbol || core.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 || core.Metadata.getType(target, propertyKey);
+              bean = injector.invoke(useType, locals, invokeOptions);
+              locals.delete(DI_PARAM_OPTIONS);
+            }
+
+            if (core.isPromise(bean)) {
+              bean.then(result => {
+                bean = result;
+              });
+            }
+
+            return () => onGet(bean);
           }
+
         });
         break;
 
@@ -961,6 +1003,67 @@ function Inject(symbol, onGet) {
   };
 }
 
+function mapOptions$1(args) {
+  const options = args.reduce((options, item) => {
+    if (core.isString(item)) {
+      options.packageName = item;
+    } else if (core.isFunction(item)) {
+      options.resolver = item;
+    } else if (core.isBoolean(item)) {
+      options.optional = item;
+    }
+
+    return options;
+  }, {
+    optional: false
+  });
+
+  if (!options.packageName && options.resolver) {
+    options.packageName = options.resolver.toString();
+  }
+
+  if (!options.resolver) {
+    options.resolver = () => Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(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 core.importPackage(packageName, resolver, optional);
+            token = ((_token = token) == null ? void 0 : _token.default) || token;
+
+            if (token && core.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.
  *
@@ -1313,6 +1416,9 @@ function Controller(options) {
   }, path && schema.Path(path), schema.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(core.isString(origin) ? origin : "");
@@ -1359,7 +1465,7 @@ function printDependencyInjectionError(token, options) {
   const args = core.getConstructorArgNames(token).map((arg, index) => {
     if (options.index === index) {
       erroredArg = arg;
-      arg = chalk__default['default'].red(arg);
+      arg = red(arg);
     }
 
     return `${arg}: ${core.nameOf(options.deps[index])}`;
@@ -1367,7 +1473,7 @@ function printDependencyInjectionError(token, options) {
   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));
+  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) : "");
 }
@@ -1635,9 +1741,7 @@ exports.InjectorService = InjectorService_1 = class InjectorService extends Cont
 
 
   get(token, options = {}) {
-    var _super$get;
-
-    const instance = (_super$get = super.get(core.getClassOrSymbol(token))) == null ? void 0 : _super$get.instance;
+    const instance = this.getInstance(token);
 
     if (instance !== undefined) {
       return instance;
@@ -1894,7 +1998,7 @@ exports.InjectorService = InjectorService_1 = class InjectorService extends Cont
    * @param instance
    * @param {string} propertyKey
    * @param {any} useType
-   * @param onGet
+   * @param resolver
    * @param options
    * @param locals
    * @param invokeOptions
@@ -1903,23 +2007,15 @@ exports.InjectorService = InjectorService_1 = class InjectorService extends Cont
 
   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 (core.isPromise(bean)) {
-      bean.then(result => {
-        bean = result;
-      });
-    }
-
+    let get;
+    get = resolver(this, locals, _extends({}, invokeOptions, {
+      options
+    }));
     core.catchError(() => Object.defineProperty(instance, propertyKey, {
-      get: () => onGet(bean)
+      get
     }));
   }
   /**
@@ -2026,6 +2122,22 @@ exports.InjectorService = InjectorService_1 = class InjectorService extends Cont
     return cb();
   }
 
+  async lazyInvoke(token) {
+    let instance = this.getInstance(token);
+
+    if (!instance) {
+      var _instance;
+
+      instance = await this.invoke(token);
+
+      if (core.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);
@@ -2033,6 +2145,12 @@ exports.InjectorService = InjectorService_1 = class InjectorService extends Cont
 
     return this.getProvider(token);
   }
+
+  getInstance(token) {
+    var _super$get;
+
+    return (_super$get = super.get(core.getClassOrSymbol(token))) == null ? void 0 : _super$get.instance;
+  }
   /**
    * Invoke a class method and inject service.
    *
@@ -2339,8 +2457,10 @@ exports.Injectable = Injectable;
 exports.InjectionError = InjectionError;
 exports.Intercept = Intercept;
 exports.Interceptor = Interceptor;
+exports.LazyInject = LazyInject;
 exports.LocalsContainer = LocalsContainer;
 exports.Module = Module;
+exports.OptionalLazyInject = OptionalLazyInject;
 exports.Opts = Opts;
 exports.OverrideProvider = OverrideProvider;
 exports.Provider = Provider;
@@ -2351,6 +2471,7 @@ exports.UseOpts = UseOpts;
 exports.Value = Value;
 exports.createContainer = createContainer;
 exports.getConfiguration = getConfiguration;
+exports.injectProperty = injectProperty;
 exports.registerController = registerController;
 exports.registerFactory = registerFactory;
 exports.registerProvider = registerProvider;