@nestjs/core 9.1.6 → 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/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/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

@@ -5,7 +5,7 @@ const constants_1 = require("@nestjs/common/constants");
 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");

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,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleRef = void 0;
 const common_1 = require("@nestjs/common");
-const exceptions_1 = require("../errors/exceptions");
 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();
     }
@@ -33,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 exceptions_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 exceptions_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

@@ -345,8 +345,11 @@ 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);

package/middleware/builder.d.ts

@@ -1,6 +1,5 @@
 import { HttpServer, MiddlewareConsumer, Type } from '@nestjs/common/interfaces';
-import { MiddlewareConfigProxy } from '@nestjs/common/interfaces/middleware';
-import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
+import { MiddlewareConfigProxy, MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware';
 import { RoutesMapper } from './routes-mapper';
 export declare class MiddlewareBuilder implements MiddlewareConsumer {
     private readonly routesMapper;

package/middleware/middleware-module.d.ts

@@ -4,8 +4,10 @@ import { ApplicationConfig } from '../application-config';
 import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { Module } from '../injector/module';
+import { RoutePathFactory } from '../router/route-path-factory';
 import { MiddlewareContainer } from './container';
 export declare class MiddlewareModule {
+    private readonly routePathFactory;
     private readonly routerProxy;
     private readonly exceptionFiltersCache;
     private injector;
@@ -15,6 +17,7 @@ export declare class MiddlewareModule {
     private config;
     private container;
     private httpAdapter;
+    constructor(routePathFactory: RoutePathFactory);
     register(middlewareContainer: MiddlewareContainer, container: NestContainer, config: ApplicationConfig, injector: Injector, httpAdapter: HttpServer): Promise<void>;
     resolveMiddleware(middlewareContainer: MiddlewareContainer, modules: Map<string, Module>): Promise<void>;
     loadConfiguration(middlewareContainer: MiddlewareContainer, moduleRef: Module, moduleKey: string): Promise<void>;

package/middleware/middleware-module.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MiddlewareModule = void 0;
+const common_1 = require("@nestjs/common");
 const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_middleware_exception_1 = require("../errors/exceptions/invalid-middleware.exception");
@@ -16,7 +17,8 @@ const builder_1 = require("./builder");
 const resolver_1 = require("./resolver");
 const routes_mapper_1 = require("./routes-mapper");
 class MiddlewareModule {
-    constructor() {
+    constructor(routePathFactory) {
+        this.routePathFactory = routePathFactory;
         this.routerProxy = new router_proxy_1.RouterProxy();
         this.exceptionFiltersCache = new WeakMap();
     }
@@ -86,10 +88,10 @@ class MiddlewareModule {
             if (instanceWrapper.isTransient) {
                 return;
             }
-            await this.bindHandler(instanceWrapper, applicationRef, routeInfo.method, routeInfo.path, moduleRef, collection);
+            await this.bindHandler(instanceWrapper, applicationRef, routeInfo, moduleRef, collection);
         }
     }
-    async bindHandler(wrapper, applicationRef, method, path, moduleRef, collection) {
+    async bindHandler(wrapper, applicationRef, routeInfo, moduleRef, collection) {
         const { instance, metatype } = wrapper;
         if ((0, shared_utils_1.isUndefined)(instance === null || instance === void 0 ? void 0 : instance.use)) {
             throw new invalid_middleware_exception_1.InvalidMiddlewareException(metatype.name);
@@ -97,9 +99,9 @@ class MiddlewareModule {
         const isStatic = wrapper.isDependencyTreeStatic();
         if (isStatic) {
             const proxy = await this.createProxy(instance);
-            return this.registerHandler(applicationRef, method, path, proxy);
+            return this.registerHandler(applicationRef, routeInfo, proxy);
         }
-        await this.registerHandler(applicationRef, method, path, async (req, res, next) => {
+        await this.registerHandler(applicationRef, routeInfo, async (req, res, next) => {
             try {
                 const contextId = context_id_factory_1.ContextIdFactory.getByRequest(req);
                 if (!req[request_constants_1.REQUEST_CONTEXT_ID]) {
@@ -131,7 +133,7 @@ class MiddlewareModule {
         const middleware = instance.use.bind(instance);
         return this.routerProxy.createProxy(middleware, exceptionsHandler);
     }
-    async registerHandler(applicationRef, method, path, proxy) {
+    async registerHandler(applicationRef, { path, method, version }, proxy) {
         const prefix = this.config.getGlobalPrefix();
         const excludedRoutes = this.config.getGlobalPrefixOptions().exclude;
         if ((Array.isArray(excludedRoutes) &&
@@ -148,6 +150,11 @@ class MiddlewareModule {
             }
             path = basePath + path;
         }
+        const applicationVersioningConfig = this.config.getVersioning();
+        if (version && applicationVersioningConfig.type === common_1.VersioningType.URI) {
+            const versionPrefix = this.routePathFactory.getVersionPrefix(applicationVersioningConfig);
+            path = `/${versionPrefix}${version.toString()}${path}`;
+        }
         const isMethodAll = (0, utils_1.isRequestMethodAll)(method);
         const requestMethod = request_method_enum_1.RequestMethod[method];
         const router = await applicationRef.createMiddlewareFactory(method);

package/middleware/routes-mapper.d.ts

@@ -5,6 +5,9 @@ export declare class RoutesMapper {
     private readonly routerExplorer;
     constructor(container: NestContainer);
     mapRouteToRouteInfo(route: Type<any> | RouteInfo | string): RouteInfo[];
+    private getRouteInfoFromPath;
+    private getRouteInfoFromObject;
+    private getRouteInfoFromController;
     private isRouteInfo;
     private normalizeGlobalPath;
     private getRoutePath;

package/middleware/routes-mapper.js

@@ -13,39 +13,54 @@ class RoutesMapper {
     }
     mapRouteToRouteInfo(route) {
         if ((0, shared_utils_1.isString)(route)) {
-            const defaultRequestMethod = -1;
-            return [
-                {
-                    path: (0, shared_utils_1.addLeadingSlash)(route),
-                    method: defaultRequestMethod,
-                },
-            ];
+            return this.getRouteInfoFromPath(route);
         }
         const routePathOrPaths = this.getRoutePath(route);
         if (this.isRouteInfo(routePathOrPaths, route)) {
-            return [
-                {
-                    path: (0, shared_utils_1.addLeadingSlash)(route.path),
-                    method: route.method,
-                },
-            ];
+            return this.getRouteInfoFromObject(route);
         }
-        const controllerPaths = this.routerExplorer.scanForPaths(Object.create(route), route.prototype);
-        const moduleRef = this.getHostModuleOfController(route);
+        return this.getRouteInfoFromController(route, routePathOrPaths);
+    }
+    getRouteInfoFromPath(routePath) {
+        const defaultRequestMethod = -1;
+        return [
+            {
+                path: (0, shared_utils_1.addLeadingSlash)(routePath),
+                method: defaultRequestMethod,
+            },
+        ];
+    }
+    getRouteInfoFromObject(routeInfoObject) {
+        const routeInfo = {
+            path: (0, shared_utils_1.addLeadingSlash)(routeInfoObject.path),
+            method: routeInfoObject.method,
+        };
+        if (routeInfoObject.version) {
+            routeInfo.version = routeInfoObject.version;
+        }
+        return [routeInfo];
+    }
+    getRouteInfoFromController(controller, routePath) {
+        const controllerPaths = this.routerExplorer.scanForPaths(Object.create(controller), controller.prototype);
+        const moduleRef = this.getHostModuleOfController(controller);
         const modulePath = this.getModulePath(moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype);
         const concatPaths = (acc, currentValue) => acc.concat(currentValue);
         return []
-            .concat(routePathOrPaths)
+            .concat(routePath)
             .map(routePath => controllerPaths
             .map(item => {
             var _a;
             return (_a = item.path) === null || _a === void 0 ? void 0 : _a.map(p => {
                 let path = modulePath !== null && modulePath !== void 0 ? modulePath : '';
                 path += this.normalizeGlobalPath(routePath) + (0, shared_utils_1.addLeadingSlash)(p);
-                return {
+                const routeInfo = {
                     path,
                     method: item.requestMethod,
                 };
+                if (item.version) {
+                    routeInfo.version = item.version;
+                }
+                return routeInfo;
             });
         })
             .reduce(concatPaths, []))

package/nest-application-context.d.ts

@@ -1,14 +1,15 @@
 import { INestApplicationContext, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
-import { Abstract, DynamicModule } from '@nestjs/common/interfaces';
-import { Type } from '@nestjs/common/interfaces/type.interface';
+import { DynamicModule, Type } from '@nestjs/common/interfaces';
+import { AbstractInstanceResolver } from './injector/abstract-instance-resolver';
 import { NestContainer } from './injector/container';
 import { Injector } from './injector/injector';
+import { InstanceLinksHost } from './injector/instance-links-host';
 import { ContextId } from './injector/instance-wrapper';
 import { Module } from './injector/module';
 /**
  * @publicApi
  */
-export declare class NestApplicationContext implements INestApplicationContext {
+export declare class NestApplicationContext extends AbstractInstanceResolver implements INestApplicationContext {
     protected readonly container: NestContainer;
     private readonly scope;
     private contextModule;
@@ -20,16 +21,71 @@ export declare class NestApplicationContext implements INestApplicationContext {
     private shutdownCleanupRef?;
     private _instanceLinksHost;
     private _moduleRefsByDistance?;
-    private get instanceLinksHost();
+    protected get instanceLinksHost(): InstanceLinksHost;
     constructor(container: NestContainer, scope?: Type<any>[], contextModule?: Module);
     selectContextModule(): void;
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {INestApplicationContext}
+     */
     select<T>(moduleType: Type<T> | DynamicModule): INestApplicationContext;
-    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, options?: {
-        strict: boolean;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    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}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
     }): TResult;
-    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextId?: ContextId, options?: {
-        strict: boolean;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    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>}
+     */
+    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>}
+     */
+    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>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
     registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
     /**
      * Initializes the Nest application.
@@ -38,8 +94,21 @@ export declare class NestApplicationContext implements INestApplicationContext {
      * @returns {Promise<this>} The NestApplicationContext instance as Promise
      */
     init(): Promise<this>;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
     close(): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
     useLogger(logger: LoggerService | LogLevel[] | false): void;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
     flushLogs(): void;
     /**
      * Define that it must flush logs right after defining a custom logger.
@@ -92,9 +161,5 @@ export declare class NestApplicationContext implements INestApplicationContext {
      * modules and children.
      */
     protected callBeforeShutdownHook(signal?: string): Promise<void>;
-    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextModule?: Module): TResult;
-    protected resolvePerContext<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextModule: Module, contextId: ContextId, options?: {
-        strict: boolean;
-    }): Promise<TResult>;
     private getModulesSortedByDistance;
 }

package/nest-application-context.js

@@ -2,21 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestApplicationContext = void 0;
 const common_1 = require("@nestjs/common");
-const interfaces_1 = require("@nestjs/common/interfaces");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
 const constants_1 = require("./constants");
 const exceptions_1 = require("./errors/exceptions");
 const context_id_factory_1 = require("./helpers/context-id-factory");
 const hooks_1 = require("./hooks");
+const abstract_instance_resolver_1 = require("./injector/abstract-instance-resolver");
 const compiler_1 = require("./injector/compiler");
 const injector_1 = require("./injector/injector");
 const instance_links_host_1 = require("./injector/instance-links-host");
 /**
  * @publicApi
  */
-class NestApplicationContext {
+class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstanceResolver {
     constructor(container, scope = new Array(), contextModule = null) {
+        super();
         this.container = container;
         this.scope = scope;
         this.contextModule = contextModule;
@@ -36,6 +37,10 @@ class NestApplicationContext {
         const modules = this.container.getModules().values();
         this.contextModule = modules.next().value;
     }
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {INestApplicationContext}
+     */
     select(moduleType) {
         const modulesContainer = this.container.getModules();
         const contextModuleCtor = this.contextModule.metatype;
@@ -49,14 +54,30 @@ class NestApplicationContext {
         }
         return new NestApplicationContext(this.container, scope, selectedModule);
     }
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
     get(typeOrToken, options = { strict: false }) {
+        var _a;
         return !(options && options.strict)
-            ? this.find(typeOrToken)
-            : this.find(typeOrToken, this.contextModule);
+            ? this.find(typeOrToken, options)
+            : this.find(typeOrToken, {
+                moduleId: (_a = this.contextModule) === null || _a === void 0 ? void 0 : _a.id,
+                each: options.each,
+            });
     }
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
     resolve(typeOrToken, contextId = (0, context_id_factory_1.createContextId)(), options = { strict: false }) {
         return this.resolvePerContext(typeOrToken, this.contextModule, contextId, options);
     }
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
     registerRequestByContextId(request, contextId) {
         this.container.registerRequestProvider(request, contextId);
     }
@@ -75,6 +96,10 @@ class NestApplicationContext {
         this.isInitialized = true;
         return this;
     }
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
     async close() {
         await this.callDestroyHook();
         await this.callBeforeShutdownHook();
@@ -82,12 +107,21 @@ class NestApplicationContext {
         await this.callShutdownHook();
         this.unsubscribeFromProcessSignals();
     }
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
     useLogger(logger) {
         common_1.Logger.overrideLogger(logger);
         if (this.shouldFlushLogsOnOverride) {
             this.flushLogs();
         }
     }
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
     flushLogs() {
         common_1.Logger.flush();
     }
@@ -216,31 +250,6 @@ class NestApplicationContext {
             await (0, hooks_1.callBeforeAppShutdownHook)(module, signal);
         }
     }
-    find(typeOrToken, contextModule) {
-        const moduleId = contextModule && contextModule.id;
-        const { wrapperRef } = this.instanceLinksHost.get(typeOrToken, moduleId);
-        if (wrapperRef.scope === interfaces_1.Scope.REQUEST ||
-            wrapperRef.scope === interfaces_1.Scope.TRANSIENT) {
-            throw new exceptions_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 exceptions_1.UnknownElementException();
-        }
-        return instance;
-    }
     getModulesSortedByDistance() {
         if (this._moduleRefsByDistance) {
             return this._moduleRefsByDistance;

package/nest-application.js

@@ -14,6 +14,7 @@ const optional_require_1 = require("./helpers/optional-require");
 const container_1 = require("./middleware/container");
 const middleware_module_1 = require("./middleware/middleware-module");
 const nest_application_context_1 = require("./nest-application-context");
+const route_path_factory_1 = require("./router/route-path-factory");
 const routes_resolver_1 = require("./router/routes-resolver");
 const { SocketModule } = (0, optional_require_1.optionalRequire)('@nestjs/websockets/socket-module', () => require('@nestjs/websockets/socket-module'));
 const { MicroservicesModule } = (0, optional_require_1.optionalRequire)('@nestjs/microservices/microservices-module', () => require('@nestjs/microservices/microservices-module'));
@@ -29,7 +30,6 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.logger = new logger_service_1.Logger(NestApplication.name, {
             timestamp: true,
         });
-        this.middlewareModule = new middleware_module_1.MiddlewareModule();
         this.middlewareContainer = new container_1.MiddlewareContainer(this.container);
         this.microservicesModule = MicroservicesModule && new MicroservicesModule();
         this.socketModule = SocketModule && new SocketModule();
@@ -37,6 +37,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.isListening = false;
         this.selectContextModule();
         this.registerHttpServer();
+        this.middlewareModule = new middleware_module_1.MiddlewareModule(new route_path_factory_1.RoutePathFactory(config));
         this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector);
     }
     async dispose() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "9.1.6",
+  "version": "9.2.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -32,11 +32,11 @@
     "iterare": "1.2.1",
     "object-hash": "3.0.0",
     "path-to-regexp": "3.2.0",
-    "tslib": "2.4.0",
+    "tslib": "2.4.1",
     "uuid": "9.0.0"
   },
   "devDependencies": {
-    "@nestjs/common": "9.1.6"
+    "@nestjs/common": "9.2.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^9.0.0",

package/repl/repl-context.js

@@ -4,7 +4,7 @@ exports.ReplContext = void 0;
 const common_1 = require("@nestjs/common");
 const application_config_1 = require("../application-config");
 const injector_1 = require("../injector");
-const internal_core_module_1 = require("../injector/internal-core-module");
+const internal_core_module_1 = require("../injector/internal-core-module/internal-core-module");
 const native_functions_1 = require("./native-functions");
 class ReplContext {
     constructor(app, nativeFunctionsClassRefs) {

package/repl/repl.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="node" />
-import { Type } from '@nestjs/common';
-export declare function repl(module: Type): Promise<import("repl").REPLServer>;
+import { DynamicModule, Type } from '@nestjs/common';
+export declare function repl(module: Type | DynamicModule): Promise<import("repl").REPLServer>;

package/router/router-execution-context.js

@@ -174,6 +174,7 @@ class RouterExecutionContext {
             result = await this.responseController.transformToResult(result);
             !isResponseHandled &&
                 (await this.responseController.apply(result, res, httpStatusCode));
+            return res;
         };
     }
     isResponseHandled(instance, methodName, paramsMetadata) {

package/router/router-explorer.js

@@ -53,7 +53,7 @@ class RouterExplorer {
     extractRouterPath(metatype) {
         const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
         if ((0, shared_utils_1.isUndefined)(path)) {
-            throw new unknown_request_mapping_exception_1.UnknownRequestMappingException();
+            throw new unknown_request_mapping_exception_1.UnknownRequestMappingException(metatype);
         }
         if (Array.isArray(path)) {
             return path.map(p => (0, shared_utils_1.addLeadingSlash)(p));

package/scanner.js

@@ -14,7 +14,7 @@ const invalid_class_module_exception_1 = require("./errors/exceptions/invalid-cl
 const invalid_module_exception_1 = require("./errors/exceptions/invalid-module.exception");
 const undefined_module_exception_1 = require("./errors/exceptions/undefined-module.exception");
 const get_class_scope_1 = require("./helpers/get-class-scope");
-const internal_core_module_factory_1 = require("./injector/internal-core-module-factory");
+const internal_core_module_factory_1 = require("./injector/internal-core-module/internal-core-module-factory");
 class DependenciesScanner {
     constructor(container, metadataScanner, applicationConfig = new application_config_1.ApplicationConfig()) {
         this.container = container;