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

package/lib/cjs/utils/createContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createContainer.js","sourceRoot":"","sources":["../../../src/utils/createContainer.ts"],"names":[],"mappings":";;;AACA,mDAA8C;AAC9C,mEAA8D;AAE9D,SAAgB,eAAe,CAAC,UAAsB;IACpD,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC,iCAAe,CAAC,OAAO,EAAE,CAAC,CAAC;IAE3D,IAAI,UAAU,EAAE;QACd,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;KAC9B;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AARD,0CAQC","sourcesContent":["import {Type} from \"@tsed/core\";\nimport {Container} from \"../domain/Container\";\nimport {GlobalProviders} from \"../registries/GlobalProviders\";\n\nexport function createContainer(rootModule?: Type<any>) {\n  const container = new Container(GlobalProviders.entries());\n\n  if (rootModule) {\n    container.delete(rootModule);\n  }\n\n  return container;\n}\n"]}

package/lib/cjs/utils/getConfiguration.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfiguration = void 0;
+const core_1 = require("@tsed/core");
+function getConfiguration(module, configuration = {}) {
+    const store = core_1.Store.from(module).get("configuration") || {};
+    const config = {
+        ...store,
+        ...configuration
+    };
+    if (store.mount && configuration.mount) {
+        config.mount = (0, core_1.deepMerge)(store.mount, configuration.mount);
+    }
+    if (store.componentsScan && configuration.componentsScan) {
+        config.componentsScan = [...store.componentsScan, ...configuration.componentsScan];
+    }
+    return config;
+}
+exports.getConfiguration = getConfiguration;
+//# sourceMappingURL=getConfiguration.js.map

package/lib/cjs/utils/getConfiguration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConfiguration.js","sourceRoot":"","sources":["../../../src/utils/getConfiguration.ts"],"names":[],"mappings":";;;AAAA,qCAAkD;AAElD,SAAgB,gBAAgB,CAAC,MAAiB,EAAE,gBAAqB,EAAE;IACzE,MAAM,KAAK,GAAG,YAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAE5D,MAAM,MAAM,GAAG;QACb,GAAG,KAAK;QACR,GAAG,aAAa;KACjB,CAAC;IAEF,IAAI,KAAK,CAAC,KAAK,IAAI,aAAa,CAAC,KAAK,EAAE;QACtC,MAAM,CAAC,KAAK,GAAG,IAAA,gBAAS,EAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KAC5D;IAED,IAAI,KAAK,CAAC,cAAc,IAAI,aAAa,CAAC,cAAc,EAAE;QACxD,MAAM,CAAC,cAAc,GAAG,CAAC,GAAG,KAAK,CAAC,cAAc,EAAE,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;KACpF;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAjBD,4CAiBC","sourcesContent":["import {deepMerge, Store, Type} from \"@tsed/core\";\n\nexport function getConfiguration(module: Type<any>, configuration: any = {}) {\n  const store = Store.from(module).get(\"configuration\") || {};\n\n  const config = {\n    ...store,\n    ...configuration\n  };\n\n  if (store.mount && configuration.mount) {\n    config.mount = deepMerge(store.mount, configuration.mount);\n  }\n\n  if (store.componentsScan && configuration.componentsScan) {\n    config.componentsScan = [...store.componentsScan, ...configuration.componentsScan];\n  }\n\n  return config;\n}\n"]}

package/lib/cjs/utils/runInContext.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInContext = exports.getContext = exports.getAsyncStore = void 0;
+const async_hooks_1 = require("async_hooks");
+let store;
+function getAsyncStore() {
+    store = store || new async_hooks_1.AsyncLocalStorage();
+    return store;
+}
+exports.getAsyncStore = getAsyncStore;
+function getContext() {
+    return store === null || store === void 0 ? void 0 : store.getStore();
+}
+exports.getContext = getContext;
+function runInContext(ctx, cb) {
+    return getAsyncStore().run(ctx, cb);
+}
+exports.runInContext = runInContext;
+//# sourceMappingURL=runInContext.js.map

package/lib/cjs/utils/runInContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runInContext.js","sourceRoot":"","sources":["../../../src/utils/runInContext.ts"],"names":[],"mappings":";;;AAAA,6CAA8C;AAG9C,IAAI,KAAmC,CAAC;AAExC,SAAgB,aAAa;IAC3B,KAAK,GAAG,KAAK,IAAI,IAAI,+BAAiB,EAAE,CAAC;IACzC,OAAO,KAAK,CAAC;AACf,CAAC;AAHD,sCAGC;AAED,SAAgB,UAAU;IACxB,OAAO,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,EAAE,CAAC;AAC3B,CAAC;AAFD,gCAEC;AAED,SAAgB,YAAY,CAAC,GAAc,EAAE,EAAO;IAClD,OAAO,aAAa,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AACtC,CAAC;AAFD,oCAEC","sourcesContent":["import {AsyncLocalStorage} from \"async_hooks\";\nimport {DIContext} from \"../domain/DIContext\";\n\nlet store: AsyncLocalStorage<DIContext>;\n\nexport function getAsyncStore() {\n  store = store || new AsyncLocalStorage();\n  return store;\n}\n\nexport function getContext() {\n  return store?.getStore();\n}\n\nexport function runInContext(ctx: DIContext, cb: any) {\n  return getAsyncStore().run(ctx, cb);\n}\n"]}

