@nestjs/core 8.3.1 → 8.4.2

package/injector/injector.js

@@ -37,7 +37,7 @@ class Injector {
         const token = wrapper.token || wrapper.name;
         const { inject } = wrapper;
         const targetWrapper = collection.get(token);
-        if (shared_utils_1.isUndefined(targetWrapper)) {
+        if ((0, shared_utils_1.isUndefined)(targetWrapper)) {
             throw new runtime_exception_1.RuntimeException();
         }
         if (instanceHost.isResolved) {
@@ -54,7 +54,7 @@ class Injector {
     async loadMiddleware(wrapper, collection, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer) {
         const { metatype, token } = wrapper;
         const targetWrapper = collection.get(token);
-        if (!shared_utils_1.isUndefined(targetWrapper.instance)) {
+        if (!(0, shared_utils_1.isUndefined)(targetWrapper.instance)) {
             return;
         }
         targetWrapper.instance = Object.create(metatype.prototype);
@@ -89,12 +89,10 @@ class Injector {
             const deps = await this.loadCtorMetadata(metadata, contextId, inquirer, parentInquirer);
             return callback(deps);
         }
-        const dependencies = shared_utils_1.isNil(inject)
-            ? this.reflectConstructorParams(wrapper.metatype)
-            : inject;
-        const optionalDependenciesIds = shared_utils_1.isNil(inject)
-            ? this.reflectOptionalParams(wrapper.metatype)
-            : [];
+        const isFactoryProvider = !(0, shared_utils_1.isNil)(inject);
+        const [dependencies, optionalDependenciesIds] = isFactoryProvider
+            ? this.getFactoryProviderDependencies(wrapper)
+            : this.getClassDependencies(wrapper);
         let isResolved = true;
         const resolveParam = async (param, index) => {
             try {
@@ -123,6 +121,35 @@ class Injector {
         const instances = await Promise.all(dependencies.map(resolveParam));
         isResolved && (await callback(instances));
     }
+    getClassDependencies(wrapper) {
+        const ctorRef = wrapper.metatype;
+        return [
+            this.reflectConstructorParams(ctorRef),
+            this.reflectOptionalParams(ctorRef),
+        ];
+    }
+    getFactoryProviderDependencies(wrapper) {
+        var _a, _b;
+        const optionalDependenciesIds = [];
+        const isOptionalFactoryDep = (item) => !(0, shared_utils_1.isUndefined)(item.token) &&
+            !(0, shared_utils_1.isUndefined)(item.optional);
+        const mapFactoryProviderInjectArray = (item, index) => {
+            if (typeof item !== 'object') {
+                return item;
+            }
+            if (isOptionalFactoryDep(item)) {
+                if (item.optional) {
+                    optionalDependenciesIds.push(index);
+                }
+                return item === null || item === void 0 ? void 0 : item.token;
+            }
+            return item;
+        };
+        return [
+            (_b = (_a = wrapper.inject) === null || _a === void 0 ? void 0 : _a.map) === null || _b === void 0 ? void 0 : _b.call(_a, mapFactoryProviderInjectArray),
+            optionalDependenciesIds,
+        ];
+    }
     reflectConstructorParams(type) {
         const paramtypes = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) || [];
         const selfParams = this.reflectSelfParams(type);
@@ -136,7 +163,7 @@ class Injector {
         return Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, type) || [];
     }
     async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
-        if (shared_utils_1.isUndefined(param)) {
+        if ((0, shared_utils_1.isUndefined)(param)) {
             this.logger.log('Nest encountered an undefined dependency. This may be due to a circular import or a missing dependency declaration.');
             throw new undefined_dependency_exception_1.UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
         }
@@ -158,10 +185,11 @@ class Injector {
         return this.resolveComponentHost(moduleRef, instanceWrapper, contextId, inquirer);
     }
     async resolveComponentHost(moduleRef, instanceWrapper, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+        var _a;
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = instanceWrapper.getInstanceByContextId(contextId, inquirerId);
         if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
-            await this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer);
+            await this.loadProvider(instanceWrapper, (_a = instanceWrapper.host) !== null && _a !== void 0 ? _a : moduleRef, contextId, inquirer);
         }
         else if (!instanceHost.isResolved &&
             instanceWrapper.forwardRef &&
@@ -184,8 +212,9 @@ class Injector {
         return instanceWrapper;
     }
     async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
+        const token = wrapper.token || wrapper.name;
         const { name } = dependencyContext;
-        if (wrapper && wrapper.name === name) {
+        if (wrapper && token === name) {
             throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef);
         }
         if (providers.has(name)) {
@@ -198,7 +227,7 @@ class Injector {
     }
     async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
         const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, [], contextId, inquirer, keyOrIndex);
-        if (shared_utils_1.isNil(instanceWrapper)) {
+        if ((0, shared_utils_1.isNil)(instanceWrapper)) {
             throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef);
         }
         return instanceWrapper;
@@ -240,7 +269,7 @@ class Injector {
         return instanceWrapperRef;
     }
     async resolveProperties(wrapper, moduleRef, inject, contextId = constants_2.STATIC_CONTEXT, inquirer, parentInquirer) {
-        if (!shared_utils_1.isNil(inject)) {
+        if (!(0, shared_utils_1.isNil)(inject)) {
             return [];
         }
         const metadata = wrapper.getPropertiesMetadata();
@@ -280,11 +309,11 @@ class Injector {
         return properties.map((item) => (Object.assign(Object.assign({}, item), { name: item.type, isOptional: optionalKeys.includes(item.key) })));
     }
     applyProperties(instance, properties) {
-        if (!shared_utils_1.isObject(instance)) {
+        if (!(0, shared_utils_1.isObject)(instance)) {
             return undefined;
         }
-        iterare_1.iterate(properties)
-            .filter(item => !shared_utils_1.isNil(item.instance))
+        (0, iterare_1.iterate)(properties)
+            .filter(item => !(0, shared_utils_1.isNil)(item.instance))
             .forEach(item => (instance[item.key] = item.instance));
     }
     async instantiateClass(instances, wrapper, targetMetatype, contextId = constants_2.STATIC_CONTEXT, inquirer) {
@@ -295,7 +324,7 @@ class Injector {
             wrapper.isInRequestScope(contextId, inquirer) ||
             wrapper.isLazyTransient(contextId, inquirer) ||
             wrapper.isExplicitlyRequested(contextId, inquirer);
-        if (shared_utils_1.isNil(inject) && isInContext) {
+        if ((0, shared_utils_1.isNil)(inject) && isInContext) {
             instanceHost.instance = wrapper.forwardRef
                 ? Object.assign(instanceHost.instance, new metatype(...instances))
                 : new metatype(...instances);
@@ -357,12 +386,12 @@ class Injector {
         return param === inquirer_1.INQUIRER && parentInquirer;
     }
     addDependencyMetadata(keyOrIndex, hostWrapper, instanceWrapper) {
-        shared_utils_1.isString(keyOrIndex)
+        (0, shared_utils_1.isString)(keyOrIndex)
             ? hostWrapper.addPropertiesMetadata(keyOrIndex, instanceWrapper)
             : hostWrapper.addCtorMetadata(keyOrIndex, instanceWrapper);
     }
     getTokenName(token) {
-        return shared_utils_1.isFunction(token) ? token.name : token.toString();
+        return (0, shared_utils_1.isFunction)(token) ? token.name : token.toString();
     }
     printResolvingDependenciesLog(token, inquirer) {
         var _a, _b, _c;

package/injector/instance-links-host.js

@@ -47,8 +47,7 @@ class InstanceLinksHost {
         }
     }
     getInstanceNameByToken(token) {
-        var _a;
-        return shared_utils_1.isFunction(token) ? (_a = token) === null || _a === void 0 ? void 0 : _a.name : token;
+        return (0, shared_utils_1.isFunction)(token) ? token === null || token === void 0 ? void 0 : token.name : token;
     }
 }
 exports.InstanceLinksHost = InstanceLinksHost;

package/injector/instance-loader.js

@@ -31,7 +31,7 @@ class InstanceLoader {
             await this.createInstancesOfControllers(moduleRef);
             const { name } = moduleRef.metatype;
             this.isModuleWhitelisted(name) &&
-                this.logger.log(messages_1.MODULE_INIT_MESSAGE `${name}`);
+                this.logger.log((0, messages_1.MODULE_INIT_MESSAGE) `${name}`);
         }));
     }
     createPrototypesOfProviders(moduleRef) {

package/injector/instance-wrapper.d.ts

@@ -1,4 +1,5 @@
 import { Provider, Scope, Type } from '@nestjs/common';
+import { FactoryProvider } from '@nestjs/common/interfaces';
 import { InstanceToken, Module } from './module';
 export declare const INSTANCE_METADATA_SYMBOL: unique symbol;
 export declare const INSTANCE_ID_SYMBOL: unique symbol;
@@ -23,7 +24,7 @@ export declare class InstanceWrapper<T = any> {
     readonly isAlias: boolean;
     scope?: Scope;
     metatype: Type<T> | Function;
-    inject?: (string | symbol | Function | Type<any>)[];
+    inject?: FactoryProvider['inject'];
     forwardRef?: boolean;
     private readonly values;
     private readonly [INSTANCE_METADATA_SYMBOL];

package/injector/instance-wrapper.js

@@ -16,7 +16,7 @@ class InstanceWrapper {
         this.scope = common_1.Scope.DEFAULT;
         this.values = new WeakMap();
         this[_a] = {};
-        this[exports.INSTANCE_ID_SYMBOL] = random_string_generator_util_1.randomStringGenerator();
+        this[exports.INSTANCE_ID_SYMBOL] = (0, random_string_generator_util_1.randomStringGenerator)();
         this.initialize(metadata);
     }
     get id() {
@@ -30,7 +30,7 @@ class InstanceWrapper {
         return instancePerContext.instance;
     }
     get isNotMetatype() {
-        const isFactory = this.metatype && !shared_utils_1.isNil(this.inject);
+        const isFactory = this.metatype && !(0, shared_utils_1.isNil)(this.inject);
         return !this.metatype || isFactory;
     }
     get isTransient() {
@@ -101,7 +101,7 @@ class InstanceWrapper {
         return this[exports.INSTANCE_METADATA_SYMBOL].enhancers;
     }
     isDependencyTreeStatic(lookupRegistry = []) {
-        if (!shared_utils_1.isUndefined(this.isTreeStatic)) {
+        if (!(0, shared_utils_1.isUndefined)(this.isTreeStatic)) {
             return this.isTreeStatic;
         }
         if (this.scope === common_1.Scope.REQUEST) {
@@ -190,13 +190,13 @@ class InstanceWrapper {
             return [];
         }
         const instances = [...this.transientMap.values()];
-        return iterare_1.iterate(instances)
+        return (0, iterare_1.iterate)(instances)
             .map(item => item.get(constants_1.STATIC_CONTEXT))
             .filter(item => !!item)
             .toArray();
     }
     mergeWith(provider) {
-        if (!shared_utils_1.isUndefined(provider.useValue)) {
+        if (!(0, shared_utils_1.isUndefined)(provider.useValue)) {
             this.metatype = null;
             this.inject = null;
             this.scope = common_1.Scope.DEFAULT;
@@ -216,7 +216,7 @@ class InstanceWrapper {
         }
     }
     isNewable() {
-        return shared_utils_1.isNil(this.inject) && this.metatype && this.metatype.prototype;
+        return (0, shared_utils_1.isNil)(this.inject) && this.metatype && this.metatype.prototype;
     }
     isWrapperListStatic(tree, lookupRegistry) {
         return tree.every((item) => item.isDependencyTreeStatic(lookupRegistry));

package/injector/internal-core-module.js

@@ -21,8 +21,8 @@ let InternalCoreModule = InternalCoreModule_1 = class InternalCoreModule {
     }
 };
 InternalCoreModule = InternalCoreModule_1 = tslib_1.__decorate([
-    common_1.Global(),
-    common_1.Module({
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
         providers: [
             services_1.Reflector,
             ReflectorAliasProvider,

package/injector/module-ref.js

@@ -63,7 +63,7 @@ class ModuleRef {
             name: type && type.name,
             metatype: type,
             isResolved: false,
-            scope: get_class_scope_1.getClassScope(type),
+            scope: (0, get_class_scope_1.getClassScope)(type),
             host: moduleRef,
         });
         return new Promise(async (resolve, reject) => {

package/injector/module-token-factory.js

@@ -23,7 +23,7 @@ class ModuleTokenFactory {
         // The replacer function is also required in order to obtain real class names
         // instead of the unified "Function" key
         return dynamicModuleMetadata
-            ? fast_safe_stringify_1.default(dynamicModuleMetadata, this.replacer)
+            ? (0, fast_safe_stringify_1.default)(dynamicModuleMetadata, this.replacer)
             : '';
     }
     getModuleId(metatype) {
@@ -31,7 +31,7 @@ class ModuleTokenFactory {
         if (moduleId) {
             return moduleId;
         }
-        moduleId = random_string_generator_util_1.randomStringGenerator();
+        moduleId = (0, random_string_generator_util_1.randomStringGenerator)();
         this.moduleIdsCache.set(metatype, moduleId);
         return moduleId;
     }
@@ -39,7 +39,7 @@ class ModuleTokenFactory {
         return metatype.name;
     }
     replacer(key, value) {
-        if (shared_utils_1.isFunction(value)) {
+        if ((0, shared_utils_1.isFunction)(value)) {
             const funcAsString = value.toString();
             const isClass = /^class\s/.test(funcAsString);
             if (isClass) {
@@ -47,7 +47,7 @@ class ModuleTokenFactory {
             }
             return hash(funcAsString, { ignoreUnknown: true });
         }
-        if (shared_utils_1.isSymbol(value)) {
+        if ((0, shared_utils_1.isSymbol)(value)) {
             return value.toString();
         }
         return value;

package/injector/module.d.ts

@@ -1,9 +1,13 @@
-import { Abstract, ClassProvider, Controller, DynamicModule, ExistingProvider, FactoryProvider, Injectable, NestModule, Provider, ValueProvider } from '@nestjs/common/interfaces';
+import { ClassProvider, Controller, DynamicModule, ExistingProvider, FactoryProvider, Injectable, InjectionToken, NestModule, Provider, ValueProvider } from '@nestjs/common/interfaces';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
 import { ModuleRef } from './module-ref';
-export declare type InstanceToken = string | symbol | Type<any> | Abstract<any> | Function;
+/**
+ * @note
+ * Left for backward compatibility
+ */
+export declare type InstanceToken = InjectionToken;
 export declare class Module {
     private readonly _metatype;
     private readonly container;
@@ -46,10 +50,10 @@ export declare class Module {
     addModuleRef(): void;
     addModuleAsProvider(): void;
     addApplicationConfig(): void;
-    addInjectable<T extends Injectable>(injectable: Provider, host?: Type<T>): string | symbol | Function | Type<any> | Abstract<any>;
-    addProvider(provider: Provider): string | symbol | Function;
+    addInjectable<T extends Injectable>(injectable: Provider, host?: Type<T>): InjectionToken;
+    addProvider(provider: Provider): InjectionToken;
     isCustomProvider(provider: Provider): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
-    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>): string | symbol | Function | Type<any> | Abstract<any>;
+    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>): InjectionToken;
     isCustomClass(provider: any): provider is ClassProvider;
     isCustomValue(provider: any): provider is ValueProvider;
     isCustomFactory(provider: any): provider is FactoryProvider;
@@ -59,9 +63,9 @@ export declare class Module {
     addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>): void;
     addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>): void;
     addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>): void;
-    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InstanceToken>;
-    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InstanceToken>;
-    validateExportedProvider(token: InstanceToken): InstanceToken;
+    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InjectionToken>;
+    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken>;
+    validateExportedProvider(token: InstanceToken): InjectionToken;
     addController(controller: Type<Controller>): void;
     assignControllerUniqueId(controller: Type<Controller>): void;
     addRelatedModule(module: Module): void;

package/injector/module.js

@@ -25,7 +25,7 @@ class Module {
         this._exports = new Set();
         this._distance = 0;
         this.addCoreProviders();
-        this._id = random_string_generator_util_1.randomStringGenerator();
+        this._id = (0, random_string_generator_util_1.randomStringGenerator)();
     }
     get id() {
         return this._id;
@@ -135,7 +135,7 @@ class Module {
                 metatype: injectable,
                 instance: null,
                 isResolved: false,
-                scope: get_class_scope_1.getClassScope(injectable),
+                scope: (0, get_class_scope_1.getClassScope)(injectable),
                 host: this,
             });
             this._injectables.set(injectable, instanceWrapper);
@@ -155,13 +155,13 @@ class Module {
             metatype: provider,
             instance: null,
             isResolved: false,
-            scope: get_class_scope_1.getClassScope(provider),
+            scope: (0, get_class_scope_1.getClassScope)(provider),
             host: this,
         }));
         return provider;
     }
     isCustomProvider(provider) {
-        return !shared_utils_1.isNil(provider.provide);
+        return !(0, shared_utils_1.isNil)(provider.provide);
     }
     addCustomProvider(provider, collection) {
         if (this.isCustomClass(provider)) {
@@ -179,16 +179,16 @@ class Module {
         return provider.provide;
     }
     isCustomClass(provider) {
-        return !shared_utils_1.isUndefined(provider.useClass);
+        return !(0, shared_utils_1.isUndefined)(provider.useClass);
     }
     isCustomValue(provider) {
-        return !shared_utils_1.isUndefined(provider.useValue);
+        return !(0, shared_utils_1.isUndefined)(provider.useValue);
     }
     isCustomFactory(provider) {
-        return !shared_utils_1.isUndefined(provider.useFactory);
+        return !(0, shared_utils_1.isUndefined)(provider.useFactory);
     }
     isCustomUseExisting(provider) {
-        return !shared_utils_1.isUndefined(provider.useExisting);
+        return !(0, shared_utils_1.isUndefined)(provider.useExisting);
     }
     isDynamicModule(exported) {
         return exported && exported.module;
@@ -196,8 +196,8 @@ class Module {
     addCustomClass(provider, collection) {
         let { scope } = provider;
         const { useClass } = provider;
-        if (shared_utils_1.isUndefined(scope)) {
-            scope = get_class_scope_1.getClassScope(useClass);
+        if ((0, shared_utils_1.isUndefined)(scope)) {
+            scope = (0, get_class_scope_1.getClassScope)(useClass);
         }
         collection.set(provider.provide, new instance_wrapper_1.InstanceWrapper({
             token: provider.provide,
@@ -210,11 +210,10 @@ class Module {
         }));
     }
     addCustomValue(provider, collection) {
-        var _a;
         const { useValue: value, provide: providerToken } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
-            name: ((_a = providerToken) === null || _a === void 0 ? void 0 : _a.name) || providerToken,
+            name: (providerToken === null || providerToken === void 0 ? void 0 : providerToken.name) || providerToken,
             metatype: null,
             instance: value,
             isResolved: true,
@@ -223,11 +222,10 @@ class Module {
         }));
     }
     addCustomFactory(provider, collection) {
-        var _a;
         const { useFactory: factory, inject, scope, provide: providerToken, } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
-            name: ((_a = providerToken) === null || _a === void 0 ? void 0 : _a.name) || providerToken,
+            name: (providerToken === null || providerToken === void 0 ? void 0 : providerToken.name) || providerToken,
             metatype: factory,
             instance: null,
             isResolved: false,
@@ -237,11 +235,10 @@ class Module {
         }));
     }
     addCustomUseExisting(provider, collection) {
-        var _a;
         const { useExisting, provide: providerToken } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
-            name: ((_a = providerToken) === null || _a === void 0 ? void 0 : _a.name) || providerToken,
+            name: (providerToken === null || providerToken === void 0 ? void 0 : providerToken.name) || providerToken,
             metatype: (instance => instance),
             instance: null,
             isResolved: false,
@@ -255,7 +252,7 @@ class Module {
         if (this.isCustomProvider(provider)) {
             return this.addCustomExportedProvider(provider);
         }
-        else if (shared_utils_1.isString(provider) || shared_utils_1.isSymbol(provider)) {
+        else if ((0, shared_utils_1.isString)(provider) || (0, shared_utils_1.isSymbol)(provider)) {
             return addExportedUnit(provider);
         }
         else if (this.isDynamicModule(provider)) {
@@ -266,7 +263,7 @@ class Module {
     }
     addCustomExportedProvider(provider) {
         const provide = provider.provide;
-        if (shared_utils_1.isString(provide) || shared_utils_1.isSymbol(provide)) {
+        if ((0, shared_utils_1.isString)(provide) || (0, shared_utils_1.isSymbol)(provide)) {
             return this._exports.add(this.validateExportedProvider(provide));
         }
         this._exports.add(this.validateExportedProvider(provide));
@@ -275,14 +272,14 @@ class Module {
         if (this._providers.has(token)) {
             return token;
         }
-        const imports = iterare_1.iterate(this._imports.values())
+        const imports = (0, iterare_1.iterate)(this._imports.values())
             .filter(item => !!item)
             .map(({ metatype }) => metatype)
             .filter(metatype => !!metatype)
             .toArray();
         if (!imports.includes(token)) {
             const { name } = this.metatype;
-            const providerName = shared_utils_1.isFunction(token) ? token.name : token;
+            const providerName = (0, shared_utils_1.isFunction)(token) ? token.name : token;
             throw new unknown_export_exception_1.UnknownExportException(providerName, name);
         }
         return token;
@@ -294,7 +291,7 @@ class Module {
             metatype: controller,
             instance: null,
             isResolved: false,
-            scope: get_class_scope_1.getClassScope(controller),
+            scope: (0, get_class_scope_1.getClassScope)(controller),
             host: this,
         }));
         this.assignControllerUniqueId(controller);
@@ -304,7 +301,7 @@ class Module {
             enumerable: false,
             writable: false,
             configurable: true,
-            value: random_string_generator_util_1.randomStringGenerator(),
+            value: (0, random_string_generator_util_1.randomStringGenerator)(),
         });
     }
     addRelatedModule(module) {
@@ -344,11 +341,11 @@ class Module {
                     ? this.find(typeOrToken)
                     : this.find(typeOrToken, self);
             }
-            resolve(typeOrToken, contextId = context_id_factory_1.createContextId(), options = { strict: true }) {
+            resolve(typeOrToken, contextId = (0, context_id_factory_1.createContextId)(), options = { strict: true }) {
                 return this.resolvePerContext(typeOrToken, self, contextId, options);
             }
             async create(type) {
-                if (!(type && shared_utils_1.isFunction(type) && type.prototype)) {
+                if (!(type && (0, shared_utils_1.isFunction)(type) && type.prototype)) {
                     throw new invalid_class_exception_1.InvalidClassException(type);
                 }
                 return this.instantiateClass(type, self);

package/injector/modules-container.js

@@ -5,7 +5,7 @@ const uuid_1 = require("uuid");
 class ModulesContainer extends Map {
     constructor() {
         super(...arguments);
-        this._applicationId = uuid_1.v4();
+        this._applicationId = (0, uuid_1.v4)();
     }
     get applicationId() {
         return this._applicationId;

package/interceptors/interceptors-consumer.js

@@ -7,18 +7,18 @@ const operators_1 = require("rxjs/operators");
 const execution_context_host_1 = require("../helpers/execution-context-host");
 class InterceptorsConsumer {
     async intercept(interceptors, args, instance, callback, next, type) {
-        if (shared_utils_1.isEmpty(interceptors)) {
+        if ((0, shared_utils_1.isEmpty)(interceptors)) {
             return next();
         }
         const context = this.createContext(args, instance, callback);
         context.setType(type);
-        const start$ = rxjs_1.defer(() => this.transformDeferred(next));
+        const start$ = (0, rxjs_1.defer)(() => this.transformDeferred(next));
         const nextFn = (i = 0) => async () => {
             if (i >= interceptors.length) {
                 return start$;
             }
             const handler = {
-                handle: () => rxjs_1.from(nextFn(i + 1)()).pipe(operators_1.mergeAll()),
+                handle: () => (0, rxjs_1.from)(nextFn(i + 1)()).pipe((0, operators_1.mergeAll)()),
             };
             return interceptors[i].intercept(context, handler);
         };
@@ -28,7 +28,7 @@ class InterceptorsConsumer {
         return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
     }
     transformDeferred(next) {
-        return rxjs_1.from(next()).pipe(operators_1.switchMap(res => {
+        return (0, rxjs_1.from)(next()).pipe((0, operators_1.switchMap)(res => {
             const isDeferred = res instanceof Promise || res instanceof rxjs_1.Observable;
             return isDeferred ? res : Promise.resolve(res);
         }));

package/interceptors/interceptors-context-creator.js

@@ -17,13 +17,13 @@ class InterceptorsContextCreator extends context_creator_1.ContextCreator {
         return this.createContext(instance, callback, constants_1.INTERCEPTORS_METADATA, contextId, inquirerId);
     }
     createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        if (shared_utils_1.isEmpty(metadata)) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
             return [];
         }
-        return iterare_1.iterate(metadata)
+        return (0, iterare_1.iterate)(metadata)
             .filter(interceptor => interceptor && (interceptor.name || interceptor.intercept))
             .map(interceptor => this.getInterceptorInstance(interceptor, contextId, inquirerId))
-            .filter((interceptor) => interceptor && shared_utils_1.isFunction(interceptor.intercept))
+            .filter((interceptor) => interceptor && (0, shared_utils_1.isFunction)(interceptor.intercept))
             .toArray();
     }
     getInterceptorInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
@@ -58,7 +58,7 @@ class InterceptorsContextCreator extends context_creator_1.ContextCreator {
             return globalInterceptors;
         }
         const scopedInterceptorWrappers = this.config.getGlobalRequestInterceptors();
-        const scopedInterceptors = iterare_1.iterate(scopedInterceptorWrappers)
+        const scopedInterceptors = (0, iterare_1.iterate)(scopedInterceptorWrappers)
             .map(wrapper => wrapper.getInstanceByContextId(contextId, inquirerId))
             .filter(host => !!host)
             .map(host => host.instance)

package/metadata-scanner.js

@@ -6,9 +6,9 @@ const iterare_1 = require("iterare");
 class MetadataScanner {
     scanFromPrototype(instance, prototype, callback) {
         const methodNames = new Set(this.getAllFilteredMethodNames(prototype));
-        return iterare_1.iterate(methodNames)
+        return (0, iterare_1.iterate)(methodNames)
             .map(callback)
-            .filter(metadata => !shared_utils_1.isNil(metadata))
+            .filter(metadata => !(0, shared_utils_1.isNil)(metadata))
             .toArray();
     }
     *getAllFilteredMethodNames(prototype) {
@@ -17,10 +17,10 @@ class MetadataScanner {
             if (descriptor.set || descriptor.get) {
                 return false;
             }
-            return !shared_utils_1.isConstructor(prop) && shared_utils_1.isFunction(prototype[prop]);
+            return !(0, shared_utils_1.isConstructor)(prop) && (0, shared_utils_1.isFunction)(prototype[prop]);
         };
         do {
-            yield* iterare_1.iterate(Object.getOwnPropertyNames(prototype))
+            yield* (0, iterare_1.iterate)(Object.getOwnPropertyNames(prototype))
                 .filter(isMethod)
                 .toArray();
         } while ((prototype = Reflect.getPrototypeOf(prototype)) &&

package/middleware/builder.js

@@ -11,7 +11,7 @@ class MiddlewareBuilder {
         this.middlewareCollection = new Set();
     }
     apply(...middleware) {
-        return new MiddlewareBuilder.ConfigProxy(this, dependencies_decorator_1.flatten(middleware));
+        return new MiddlewareBuilder.ConfigProxy(this, (0, dependencies_decorator_1.flatten)(middleware));
     }
     build() {
         return [...this.middlewareCollection];
@@ -38,7 +38,7 @@ MiddlewareBuilder.ConfigProxy = class {
         const { middlewareCollection } = this.builder;
         const forRoutes = this.getRoutesFlatList(routes);
         const configuration = {
-            middleware: utils_1.filterMiddleware(this.middleware, this.excludedRoutes, this.builder.getHttpAdapter()),
+            middleware: (0, utils_1.filterMiddleware)(this.middleware, this.excludedRoutes, this.builder.getHttpAdapter()),
             forRoutes,
         };
         middlewareCollection.add(configuration);
@@ -46,7 +46,7 @@ MiddlewareBuilder.ConfigProxy = class {
     }
     getRoutesFlatList(routes) {
         const { routesMapper } = this.builder;
-        return iterare_1.iterate(routes)
+        return (0, iterare_1.iterate)(routes)
             .map(route => routesMapper.mapRouteToRouteInfo(route))
             .flatten()
             .toArray();

package/middleware/container.js

@@ -26,7 +26,7 @@ class MiddlewareContainer {
         const insertMiddleware = (metatype) => {
             const token = metatype;
             middleware.set(token, new instance_wrapper_1.InstanceWrapper({
-                scope: get_class_scope_1.getClassScope(metatype),
+                scope: (0, get_class_scope_1.getClassScope)(metatype),
                 name: token,
                 metatype,
                 token,