@nestjs/core 9.1.5 → 9.2.0

package/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interceptors-consumer';
+export * from './interceptors-context-creator';

package/interceptors/index.js

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

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

@@ -1,11 +1,13 @@
 import { HttpServer } from '@nestjs/common';
-import { MiddlewareConfiguration, RouteInfo } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
+import { MiddlewareConfiguration, RouteInfo } from '@nestjs/common/interfaces/middleware';
 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,23 +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 invalid_class_scope_exception_1 = require("./errors/exceptions/invalid-class-scope.exception");
-const unknown_element_exception_1 = require("./errors/exceptions/unknown-element.exception");
-const unknown_module_exception_1 = require("./errors/exceptions/unknown-module.exception");
+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;
@@ -38,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;
@@ -47,18 +50,34 @@ class NestApplicationContext {
         const token = moduleTokenFactory.create(type, dynamicMetadata);
         const selectedModule = modulesContainer.get(token);
         if (!selectedModule) {
-            throw new unknown_module_exception_1.UnknownModuleException();
+            throw new exceptions_1.UnknownModuleException();
         }
         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);
     }
@@ -77,6 +96,10 @@ class NestApplicationContext {
         this.isInitialized = true;
         return this;
     }
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
     async close() {
         await this.callDestroyHook();
         await this.callBeforeShutdownHook();
@@ -84,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();
     }
@@ -218,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 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;
-    }
     getModulesSortedByDistance() {
         if (this._moduleRefsByDistance) {
             return this._moduleRefsByDistance;

package/nest-application.d.ts

@@ -1,7 +1,6 @@
 import { CanActivate, ExceptionFilter, HttpServer, INestApplication, INestMicroservice, NestHybridApplicationOptions, NestInterceptor, PipeTransform, VersioningOptions, WebSocketAdapter } from '@nestjs/common';
+import { GlobalPrefixOptions, NestApplicationOptions } from '@nestjs/common/interfaces';
 import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
-import { GlobalPrefixOptions } from '@nestjs/common/interfaces/global-prefix-options.interface';
-import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
 import { AbstractHttpAdapter } from './adapters';
 import { ApplicationConfig } from './application-config';
 import { NestContainer } from './injector/container';

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.5",
+  "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.5"
+    "@nestjs/common": "9.2.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^9.0.0",

package/pipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './params-token-factory';
+export * from './pipes-consumer';
+export * from './pipes-context-creator';

package/pipes/index.js

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

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.d.ts

@@ -2,8 +2,7 @@ import { CanActivate, HttpServer, ParamData, PipeTransform, RequestMethod } from
 import { RouteParamMetadata } from '@nestjs/common/decorators';
 import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
 import { ContextType, Controller } from '@nestjs/common/interfaces';
-import { GuardsConsumer } from '../guards/guards-consumer';
-import { GuardsContextCreator } from '../guards/guards-context-creator';
+import { GuardsConsumer, GuardsContextCreator } from '../guards';
 import { ExecutionContextHost } from '../helpers/execution-context-host';
 import { HandleResponseFn, HandlerMetadata } from '../helpers/handler-metadata-storage';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';

package/router/router-execution-context.js

@@ -5,10 +5,10 @@ const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
 const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const constants_2 = require("../guards/constants");
+const guards_1 = require("../guards");
 const context_utils_1 = require("../helpers/context-utils");
 const handler_metadata_storage_1 = require("../helpers/handler-metadata-storage");
-const constants_3 = require("../injector/constants");
+const constants_2 = require("../injector/constants");
 const router_response_controller_1 = require("./router-response-controller");
 class RouterExecutionContext {
     constructor(paramsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, applicationRef) {
@@ -24,7 +24,7 @@ class RouterExecutionContext {
         this.contextUtils = new context_utils_1.ContextUtils();
         this.responseController = new router_response_controller_1.RouterResponseController(applicationRef);
     }
-    create(instance, callback, methodName, moduleKey, requestMethod, contextId = constants_3.STATIC_CONTEXT, inquirerId) {
+    create(instance, callback, methodName, moduleKey, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
         const contextType = 'http';
         const { argsLength, fnHandleResponse, paramtypes, getParamsMetadata, httpStatusCode, responseHeaders, hasCustomHeaders, } = this.getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType);
         const paramsOptions = this.contextUtils.mergeParamsMetatypes(getParamsMetadata(moduleKey, contextId, inquirerId), paramtypes);
@@ -57,7 +57,7 @@ class RouterExecutionContext {
         const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
         const paramtypes = this.contextUtils.reflectCallbackParamtypes(instance, methodName);
         const contextFactory = this.contextUtils.getContextFactory(contextType, instance, callback);
-        const getParamsMetadata = (moduleKey, contextId = constants_3.STATIC_CONTEXT, inquirerId) => this.exchangeKeysForValues(keys, metadata, moduleKey, contextId, inquirerId, contextFactory);
+        const getParamsMetadata = (moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) => this.exchangeKeysForValues(keys, metadata, moduleKey, contextId, inquirerId, contextFactory);
         const paramsMetadata = getParamsMetadata(moduleKey);
         const isResponseHandled = this.isResponseHandled(instance, methodName, paramsMetadata);
         const httpRedirectResponse = this.reflectRedirect(callback);
@@ -95,7 +95,7 @@ class RouterExecutionContext {
     reflectSse(callback) {
         return Reflect.getMetadata(constants_1.SSE_METADATA, callback);
     }
-    exchangeKeysForValues(keys, metadata, moduleContext, contextId = constants_3.STATIC_CONTEXT, inquirerId, contextFactory) {
+    exchangeKeysForValues(keys, metadata, moduleContext, contextId = constants_2.STATIC_CONTEXT, inquirerId, contextFactory) {
         this.pipesContextCreator.setModuleContext(moduleContext);
         return keys.map(key => {
             const { index, data, pipes: pipesCollection } = metadata[key];
@@ -133,7 +133,7 @@ class RouterExecutionContext {
         const canActivateFn = async (args) => {
             const canActivate = await this.guardsConsumer.tryActivate(guards, args, instance, callback, contextType);
             if (!canActivate) {
-                throw new common_1.ForbiddenException(constants_2.FORBIDDEN_MESSAGE);
+                throw new common_1.ForbiddenException(guards_1.FORBIDDEN_MESSAGE);
             }
         };
         return guards.length ? canActivateFn : null;
@@ -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.d.ts

@@ -1,5 +1,5 @@
 import { HttpServer } from '@nestjs/common';
-import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
+import { RequestMethod } from '@nestjs/common/enums';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { VersionValue } from '@nestjs/common/interfaces/version-options.interface';

package/router/router-explorer.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterExplorer = void 0;
 const constants_1 = require("@nestjs/common/constants");
-const version_type_enum_1 = require("@nestjs/common/enums/version-type.enum");
+const enums_1 = require("@nestjs/common/enums");
 const exceptions_1 = require("@nestjs/common/exceptions");
 const logger_service_1 = require("@nestjs/common/services/logger.service");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
@@ -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));
@@ -109,7 +109,7 @@ class RouterExplorer {
         let routeHandler = this.applyHostFilter(host, proxy);
         paths.forEach(path => {
             if (isVersioned &&
-                routePathMetadata.versioningOptions.type !== version_type_enum_1.VersioningType.URI) {
+                routePathMetadata.versioningOptions.type !== enums_1.VersioningType.URI) {
                 // All versioning (except for URI Versioning) is done via the "Version Filter"
                 routeHandler = this.applyVersionFilter(router, routePathMetadata, routeHandler);
             }