package/lib/cjs/utils/setLoggerLevel.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLoggerLevel = void 0;
+/**
+ * @ignore
+ * @param injector
+ */
+function setLoggerLevel(injector) {
+    var _a;
+    const level = (_a = injector.settings.logger) === null || _a === void 0 ? void 0 : _a.level;
+    if (level) {
+        injector.logger.level = level;
+    }
+}
+exports.setLoggerLevel = setLoggerLevel;
+//# sourceMappingURL=setLoggerLevel.js.map

package/lib/cjs/utils/setLoggerLevel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setLoggerLevel.js","sourceRoot":"","sources":["../../../src/utils/setLoggerLevel.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACH,SAAgB,cAAc,CAAC,QAAyB;;IACtD,MAAM,KAAK,GAAG,MAAA,QAAQ,CAAC,QAAQ,CAAC,MAAM,0CAAE,KAAK,CAAC;IAE9C,IAAI,KAAK,EAAE;QACT,QAAQ,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;KAC/B;AACH,CAAC;AAND,wCAMC","sourcesContent":["import {InjectorService} from \"../services/InjectorService\";\n\n/**\n * @ignore\n * @param injector\n */\nexport function setLoggerLevel(injector: InjectorService) {\n  const level = injector.settings.logger?.level;\n\n  if (level) {\n    injector.logger.level = level;\n  }\n}\n"]}

package/lib/esm/constants/constants.js

@@ -0,0 +1,4 @@
+export const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
+export const DI_PARAMS = "DI:PARAMS";
+export const DI_PARAM_OPTIONS = "DI:PARAM:OPTIONS";
+//# sourceMappingURL=constants.js.map

package/lib/esm/constants/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/constants/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG,oBAAoB,CAAC;AACpD,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC;AACrC,MAAM,CAAC,MAAM,gBAAgB,GAAG,kBAAkB,CAAC","sourcesContent":["export const INJECTABLE_PROP = \"DI:INJECTABLE_PROP\";\nexport const DI_PARAMS = \"DI:PARAMS\";\nexport const DI_PARAM_OPTIONS = \"DI:PARAM:OPTIONS\";\n"]}

package/lib/esm/decorators/configuration.js

@@ -0,0 +1,20 @@
+import { decoratorTypeOf, DecoratorTypes, StoreSet } from "@tsed/core";
+import { Inject } from "../decorators/inject.js";
+/**
+ * Get or set Configuration on a class.
+ *
+ * @decorator
+ */
+export function Configuration(configuration = {}) {
+    return (...args) => {
+        switch (decoratorTypeOf(args)) {
+            case DecoratorTypes.CLASS:
+                StoreSet("configuration", configuration)(args[0]);
+                break;
+            default:
+            case DecoratorTypes.PARAM_CTOR:
+                return Inject(Configuration)(args[0], args[1], args[2]);
+        }
+    };
+}
+//# sourceMappingURL=configuration.js.map

package/lib/esm/decorators/configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../src/decorators/configuration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,eAAe,EAAE,cAAc,EAAE,QAAQ,EAAC,MAAM,YAAY,CAAC;AAC1F,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAG5C;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,gBAA6C,EAAE;IAC3E,OAAO,CAAC,GAAG,IAAyB,EAAE,EAAE;QACtC,QAAQ,eAAe,CAAC,IAAI,CAAC,EAAE;YAC7B,KAAK,cAAc,CAAC,KAAK;gBACvB,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBAElD,MAAM;YACR,QAAQ;YACR,KAAK,cAAc,CAAC,UAAU;gBAC5B,OAAO,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAW,CAAC,CAAC;SACrE;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {DecoratorParameters, decoratorTypeOf, DecoratorTypes, StoreSet} from \"@tsed/core\";\nimport {Inject} from \"../decorators/inject\";\nimport {DIConfiguration} from \"../services/DIConfiguration\";\n\n/**\n * Get or set Configuration on a class.\n *\n * @decorator\n */\nexport function Configuration(configuration: Partial<TsED.Configuration> = {}): Function {\n  return (...args: DecoratorParameters) => {\n    switch (decoratorTypeOf(args)) {\n      case DecoratorTypes.CLASS:\n        StoreSet(\"configuration\", configuration)(args[0]);\n\n        break;\n      default:\n      case DecoratorTypes.PARAM_CTOR:\n        return Inject(Configuration)(args[0], args[1], args[2] as number);\n    }\n  };\n}\n\nexport type Configuration = TsED.Configuration & DIConfiguration;\n"]}

package/lib/esm/decorators/constant.js

