@nestjs/core 9.1.5 → 9.2.0

package/Readme.md

@@ -90,7 +90,9 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <a href="https://www.castlecraft.in" target="_blank"><img src="https://nestjs.com/img/castlecraft-logo.png" width="150" valign="middle" /></td>
 <td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td>
 <td><a href="https://n.inc" target="_blank"><img src="https://nestjs.com/img/n-inc-logo.svg" width="120" valign="middle" /></td></tr><tr>
-<td><a href="https://bilberrry.com/" target="_blank"><img src="https://nestjs.com/img/bilberrry-logo.svg" width="180" valign="middle" /></td></tr></table>
+<td><a href="https://bilberrry.com/" target="_blank"><img src="https://nestjs.com/img/bilberrry-logo.svg" width="180" valign="middle" /></td>
+<td><a href="https://ipinfo.ai/" target="_blank"><img src="https://nestjs.com/img/ipinfo-logo.png" width="130" valign="middle" /></td></tr>
+</table>
 
 #### Sponsors
 

package/errors/exceptions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './circular-dependency.exception';
+export * from './runtime.exception';
+export * from './unknown-element.exception';
+export * from './invalid-class-scope.exception';
+export * from './invalid-class.exception';
+export * from './unknown-export.exception';
+export * from './unknown-module.exception';
+export * from './undefined-forwardref.exception';

package/errors/exceptions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./circular-dependency.exception"), exports);
+tslib_1.__exportStar(require("./runtime.exception"), exports);
+tslib_1.__exportStar(require("./unknown-element.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class-scope.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class.exception"), exports);
+tslib_1.__exportStar(require("./unknown-export.exception"), exports);
+tslib_1.__exportStar(require("./unknown-module.exception"), exports);
+tslib_1.__exportStar(require("./undefined-forwardref.exception"), exports);

package/errors/exceptions/unknown-request-mapping.exception.d.ts

@@ -1,4 +1,5 @@
+import type { Type } from '@nestjs/common';
 import { RuntimeException } from './runtime.exception';
 export declare class UnknownRequestMappingException extends RuntimeException {
-    constructor();
+    constructor(metatype: Type);
 }

package/errors/exceptions/unknown-request-mapping.exception.js

@@ -4,8 +4,8 @@ exports.UnknownRequestMappingException = void 0;
 const runtime_exception_1 = require("./runtime.exception");
 const messages_1 = require("../messages");
 class UnknownRequestMappingException extends runtime_exception_1.RuntimeException {
-    constructor() {
-        super(messages_1.UNKNOWN_REQUEST_MAPPING);
+    constructor(metatype) {
+        super((0, messages_1.UNKNOWN_REQUEST_MAPPING)(metatype));
     }
 }
 exports.UnknownRequestMappingException = UnknownRequestMappingException;

package/errors/messages.d.ts

@@ -10,8 +10,8 @@ export declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number
 export declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol, module: string) => string;
 export declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
 export declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
+export declare const UNKNOWN_REQUEST_MAPPING: (metatype: Type) => string;
 export declare const INVALID_MIDDLEWARE_CONFIGURATION = "An invalid middleware configuration has been passed inside the module 'configure()' method.";
-export declare const UNKNOWN_REQUEST_MAPPING = "An invalid controller has been detected. Perhaps, one of your controllers is missing @Controller() decorator.";
 export declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";
 export declare const INVALID_EXCEPTION_FILTER = "Invalid exception filters (@UseFilters()).";
 export declare const MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = "Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)";