@@ -0,0 +1,51 @@
+import { Store } from "@tsed/core";
+import { INJECTABLE_PROP } from "../constants/constants.js";
+import { InjectablePropertyType } from "../domain/InjectablePropertyType.js";
+/**
+ * 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
+ */
+export function Constant(expression, defaultValue) {
+    return (target, propertyKey) => {
+        Store.from(target).merge(INJECTABLE_PROP, {
+            [propertyKey]: {
+                bindingType: InjectablePropertyType.CONSTANT,
+                propertyKey,
+                expression,
+                defaultValue
+            }
+        });
+    };
+}
+//# sourceMappingURL=constant.js.map

package/lib/esm/decorators/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../../src/decorators/constant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAC,sBAAsB,EAAC,MAAM,kCAAkC,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,QAAQ,CAAC,UAAkB,EAAE,YAAkB;IAC7D,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,EAAE;QAC1C,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,eAAe,EAAE;YACxC,CAAC,WAAW,CAAC,EAAE;gBACb,WAAW,EAAE,sBAAsB,CAAC,QAAQ;gBAC5C,WAAW;gBACX,UAAU;gBACV,YAAY;aACb;SACsB,CAAC,CAAC;IAC7B,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store} from \"@tsed/core\";\nimport {INJECTABLE_PROP} from \"../constants/constants\";\nimport type {InjectableProperties} from \"../interfaces/InjectableProperties\";\nimport {InjectablePropertyType} from \"../domain/InjectablePropertyType\";\n\n/**\n * Return value from Configuration.\n *\n * ## Example\n *\n * ```typescript\n * import {Env} from \"@tsed/core\";\n * import {Constant, Value} from \"@tsed/di\";\n *\n * export class MyClass {\n *\n *    @Constant(\"env\")\n *    env: Env;\n *\n *    @Value(\"swagger.path\")\n *    swaggerPath: string;\n *\n *    @Value(\"swagger.path\", \"defaultValue\")\n *    swaggerPath: string;\n *\n *    constructor() {\n *       console.log(this.swaggerPath) // undefined. Not available on constructor\n *    }\n *\n *    $onInit() {\n *      console.log(this.swaggerPath)  // something\n *    }\n * }\n * ```\n *\n * @param {string} expression\n * @param defaultValue\n * @returns {(targetClass: any, attributeName: string) => any}\n * @decorator\n */\nexport function Constant(expression: string, defaultValue?: any): any {\n  return (target: any, propertyKey: string) => {\n    Store.from(target).merge(INJECTABLE_PROP, {\n      [propertyKey]: {\n        bindingType: InjectablePropertyType.CONSTANT,\n        propertyKey,\n        expression,\n        defaultValue\n      }\n    } as InjectableProperties);\n  };\n}\n"]}

package/lib/esm/decorators/controller.js

@@ -0,0 +1,49 @@
+import { isArrayOrArrayClass, useDecorators } from "@tsed/core";
+import { Children, Path } from "@tsed/schema";
+import { registerController } from "../registries/ProviderRegistry.js";
+function mapOptions(options) {
+    if (typeof options === "string" || options instanceof RegExp || 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
+ */
+export function Controller(options) {
+    const { children = [], path, ...opts } = mapOptions(options);
+    return useDecorators((target) => {
+        registerController({
+            provide: target,
+            ...opts
+        });
+    }, path && Path(path), Children(...children));
+}
+//# sourceMappingURL=controller.js.map

package/lib/esm/decorators/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/decorators/controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAQ,aAAa,EAAC,MAAM,YAAY,CAAC;AACpE,OAAO,EAAC,QAAQ,EAAE,IAAI,EAAC,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAiBlE,SAAS,UAAU,CAAC,OAAY;IAC9B,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,YAAY,MAAM,IAAI,mBAAmB,CAAC,OAAO,CAAC,EAAE;QAC5F,OAAO;YACL,IAAI,EAAE,OAAO;SACd,CAAC;KACH;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,UAAU,CAAC,OAAqC;IAC9D,MAAM,EAAC,QAAQ,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,IAAI,EAAC,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IAE3D,OAAO,aAAa,CAClB,CAAC,MAAY,EAAE,EAAE;QACf,kBAAkB,CAAC;YACjB,OAAO,EAAE,MAAM;YACf,GAAG,IAAI;SACR,CAAC,CAAC;IACL,CAAC,EACD,IAAI,IAAI,IAAI,CAAC,IAAW,CAAC,EACzB,QAAQ,CAAC,GAAG,QAAQ,CAAC,CACtB,CAAC;AACJ,CAAC","sourcesContent":["import {isArrayOrArrayClass, Type, useDecorators} from \"@tsed/core\";\nimport {Children, Path} from \"@tsed/schema\";\nimport {ProviderOpts} from \"../interfaces/ProviderOpts\";\nimport {registerController} from \"../registries/ProviderRegistry\";\n\nexport type PathType = string | RegExp | (string | RegExp)[];\n\nexport interface ControllerMiddlewares {\n  useBefore: any[];\n  use: any[];\n  useAfter: any[];\n}\n\nexport interface ControllerOptions extends Partial<ProviderOpts<any>> {\n  path?: PathType;\n  children?: Type<any>[];\n  routerOptions?: any;\n  middlewares?: Partial<ControllerMiddlewares>;\n}\n\nfunction mapOptions(options: any): ControllerOptions {\n  if (typeof options === \"string\" || options instanceof RegExp || isArrayOrArrayClass(options)) {\n    return {\n      path: options\n    };\n  }\n\n  return options;\n}\n\n/**\n * Declare a new controller with his Rest path. His methods annotated will be collected to build the routing list.\n * This routing listing will be built with the `express.Router` object.\n *\n * ::: tip\n * See [Controllers](/docs/controllers.md) section for more details\n * :::\n *\n * ```typescript\n *  @Controller(\"/calendars\")\n *  export provide CalendarCtrl {\n *\n *    @Get(\"/:id\")\n *    public get(\n *      @Req() request: Req,\n *      @Res() response: Res,\n *      @Next() next: Next\n *    ): void {\n *\n *    }\n *  }\n * ```\n *\n * @param options\n * @controller\n * @decorator\n * @classDecorator\n */\nexport function Controller(options: PathType | ControllerOptions): ClassDecorator {\n  const {children = [], path, ...opts} = mapOptions(options);\n\n  return useDecorators(\n    (target: Type) => {\n      registerController({\n        provide: target,\n        ...opts\n      });\n    },\n    path && Path(path as any),\n    Children(...children)\n  );\n}\n"]}

package/lib/esm/decorators/inject.js

@@ -0,0 +1,98 @@
+import { decoratorTypeOf, DecoratorTypes, isPromise, Metadata, Store, UnsupportedDecoratorType } from "@tsed/core";
+import { DI_PARAM_OPTIONS, INJECTABLE_PROP } from "../constants/constants.js";
+import { getContext } from "../utils/runInContext.js";
+export function injectProperty(target, propertyKey, options) {
+    Store.from(target).merge(INJECTABLE_PROP, {
+        [propertyKey]: {
+            bindingType: DecoratorTypes.PROP,
+            propertyKey,
+            ...options
+        }
+    });
+}
+/**
+ * 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
+ */
+export function Inject(symbol, onGet = (bean) => bean) {
+    return (target, propertyKey, descriptor) => {
+        const bindingType = decoratorTypeOf([target, propertyKey, descriptor]);
+        switch (bindingType) {
+            case DecoratorTypes.PARAM:
+            case DecoratorTypes.PARAM_CTOR:
+                if (symbol) {
+                    const paramTypes = Metadata.getParamTypes(target, propertyKey);
+                    paramTypes[descriptor] = symbol;
+                    Metadata.setParamTypes(target, propertyKey, paramTypes);
+                }
+                break;
+            case DecoratorTypes.PROP:
+                injectProperty(target, propertyKey, {
+                    resolver(injector, locals, { options, ...invokeOptions }) {
+                        locals.set(DI_PARAM_OPTIONS, { ...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;
+            case DecoratorTypes.METHOD:
+                Store.from(target).merge(INJECTABLE_PROP, {
+                    [propertyKey]: {
+                        bindingType,
+                        propertyKey
+                    }
+                });
+                return descriptor;
+            default:
+                throw new UnsupportedDecoratorType(Inject, [target, propertyKey, descriptor]);
+        }
+    };
+}
+/**
+ * Inject a context like PlatformContext or any BaseContext.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   @InjectContext()
+ *   ctx?: Context;
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export function InjectContext() {
+    return (target, propertyKey) => {
+        injectProperty(target, propertyKey, {
+            resolver() {
+                return () => getContext();
+            }
+        });
+    };
+}
+//# sourceMappingURL=inject.js.map

package/lib/esm/decorators/inject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.js","sourceRoot":"","sources":["../../../src/decorators/inject.ts"],"names":[],"mappings":"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","sourcesContent":["import {decoratorTypeOf, DecoratorTypes, isPromise, Metadata, Store, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {DI_PARAM_OPTIONS, INJECTABLE_PROP} from \"../constants/constants\";\nimport type {InjectablePropertyOptions} from \"../interfaces/InjectableProperties\";\nimport {getContext} from \"../utils/runInContext\";\n\nexport function injectProperty(target: any, propertyKey: string, options: Partial<InjectablePropertyOptions>) {\n  Store.from(target).merge(INJECTABLE_PROP, {\n    [propertyKey]: {\n      bindingType: DecoratorTypes.PROP,\n      propertyKey,\n      ...options\n    }\n  });\n}\n\n/**\n * Inject a provider to another provider.\n *\n * Use this decorator to inject a custom provider on constructor parameter or property.\n *\n * ```typescript\n * @Injectable()\n * export class MyService {\n *   @Inject(CONNECTION)\n *   connection: CONNECTION;\n * }\n * ```\n *\n * @param symbol\n * @param onGet Use the given name method to inject\n * @returns {Function}\n * @decorator\n */\nexport function Inject(symbol?: any, onGet = (bean: any) => bean): Function {\n  return (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<Function> | number): any | void => {\n    const bindingType = decoratorTypeOf([target, propertyKey, descriptor]);\n\n    switch (bindingType) {\n      case DecoratorTypes.PARAM:\n      case DecoratorTypes.PARAM_CTOR:\n        if (symbol) {\n          const paramTypes = Metadata.getParamTypes(target, propertyKey);\n\n          paramTypes[descriptor as number] = symbol;\n          Metadata.setParamTypes(target, propertyKey, paramTypes);\n        }\n        break;\n\n      case DecoratorTypes.PROP:\n        injectProperty(target, propertyKey, {\n          resolver(injector, locals, {options, ...invokeOptions}) {\n            locals.set(DI_PARAM_OPTIONS, {...options});\n\n            let bean: any;\n\n            if (!bean) {\n              const useType = symbol || Metadata.getType(target, propertyKey);\n              bean = injector.invoke(useType, locals, invokeOptions);\n              locals.delete(DI_PARAM_OPTIONS);\n            }\n\n            if (isPromise(bean)) {\n              bean.then((result: any) => {\n                bean = result;\n              });\n            }\n\n            return () => onGet(bean);\n          }\n        });\n        break;\n\n      case DecoratorTypes.METHOD:\n        Store.from(target).merge(INJECTABLE_PROP, {\n          [propertyKey]: {\n            bindingType,\n            propertyKey\n          }\n        });\n\n        return descriptor;\n\n      default:\n        throw new UnsupportedDecoratorType(Inject, [target, propertyKey, descriptor]);\n    }\n  };\n}\n\n/**\n * Inject a context like PlatformContext or any BaseContext.\n *\n * ```typescript\n * @Injectable()\n * export class MyService {\n *   @InjectContext()\n *   ctx?: Context;\n * }\n * ```\n *\n * @returns {Function}\n * @decorator\n */\nexport function InjectContext(): PropertyDecorator {\n  return (target: any, propertyKey: string): any | void => {\n    injectProperty(target, propertyKey, {\n      resolver() {\n        return () => getContext();\n      }\n    });\n  };\n}\n"]}

package/lib/esm/decorators/injectable.js

@@ -0,0 +1,28 @@
+import { registerProvider } from "../registries/ProviderRegistry.js";
+/**
+ * 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.
+ *
+ * ::: 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`)
+ * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
+ * - 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
+ */
+export function Injectable(options = {}) {
+    return (target) => {
+        registerProvider({
+            ...options,
+            ...(options.provide ? { useClass: target } : { provide: target })
+        });
+    };
+}
+//# sourceMappingURL=injectable.js.map

package/lib/esm/decorators/injectable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable.js","sourceRoot":"","sources":["../../../src/decorators/injectable.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAC;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CAAC,UAAiC,EAAE;IAC5D,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,gBAAgB,CAAC;YACf,GAAG,OAAO;YACV,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,MAAM,EAAC,CAAC;SAC9D,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type {ProviderOpts} from \"../interfaces/ProviderOpts\";\nimport {registerProvider} from \"../registries/ProviderRegistry\";\n\n/**\n * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.\n * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.\n *\n * ::: tip\n * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.\n * :::\n *\n * ### Options\n *\n * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)\n * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)\n * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).\n * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).\n *\n * @returns {Function}\n * @decorator\n */\nexport function Injectable(options: Partial<ProviderOpts> = {}): ClassDecorator {\n  return (target: any) => {\n    registerProvider({\n      ...options,\n      ...(options.provide ? {useClass: target} : {provide: target})\n    });\n  };\n}\n"]}

package/lib/esm/decorators/intercept.js

@@ -0,0 +1,32 @@
+import { decorateMethodsOf, decoratorTypeOf, DecoratorTypes, Store } from "@tsed/core";
+import { INJECTABLE_PROP } from "../constants/constants.js";
+import { InjectablePropertyType } from "../domain/InjectablePropertyType.js";
+/**
+ * Attaches interceptor to method call and executes the before and after methods
+ *
+ * @param interceptor
+ * @param options
+ * @decorator
+ */
+export function Intercept(interceptor, options) {
+    return (...args) => {
+        const [target, propertyKey, descriptor] = args;
+        const type = decoratorTypeOf(args);
+        switch (type) {
+            case DecoratorTypes.CLASS:
+                decorateMethodsOf(target, Intercept(interceptor, options));
+                break;
+            case DecoratorTypes.METHOD:
+                Store.from(target).merge(INJECTABLE_PROP, {
+                    [propertyKey]: {
+                        options,
+                        propertyKey,
+                        useType: interceptor,
+                        bindingType: InjectablePropertyType.INTERCEPTOR
+                    }
+                });
+                return descriptor;
+        }
+    };
+}
+//# sourceMappingURL=intercept.js.map

package/lib/esm/decorators/intercept.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intercept.js","sourceRoot":"","sources":["../../../src/decorators/intercept.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAuB,eAAe,EAAE,cAAc,EAAE,KAAK,EAAO,MAAM,YAAY,CAAC;AAChH,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAC,sBAAsB,EAAC,MAAM,kCAAkC,CAAC;AAIxE;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAA+B,WAAoB,EAAE,OAAa;IACzF,OAAO,CAAC,GAAG,IAAyB,EAAE,EAAE;QACtC,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC;QAC/C,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACnC,QAAQ,IAAI,EAAE;YACZ,KAAK,cAAc,CAAC,KAAK;gBACvB,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;gBAC3D,MAAM;YACR,KAAK,cAAc,CAAC,MAAM;gBACxB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,eAAe,EAAE;oBACxC,CAAC,WAAW,CAAC,EAAE;wBACb,OAAO;wBACP,WAAW;wBACX,OAAO,EAAE,WAAW;wBACpB,WAAW,EAAE,sBAAsB,CAAC,WAAW;qBAChD;iBACsB,CAAC,CAAC;gBAE3B,OAAO,UAAU,CAAC;SACrB;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {decorateMethodsOf, DecoratorParameters, decoratorTypeOf, DecoratorTypes, Store, Type} from \"@tsed/core\";\nimport {INJECTABLE_PROP} from \"../constants/constants\";\nimport {InjectablePropertyType} from \"../domain/InjectablePropertyType\";\nimport type {InterceptorMethods} from \"../interfaces/InterceptorMethods\";\nimport type {InjectableProperties} from \"../interfaces/InjectableProperties\";\n\n/**\n * Attaches interceptor to method call and executes the before and after methods\n *\n * @param interceptor\n * @param options\n * @decorator\n */\nexport function Intercept<T extends InterceptorMethods>(interceptor: Type<T>, options?: any): any {\n  return (...args: DecoratorParameters) => {\n    const [target, propertyKey, descriptor] = args;\n    const type = decoratorTypeOf(args);\n    switch (type) {\n      case DecoratorTypes.CLASS:\n        decorateMethodsOf(target, Intercept(interceptor, options));\n        break;\n      case DecoratorTypes.METHOD:\n        Store.from(target).merge(INJECTABLE_PROP, {\n          [propertyKey]: {\n            options,\n            propertyKey,\n            useType: interceptor,\n            bindingType: InjectablePropertyType.INTERCEPTOR\n          }\n        } as InjectableProperties);\n\n        return descriptor;\n    }\n  };\n}\n"]}

package/lib/esm/decorators/interceptor.js

@@ -0,0 +1,17 @@
+import { ProviderType } from "../domain/ProviderType.js";
+import { Injectable } from "./injectable.js";
+/**
+ * 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
+ */
+export function Interceptor() {
+    return Injectable({
+        type: ProviderType.INTERCEPTOR
+    });
+}
+//# sourceMappingURL=interceptor.js.map

package/lib/esm/decorators/interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../src/decorators/interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,UAAU,CAAC;QAChB,IAAI,EAAE,YAAY,CAAC,WAAW;KAC/B,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {ProviderType} from \"../domain/ProviderType\";\nimport {Injectable} from \"./injectable\";\n\n/**\n * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.\n * All services annotated with `@Service()` are constructed one time.\n *\n * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.\n *\n * @returns {Function}\n * @decorator\n */\nexport function Interceptor(): Function {\n  return Injectable({\n    type: ProviderType.INTERCEPTOR\n  });\n}\n"]}