package/errors/messages.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = exports.INVALID_EXCEPTION_FILTER = exports.UNHANDLED_RUNTIME_EXCEPTION = exports.UNKNOWN_REQUEST_MAPPING = exports.INVALID_MIDDLEWARE_CONFIGURATION = exports.INVALID_CLASS_SCOPE_MESSAGE = exports.INVALID_CLASS_MESSAGE = exports.UNKNOWN_EXPORT_MESSAGE = exports.UNDEFINED_MODULE_MESSAGE = exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = exports.INVALID_MODULE_MESSAGE = exports.UNDEFINED_FORWARDREF_MESSAGE = exports.INVALID_MIDDLEWARE_MESSAGE = exports.UNKNOWN_DEPENDENCIES_MESSAGE = void 0;
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = exports.INVALID_EXCEPTION_FILTER = exports.UNHANDLED_RUNTIME_EXCEPTION = exports.INVALID_MIDDLEWARE_CONFIGURATION = exports.UNKNOWN_REQUEST_MAPPING = exports.INVALID_CLASS_SCOPE_MESSAGE = exports.INVALID_CLASS_MESSAGE = exports.UNKNOWN_EXPORT_MESSAGE = exports.UNDEFINED_MODULE_MESSAGE = exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = exports.INVALID_MODULE_MESSAGE = exports.UNDEFINED_FORWARDREF_MESSAGE = exports.INVALID_MIDDLEWARE_MESSAGE = exports.UNKNOWN_DEPENDENCIES_MESSAGE = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 /**
  * Returns the name of an instance or `undefined`
@@ -114,8 +114,14 @@ const INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate cla
 exports.INVALID_CLASS_MESSAGE = INVALID_CLASS_MESSAGE;
 const INVALID_CLASS_SCOPE_MESSAGE = (text, name) => `${name || 'This class'} is marked as a scoped provider. Request and transient-scoped providers can't be used in combination with "get()" method. Please, use "resolve()" instead.`;
 exports.INVALID_CLASS_SCOPE_MESSAGE = INVALID_CLASS_SCOPE_MESSAGE;
+const UNKNOWN_REQUEST_MAPPING = (metatype) => {
+    const className = metatype.name;
+    return className
+        ? `An invalid controller has been detected. "${className}" does not have the @Controller() decorator but it is being listed in the "controllers" array of some module.`
+        : `An invalid controller has been detected. Perhaps, one of your controllers is missing the @Controller() decorator.`;
+};
+exports.UNKNOWN_REQUEST_MAPPING = UNKNOWN_REQUEST_MAPPING;
 exports.INVALID_MIDDLEWARE_CONFIGURATION = `An invalid middleware configuration has been passed inside the module 'configure()' method.`;
-exports.UNKNOWN_REQUEST_MAPPING = `An invalid controller has been detected. Perhaps, one of your controllers is missing @Controller() decorator.`;
 exports.UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;
 exports.INVALID_EXCEPTION_FILTER = `Invalid exception filters (@UseFilters()).`;
 exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = `Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)`;

package/guards/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './guards-consumer';
+export * from './guards-context-creator';

package/guards/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./guards-consumer"), exports);
+tslib_1.__exportStar(require("./guards-context-creator"), exports);

package/helpers/handler-metadata-storage.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Type } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces';
 import { IncomingMessage } from 'http';
 import { Observable } from 'rxjs';
 import { ContextId } from '../injector/instance-wrapper';

package/injector/abstract-instance-resolver.d.ts

@@ -0,0 +1,16 @@
+import { Abstract, Type } from '@nestjs/common';
+import { GetOrResolveOptions } from '@nestjs/common/interfaces';
+import { Injector } from './injector';
+import { InstanceLinksHost } from './instance-links-host';
+import { ContextId } from './instance-wrapper';
+import { Module } from './module';
+export declare abstract class AbstractInstanceResolver {
+    protected abstract instanceLinksHost: InstanceLinksHost;
+    protected abstract injector: Injector;
+    protected abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, options: {
+        moduleId?: string;
+        each?: boolean;
+    }): TResult | Array<TResult>;
+    protected resolvePerContext<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextModule: Module, contextId: ContextId, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+}

package/injector/abstract-instance-resolver.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractInstanceResolver = void 0;
+const common_1 = require("@nestjs/common");
+const exceptions_1 = require("../errors/exceptions");
+class AbstractInstanceResolver {
+    find(typeOrToken, options) {
+        const instanceLinkOrArray = this.instanceLinksHost.get(typeOrToken, options);
+        const pluckInstance = ({ wrapperRef }) => {
+            if (wrapperRef.scope === common_1.Scope.REQUEST ||
+                wrapperRef.scope === common_1.Scope.TRANSIENT) {
+                throw new exceptions_1.InvalidClassScopeException(typeOrToken);
+            }
+            return wrapperRef.instance;
+        };
+        if (Array.isArray(instanceLinkOrArray)) {
+            return instanceLinkOrArray.map(pluckInstance);
+        }
+        return pluckInstance(instanceLinkOrArray);
+    }
+    async resolvePerContext(typeOrToken, contextModule, contextId, options) {
+        const instanceLinkOrArray = (options === null || options === void 0 ? void 0 : options.strict)
+            ? this.instanceLinksHost.get(typeOrToken, {
+                moduleId: contextModule.id,
+                each: options.each,
+            })
+            : this.instanceLinksHost.get(typeOrToken, {
+                each: options.each,
+            });
+        const pluckInstance = async (instanceLink) => {
+            const { wrapperRef, collection } = instanceLink;
+            if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient) {
+                return this.get(typeOrToken, { strict: options.strict });
+            }
+            const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
+            const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);
+            if (!instance) {
+                throw new exceptions_1.UnknownElementException();
+            }
+            return instance;
+        };
+        if (Array.isArray(instanceLinkOrArray)) {
+            return Promise.all(instanceLinkOrArray.map(instanceLink => pluckInstance(instanceLink)));
+        }
+        return pluckInstance(instanceLinkOrArray);
+    }
+}
+exports.AbstractInstanceResolver = AbstractInstanceResolver;

package/injector/container.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestContainer = void 0;
 const constants_1 = require("@nestjs/common/constants");
-const circular_dependency_exception_1 = require("../errors/exceptions/circular-dependency.exception");
-const undefined_forwardref_exception_1 = require("../errors/exceptions/undefined-forwardref.exception");
-const unknown_module_exception_1 = require("../errors/exceptions/unknown-module.exception");
+const exceptions_1 = require("../errors/exceptions");
 const request_constants_1 = require("../router/request/request-constants");
 const compiler_1 = require("./compiler");
-const internal_core_module_1 = require("./internal-core-module");
+const internal_core_module_1 = require("./internal-core-module/internal-core-module");
 const internal_providers_storage_1 = require("./internal-providers-storage");
 const module_1 = require("./module");
 const module_token_factory_1 = require("./module-token-factory");
@@ -43,7 +41,7 @@ class NestContainer {
         // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
         // We still need to catch the edge-case of `forwardRef(() => undefined)`
         if (!metatype) {
-            throw new undefined_forwardref_exception_1.UndefinedForwardRefException(scope);
+            throw new exceptions_1.UndefinedForwardRefException(scope);
         }
         const { type, dynamicMetadata, token } = await this.moduleCompiler.compile(metatype);
         if (this.modules.has(token)) {
@@ -105,30 +103,30 @@ class NestContainer {
     addProvider(provider, token) {
         const moduleRef = this.modules.get(token);
         if (!provider) {
-            throw new circular_dependency_exception_1.CircularDependencyException(moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype.name);
+            throw new exceptions_1.CircularDependencyException(moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype.name);
         }
         if (!moduleRef) {
-            throw new unknown_module_exception_1.UnknownModuleException();
+            throw new exceptions_1.UnknownModuleException();
         }
         return moduleRef.addProvider(provider);
     }
     addInjectable(injectable, token, host) {
         if (!this.modules.has(token)) {
-            throw new unknown_module_exception_1.UnknownModuleException();
+            throw new exceptions_1.UnknownModuleException();
         }
         const moduleRef = this.modules.get(token);
         moduleRef.addInjectable(injectable, host);
     }
     addExportedProvider(provider, token) {
         if (!this.modules.has(token)) {
-            throw new unknown_module_exception_1.UnknownModuleException();
+            throw new exceptions_1.UnknownModuleException();
         }
         const moduleRef = this.modules.get(token);
         moduleRef.addExportedProvider(provider);
     }
     addController(controller, token) {
         if (!this.modules.has(token)) {
-            throw new unknown_module_exception_1.UnknownModuleException();
+            throw new exceptions_1.UnknownModuleException();
         }
         const moduleRef = this.modules.get(token);
         moduleRef.addController(controller);

package/injector/index.d.ts

@@ -1,6 +1,6 @@
 export * from './container';
 export * from './inquirer';
 export { ContextId, HostComponentInfo } from './instance-wrapper';
-export * from './lazy-module-loader';
+export * from './lazy-module-loader/lazy-module-loader';
 export * from './module-ref';
 export * from './modules-container';

package/injector/index.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./container"), exports);
 tslib_1.__exportStar(require("./inquirer"), exports);
-tslib_1.__exportStar(require("./lazy-module-loader"), exports);
+tslib_1.__exportStar(require("./lazy-module-loader/lazy-module-loader"), exports);
 tslib_1.__exportStar(require("./module-ref"), exports);
 tslib_1.__exportStar(require("./modules-container"), exports);

package/injector/injector.d.ts

@@ -1,7 +1,5 @@
 import { InjectionToken } from '@nestjs/common';
-import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
-import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
-import { Type } from '@nestjs/common/interfaces/type.interface';
+import { Controller, Injectable, Type } from '@nestjs/common/interfaces';
 import { ContextId, InstancePerContext, InstanceWrapper, PropertyMetadata } from './instance-wrapper';
 import { InstanceToken, Module } from './module';
 /**

package/injector/instance-links-host.d.ts

@@ -11,7 +11,11 @@ export declare class InstanceLinksHost {
     private readonly container;
     private readonly instanceLinks;
     constructor(container: NestContainer);
-    get<T = any>(token: InstanceToken, moduleId?: string): InstanceLink<T>;
+    get<T = any>(token: InstanceToken): InstanceLink<T>;
+    get<T = any>(token: InstanceToken, options?: {
+        moduleId?: string;
+        each?: boolean;
+    }): InstanceLink<T> | Array<InstanceLink<T>>;
     private initialize;
     private addLink;
     private getInstanceNameByToken;

package/injector/instance-links-host.js

@@ -9,14 +9,17 @@ class InstanceLinksHost {
         this.instanceLinks = new Map();
         this.initialize();
     }
-    get(token, moduleId) {
-        const modulesMap = this.instanceLinks.get(token);
-        if (!modulesMap) {
+    get(token, options = {}) {
+        const instanceLinksForGivenToken = this.instanceLinks.get(token);
+        if (!instanceLinksForGivenToken) {
             throw new unknown_element_exception_1.UnknownElementException(this.getInstanceNameByToken(token));
         }
-        const instanceLink = moduleId
-            ? modulesMap.find(item => item.moduleId === moduleId)
-            : modulesMap[modulesMap.length - 1];
+        if (options.each) {
+            return instanceLinksForGivenToken;
+        }
+        const instanceLink = options.moduleId
+            ? instanceLinksForGivenToken.find(item => item.moduleId === options.moduleId)
+            : instanceLinksForGivenToken[instanceLinksForGivenToken.length - 1];
         if (!instanceLink) {
             throw new unknown_element_exception_1.UnknownElementException(this.getInstanceNameByToken(token));
         }

package/injector/instance-loader.js

@@ -4,7 +4,7 @@ exports.InstanceLoader = void 0;
 const common_1 = require("@nestjs/common");
 const messages_1 = require("../helpers/messages");
 const injector_1 = require("./injector");
-const internal_core_module_1 = require("./internal-core-module");
+const internal_core_module_1 = require("./internal-core-module/internal-core-module");
 class InstanceLoader {
     constructor(container, logger = new common_1.Logger(InstanceLoader.name, {
         timestamp: true,

package/injector/internal-core-module/index.d.ts

@@ -0,0 +1 @@
+export * from './internal-core-module';

package/injector/internal-core-module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./internal-core-module"), exports);

package/injector/{internal-core-module-factory.d.ts → internal-core-module/internal-core-module-factory.d.ts}

@@ -1,7 +1,7 @@
-import { HttpAdapterHost } from '../helpers/http-adapter-host';
-import { DependenciesScanner } from '../scanner';
-import { ModuleCompiler } from './compiler';
-import { NestContainer } from './container';
+import { HttpAdapterHost } from '../../helpers/http-adapter-host';
+import { DependenciesScanner } from '../../scanner';
+import { ModuleCompiler } from '../compiler';
+import { NestContainer } from '../container';
 export declare class InternalCoreModuleFactory {
     static create(container: NestContainer, scanner: DependenciesScanner, moduleCompiler: ModuleCompiler, httpAdapterHost: HttpAdapterHost): import("@nestjs/common").DynamicModule;
 }

package/injector/{internal-core-module-factory.js → internal-core-module/internal-core-module-factory.js}

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalCoreModuleFactory = void 0;
 const common_1 = require("@nestjs/common");
-const external_context_creator_1 = require("../helpers/external-context-creator");
-const http_adapter_host_1 = require("../helpers/http-adapter-host");
-const instance_loader_1 = require("./instance-loader");
+const external_context_creator_1 = require("../../helpers/external-context-creator");
+const http_adapter_host_1 = require("../../helpers/http-adapter-host");
+const instance_loader_1 = require("../instance-loader");
+const lazy_module_loader_1 = require("../lazy-module-loader/lazy-module-loader");
+const modules_container_1 = require("../modules-container");
 const internal_core_module_1 = require("./internal-core-module");
-const lazy_module_loader_1 = require("./lazy-module-loader");
-const modules_container_1 = require("./modules-container");
 class InternalCoreModuleFactory {
     static create(container, scanner, moduleCompiler, httpAdapterHost) {
         return internal_core_module_1.InternalCoreModule.register([

package/injector/{internal-core-module.js → internal-core-module/internal-core-module.js}

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalCoreModule = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
-const request_providers_1 = require("../router/request/request-providers");
-const services_1 = require("../services");
-const inquirer_providers_1 = require("./inquirer/inquirer-providers");
+const request_providers_1 = require("../../router/request/request-providers");
+const services_1 = require("../../services");
+const inquirer_providers_1 = require("../inquirer/inquirer-providers");
 const ReflectorAliasProvider = {
     provide: services_1.Reflector.name,
     useExisting: services_1.Reflector,

package/injector/{lazy-module-loader.d.ts → lazy-module-loader/lazy-module-loader.d.ts}

@@ -1,10 +1,10 @@
 import { DynamicModule, Type } from '@nestjs/common';
-import { DependenciesScanner } from '../scanner';
-import { ModuleCompiler } from './compiler';
-import { InstanceLoader } from './instance-loader';
+import { DependenciesScanner } from '../../scanner';
+import { ModuleCompiler } from '../compiler';
+import { InstanceLoader } from '../instance-loader';
+import { ModuleRef } from '../module-ref';
+import { ModulesContainer } from '../modules-container';
 import { LazyModuleLoaderLoadOptions } from './lazy-module-loader-options.interface';
-import { ModuleRef } from './module-ref';
-import { ModulesContainer } from './modules-container';
 export declare class LazyModuleLoader {
     private readonly dependenciesScanner;
     private readonly instanceLoader;

package/injector/{lazy-module-loader.js → lazy-module-loader/lazy-module-loader.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LazyModuleLoader = void 0;
-const silent_logger_1 = require("./silent-logger");
-const module_ref_1 = require("./module-ref");
+const silent_logger_1 = require("../helpers/silent-logger");
+const module_ref_1 = require("../module-ref");
 class LazyModuleLoader {
     constructor(dependenciesScanner, instanceLoader, moduleCompiler, modulesContainer) {
         this.dependenciesScanner = dependenciesScanner;

package/injector/module-ref.d.ts

@@ -1,25 +1,84 @@
 import { IntrospectionResult, Type } from '@nestjs/common';
+import { GetOrResolveOptions } from '@nestjs/common/interfaces';
+import { AbstractInstanceResolver } from './abstract-instance-resolver';
 import { NestContainer } from './container';
+import { Injector } from './injector';
+import { InstanceLinksHost } from './instance-links-host';
 import { ContextId } from './instance-wrapper';
 import { Module } from './module';
-export declare abstract class ModuleRef {
+export declare abstract class ModuleRef extends AbstractInstanceResolver {
     protected readonly container: NestContainer;
-    private readonly injector;
+    protected readonly injector: Injector;
     private _instanceLinksHost;
-    private get instanceLinksHost();
+    protected get instanceLinksHost(): InstanceLinksHost;
     constructor(container: NestContainer);
-    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: {
-        strict: boolean;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
     }): TResult;
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: ContextId, options?: {
-        strict: boolean;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
     }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
     abstract create<T = any>(type: Type<T>): Promise<T>;
     introspect<T = any>(token: Type<T> | string | symbol): IntrospectionResult;
     registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
-    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextModule?: Module): TResult;
-    protected resolvePerContext<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextModule: Module, contextId: ContextId, options?: {
-        strict: boolean;
-    }): Promise<TResult>;
     protected instantiateClass<T = any>(type: Type<T>, moduleRef: Module): Promise<T>;
 }

package/injector/module-ref.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleRef = void 0;
 const common_1 = require("@nestjs/common");
-const invalid_class_scope_exception_1 = require("../errors/exceptions/invalid-class-scope.exception");
-const unknown_element_exception_1 = require("../errors/exceptions/unknown-element.exception");
 const get_class_scope_1 = require("../helpers/get-class-scope");
 const is_durable_1 = require("../helpers/is-durable");
+const abstract_instance_resolver_1 = require("./abstract-instance-resolver");
 const injector_1 = require("./injector");
 const instance_links_host_1 = require("./instance-links-host");
 const instance_wrapper_1 = require("./instance-wrapper");
-class ModuleRef {
+class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
     constructor(container) {
+        super();
         this.container = container;
         this.injector = new injector_1.Injector();
     }
@@ -34,31 +34,6 @@ class ModuleRef {
     registerRequestByContextId(request, contextId) {
         this.container.registerRequestProvider(request, contextId);
     }
-    find(typeOrToken, contextModule) {
-        const moduleId = contextModule && contextModule.id;
-        const { wrapperRef } = this.instanceLinksHost.get(typeOrToken, moduleId);
-        if (wrapperRef.scope === common_1.Scope.REQUEST ||
-            wrapperRef.scope === common_1.Scope.TRANSIENT) {
-            throw new invalid_class_scope_exception_1.InvalidClassScopeException(typeOrToken);
-        }
-        return wrapperRef.instance;
-    }
-    async resolvePerContext(typeOrToken, contextModule, contextId, options) {
-        const isStrictModeEnabled = options && options.strict;
-        const instanceLink = isStrictModeEnabled
-            ? this.instanceLinksHost.get(typeOrToken, contextModule.id)
-            : this.instanceLinksHost.get(typeOrToken);
-        const { wrapperRef, collection } = instanceLink;
-        if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient) {
-            return this.get(typeOrToken, options);
-        }
-        const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
-        const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);
-        if (!instance) {
-            throw new unknown_element_exception_1.UnknownElementException();
-        }
-        return instance;
-    }
     async instantiateClass(type, moduleRef) {
         const wrapper = new instance_wrapper_1.InstanceWrapper({
             name: type && type.name,

package/injector/module.d.ts

@@ -1,5 +1,4 @@
-import { ClassProvider, Controller, DynamicModule, ExistingProvider, FactoryProvider, Injectable, InjectionToken, NestModule, Provider, ValueProvider } from '@nestjs/common/interfaces';
-import { Type } from '@nestjs/common/interfaces/type.interface';
+import { ClassProvider, Controller, DynamicModule, ExistingProvider, FactoryProvider, Injectable, InjectionToken, NestModule, Provider, Type, ValueProvider } from '@nestjs/common/interfaces';
 import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
 import { ModuleRef } from './module-ref';

package/injector/module.js

@@ -5,9 +5,7 @@ const random_string_generator_util_1 = require("@nestjs/common/utils/random-stri
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
 const application_config_1 = require("../application-config");
-const invalid_class_exception_1 = require("../errors/exceptions/invalid-class.exception");
-const runtime_exception_1 = require("../errors/exceptions/runtime.exception");
-const unknown_export_exception_1 = require("../errors/exceptions/unknown-export.exception");
+const exceptions_1 = require("../errors/exceptions");
 const context_id_factory_1 = require("../helpers/context-id-factory");
 const get_class_scope_1 = require("../helpers/get-class-scope");
 const is_durable_1 = require("../helpers/is-durable");
@@ -75,7 +73,7 @@ class Module {
     }
     get instance() {
         if (!this._providers.has(this._metatype)) {
-            throw new runtime_exception_1.RuntimeException();
+            throw new exceptions_1.RuntimeException();
         }
         const module = this._providers.get(this._metatype);
         return module.instance;
@@ -288,7 +286,7 @@ class Module {
         if (!imports.includes(token)) {
             const { name } = this.metatype;
             const providerName = (0, shared_utils_1.isFunction)(token) ? token.name : token;
-            throw new unknown_export_exception_1.UnknownExportException(providerName, name);
+            throw new exceptions_1.UnknownExportException(providerName, name);
         }
         return token;
     }
@@ -347,15 +345,18 @@ class Module {
             }
             get(typeOrToken, options = { strict: true }) {
                 return !(options && options.strict)
-                    ? this.find(typeOrToken)
-                    : this.find(typeOrToken, self);
+                    ? this.find(typeOrToken, options)
+                    : this.find(typeOrToken, {
+                        moduleId: self.id,
+                        each: options.each,
+                    });
             }
             resolve(typeOrToken, contextId = (0, context_id_factory_1.createContextId)(), options = { strict: true }) {
                 return this.resolvePerContext(typeOrToken, self, contextId, options);
             }
             async create(type) {
                 if (!(type && (0, shared_utils_1.isFunction)(type) && type.prototype)) {
-                    throw new invalid_class_exception_1.InvalidClassException(type);
+                    throw new exceptions_1.InvalidClassException(type);
                 }
                 return this.instantiateClass(type, self);
             }