package/lib/esm/decorators/lazyInject.js

@@ -0,0 +1,66 @@
+import { importPackage } from "@tsed/core";
+import { injectProperty } from "./inject.js";
+/**
+ * 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("PlatformException", () => import("@tsed/platform-exceptions"))
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param key
+ * @param packageName
+ * @param resolver
+ * @param optional
+ * @returns {Function}
+ * @decorator
+ */
+export function LazyInject(key, resolver, { optional = false, packageName = resolver.toString() } = {}) {
+    return (target, propertyKey) => {
+        let bean, token;
+        injectProperty(target, propertyKey, {
+            resolver(injector) {
+                return async () => {
+                    if (!token) {
+                        const exports = await importPackage(packageName, resolver, optional);
+                        token = exports[key];
+                        if (!token) {
+                            if (!optional) {
+                                throw new Error(`Unable to lazy load the "${key}". The token isn\'t a valid token provider.`);
+                            }
+                        }
+                        bean = token ? await injector.lazyInvoke(token) : {};
+                    }
+                    return bean;
+                };
+            }
+        });
+    };
+}
+/**
+ * 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 key
+ * @param resolver
+ * @returns {Function}
+ * @decorator
+ */
+export function OptionalLazyInject(key, resolver) {
+    return LazyInject(key, resolver, { optional: true });
+}
+//# sourceMappingURL=lazyInject.js.map

package/lib/esm/decorators/lazyInject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyInject.js","sourceRoot":"","sources":["../../../src/decorators/lazyInject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AACzC,OAAO,EAAC,cAAc,EAAC,MAAM,UAAU,CAAC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,UAAU,CACxB,GAAW,EACX,QAAmB,EACnB,EAAC,QAAQ,GAAG,KAAK,EAAE,WAAW,GAAG,QAAQ,CAAC,QAAQ,EAAE,KAAgD,EAAE;IAEtG,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAc,EAAE;QACtD,IAAI,IAAS,EAAE,KAAU,CAAC;QAC1B,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YAClC,QAAQ,CAAC,QAAQ;gBACf,OAAO,KAAK,IAAI,EAAE;oBAChB,IAAI,CAAC,KAAK,EAAE;wBACV,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBACrE,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;wBAErB,IAAI,CAAC,KAAK,EAAE;4BACV,IAAI,CAAC,QAAQ,EAAE;gCACb,MAAM,IAAI,KAAK,CAAC,4BAA4B,GAAG,6CAA6C,CAAC,CAAC;6BAC/F;yBACF;wBAED,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;qBACtD;oBAED,OAAO,IAAI,CAAC;gBACd,CAAC,CAAC;YACJ,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW,EAAE,QAAmB;IACjE,OAAQ,UAAkB,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;AAC9D,CAAC","sourcesContent":["import {importPackage} from \"@tsed/core\";\nimport {injectProperty} from \"./inject\";\n\n/**\n * Lazy load a provider from his package and invoke only when the provider is used\n *\n * ```typescript\n * import type {PlatformException} from \"@tsed/platform-exceptions\";\n *\n * @Injectable()\n * export class MyService {\n *   @LazyInject(\"PlatformException\", () => import(\"@tsed/platform-exceptions\"))\n *   exceptions: Promise<PlatformException>;\n * }\n * ```\n *\n * @param key\n * @param packageName\n * @param resolver\n * @param optional\n * @returns {Function}\n * @decorator\n */\nexport function LazyInject(\n  key: string,\n  resolver: () => any,\n  {optional = false, packageName = resolver.toString()}: {optional?: boolean; packageName?: string} = {}\n): PropertyDecorator {\n  return (target: any, propertyKey: string): any | void => {\n    let bean: any, token: any;\n    injectProperty(target, propertyKey, {\n      resolver(injector) {\n        return async () => {\n          if (!token) {\n            const exports = await importPackage(packageName, resolver, optional);\n            token = exports[key];\n\n            if (!token) {\n              if (!optional) {\n                throw new Error(`Unable to lazy load the \"${key}\". The token isn\\'t a valid token provider.`);\n              }\n            }\n\n            bean = token ? await injector.lazyInvoke(token) : {};\n          }\n\n          return bean;\n        };\n      }\n    });\n  };\n}\n\n/**\n * Optionally Lazy load a provider from his package and invoke only when the provider is used\n *\n * ```typescript\n * import type {PlatformException} from \"@tsed/platform-exceptions\";\n *\n * @Injectable()\n * export class MyService {\n *   @OptionalLazyInject(\"@tsed/platform-exceptions\")\n *   exceptions: Promise<PlatformException>;\n * }\n * ```\n *\n * @param key\n * @param resolver\n * @returns {Function}\n * @decorator\n */\nexport function OptionalLazyInject(key: string, resolver: () => any): PropertyDecorator {\n  return (LazyInject as any)(key, resolver, {optional: true});\n}\n"]}

package/lib/esm/decorators/module.js

@@ -0,0 +1,28 @@
+import { useDecorators } from "@tsed/core";
+import { ProviderScope } from "../domain/ProviderScope.js";
+import { Configuration } from "./configuration.js";
+import { Injectable } from "./injectable.js";
+import { ProviderType } from "../domain/ProviderType.js";
+/**
+ * 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
+ */
+export function Module(options = {}) {
+    const { scopes, imports, resolvers, deps, scope, ...configuration } = options;
+    return useDecorators(Configuration(configuration), Injectable({
+        type: ProviderType.MODULE,
+        scope: ProviderScope.SINGLETON,
+        imports,
+        deps,
+        injectable: false,
+        resolvers
+    }));
+}
+//# sourceMappingURL=module.js.map

package/lib/esm/decorators/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../src/decorators/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AACzC,OAAO,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AA2BpD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,MAAM,CAAC,UAAkC,EAAE;IACzD,MAAM,EAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,aAAa,EAAC,GAAG,OAAO,CAAC;IAE5E,OAAO,aAAa,CAClB,aAAa,CAAC,aAAa,CAAC,EAC5B,UAAU,CAAC;QACT,IAAI,EAAE,YAAY,CAAC,MAAM;QACzB,KAAK,EAAE,aAAa,CAAC,SAAS;QAC9B,OAAO;QACP,IAAI;QACJ,UAAU,EAAE,KAAK;QACjB,SAAS;KACV,CAAC,CACH,CAAC;AACJ,CAAC","sourcesContent":["import {useDecorators} from \"@tsed/core\";\nimport {ProviderScope} from \"../domain/ProviderScope\";\nimport {TokenProvider} from \"../interfaces/TokenProvider\";\nimport {Configuration} from \"./configuration\";\nimport {Injectable} from \"./injectable\";\nimport {ProviderType} from \"../domain/ProviderType\";\nimport {DIResolver} from \"../interfaces/DIResolver\";\n\nexport interface ModuleOptions extends Omit<TsED.Configuration, \"scopes\"> {\n  /**\n   * Provider scope\n   */\n  scope?: ProviderScope;\n  /**\n   * Providers must be initialized before building this module\n   */\n  imports?: TokenProvider[];\n  /**\n   * Explicit token must be injected in the constructor\n   */\n  deps?: TokenProvider[];\n  /**\n   * A list of resolvers to inject provider from external DI.\n   */\n  resolvers?: DIResolver[];\n\n  /**\n   * Additional properties are stored as provider configuration.\n   */\n  [key: string]: any;\n}\n\n/**\n * Declare a new Ts.ED module\n *\n * ## Options\n * - imports: List of Provider which must be built by injector before invoking the module\n * - resolvers: List of external DI must be used to resolve unknown provider\n * - deps: List of provider must be injected to the module constructor (explicit declaration)\n *\n * @param options\n * @decorator\n */\nexport function Module(options: Partial<ModuleOptions> = {}) {\n  const {scopes, imports, resolvers, deps, scope, ...configuration} = options;\n\n  return useDecorators(\n    Configuration(configuration),\n    Injectable({\n      type: ProviderType.MODULE,\n      scope: ProviderScope.SINGLETON,\n      imports,\n      deps,\n      injectable: false,\n      resolvers\n    })\n  );\n}\n"]}

package/lib/esm/decorators/opts.js

@@ -0,0 +1,50 @@
+import { classOf } from "@tsed/core";
+import { DI_PARAM_OPTIONS } from "../constants/constants.js";
+import { ProviderScope } from "../domain/ProviderScope.js";
+import { Inject } from "./inject.js";
+import { Scope } from "./scope.js";
+/**
+ * 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
+ */
+export function Opts(target, propertyKey, index) {
+    Scope(ProviderScope.INSTANCE)(classOf(target));
+    Inject(DI_PARAM_OPTIONS)(target, propertyKey, index);
+}
+//# sourceMappingURL=opts.js.map

package/lib/esm/decorators/opts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opts.js","sourceRoot":"","sources":["../../../src/decorators/opts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAC;AACnC,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,UAAU,IAAI,CAAC,MAAW,EAAE,WAA4B,EAAE,KAAa;IAC3E,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/C,MAAM,CAAC,gBAAgB,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC","sourcesContent":["import {classOf} from \"@tsed/core\";\nimport {DI_PARAM_OPTIONS} from \"../constants/constants\";\nimport {ProviderScope} from \"../domain/ProviderScope\";\nimport {Inject} from \"./inject\";\nimport {Scope} from \"./scope\";\n\n/**\n * Get instance options. This options depending on his invocation context.\n *\n * ```typescript\n * import {Injectable, Opts, UseOpts} from \"@tsed/di\";\n *\n * @Injectable()\n * class MyConfigurableService {\n *   source: string;\n *   constructor(@Opts options: any = {}) {\n *      console.log(\"Hello \", options.source); // log: Hello Service1 then Hello Service2\n *\n *      this.source = options.source;\n *   }\n * }\n *\n * @Injectable()\n * class MyService1 {\n *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {\n *     console.log(service.source) // log: Service1\n *   }\n * }\n *\n * @Injectable()\n * class MyService2 {\n *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {\n *     console.log(service.source) // log: Service2\n *   }\n * }\n * ```\n *\n * ::: warning\n * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.\n * :::\n *\n * @param target\n * @param propertyKey\n * @param index\n * @decorator\n */\nexport function Opts(target: any, propertyKey: string | symbol, index: number) {\n  Scope(ProviderScope.INSTANCE)(classOf(target));\n  Inject(DI_PARAM_OPTIONS)(target, propertyKey, index);\n}\n"]}

package/lib/esm/decorators/overrideProvider.js

@@ -0,0 +1,13 @@
+import { GlobalProviders } from "../registries/GlobalProviders.js";
+/**
+ * Override a provider which is already registered in ProviderRegistry.
+ * @returns {Function}
+ * @decorators
+ * @param originalProvider
+ */
+export function OverrideProvider(originalProvider) {
+    return (target) => {
+        GlobalProviders.get(originalProvider).useClass = target;
+    };
+}
+//# sourceMappingURL=overrideProvider.js.map

package/lib/esm/decorators/overrideProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overrideProvider.js","sourceRoot":"","sources":["../../../src/decorators/overrideProvider.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,gBAA2B;IAC1D,OAAO,CAAC,MAAiB,EAAQ,EAAE;QACjC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAE,CAAC,QAAQ,GAAG,MAAM,CAAC;IAC3D,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Type} from \"@tsed/core\";\nimport {GlobalProviders} from \"../registries/GlobalProviders\";\n\n/**\n * Override a provider which is already registered in ProviderRegistry.\n * @returns {Function}\n * @decorators\n * @param originalProvider\n */\nexport function OverrideProvider(originalProvider: Type<any>): Function {\n  return (target: Type<any>): void => {\n    GlobalProviders.get(originalProvider)!.useClass = target;\n  };\n}\n"]}