@nestjs/core 11.1.16 → 12.0.0-alpha.0

package/router/router-execution-context.js

@@ -1,16 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterExecutionContext = void 0;
-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 guards_1 = require("../guards");
-const context_utils_1 = require("../helpers/context-utils");
-const handler_metadata_storage_1 = require("../helpers/handler-metadata-storage");
-const constants_2 = require("../injector/constants");
-const router_response_controller_1 = require("./router-response-controller");
-class RouterExecutionContext {
+import { ForbiddenException, } from '@nestjs/common';
+import { CUSTOM_ROUTE_ARGS_METADATA, HEADERS_METADATA, HTTP_CODE_METADATA, isEmptyArray, isString, REDIRECT_METADATA, RENDER_METADATA, ROUTE_ARGS_METADATA, RouteParamtypes, SSE_METADATA, } from '@nestjs/common/internal';
+import { FORBIDDEN_MESSAGE, } from '../guards/index.js';
+import { ContextUtils } from '../helpers/context-utils.js';
+import { HandlerMetadataStorage, } from '../helpers/handler-metadata-storage.js';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { RouterResponseController, } from './router-response-controller.js';
+export class RouterExecutionContext {
+    paramsFactory;
+    pipesContextCreator;
+    pipesConsumer;
+    guardsContextCreator;
+    guardsConsumer;
+    interceptorsContextCreator;
+    interceptorsConsumer;
+    applicationRef;
+    handlerMetadataStorage = new HandlerMetadataStorage();
+    contextUtils = new ContextUtils();
+    responseController;
     constructor(paramsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, applicationRef) {
         this.paramsFactory = paramsFactory;
         this.pipesContextCreator = pipesContextCreator;
@@ -20,11 +26,9 @@ class RouterExecutionContext {
         this.interceptorsContextCreator = interceptorsContextCreator;
         this.interceptorsConsumer = interceptorsConsumer;
         this.applicationRef = applicationRef;
-        this.handlerMetadataStorage = new handler_metadata_storage_1.HandlerMetadataStorage();
-        this.contextUtils = new context_utils_1.ContextUtils();
-        this.responseController = new router_response_controller_1.RouterResponseController(applicationRef);
+        this.responseController = new RouterResponseController(applicationRef);
     }
-    create(instance, callback, methodName, moduleKey, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    create(instance, callback, methodName, moduleKey, requestMethod, contextId = 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);
@@ -52,22 +56,20 @@ class RouterExecutionContext {
         if (cacheMetadata) {
             return cacheMetadata;
         }
-        const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, constants_1.ROUTE_ARGS_METADATA) || {};
+        const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, ROUTE_ARGS_METADATA) || {};
         const keys = Object.keys(metadata);
         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_2.STATIC_CONTEXT, inquirerId) => this.exchangeKeysForValues(keys, metadata, moduleKey, contextId, inquirerId, contextFactory);
+        const getParamsMetadata = (moduleKey, contextId = 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);
         const fnHandleResponse = this.createHandleResponseFn(callback, isResponseHandled, httpRedirectResponse);
         const httpCode = this.reflectHttpStatusCode(callback);
-        const httpStatusCode = httpCode
-            ? httpCode
-            : this.responseController.getStatusByMethod(requestMethod);
+        const httpStatusCode = httpCode ?? this.responseController.getStatusByMethod(requestMethod);
         const responseHeaders = this.reflectResponseHeaders(callback);
-        const hasCustomHeaders = !(0, shared_utils_1.isEmpty)(responseHeaders);
+        const hasCustomHeaders = !isEmptyArray(responseHeaders);
         const handlerMetadata = {
             argsLength,
             fnHandleResponse,
@@ -81,30 +83,37 @@ class RouterExecutionContext {
         return handlerMetadata;
     }
     reflectRedirect(callback) {
-        return Reflect.getMetadata(constants_1.REDIRECT_METADATA, callback);
+        return Reflect.getMetadata(REDIRECT_METADATA, callback);
     }
     reflectHttpStatusCode(callback) {
-        return Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, callback);
+        return Reflect.getMetadata(HTTP_CODE_METADATA, callback);
     }
     reflectRenderTemplate(callback) {
-        return Reflect.getMetadata(constants_1.RENDER_METADATA, callback);
+        return Reflect.getMetadata(RENDER_METADATA, callback);
     }
     reflectResponseHeaders(callback) {
-        return Reflect.getMetadata(constants_1.HEADERS_METADATA, callback) || [];
+        return Reflect.getMetadata(HEADERS_METADATA, callback) || [];
     }
     reflectSse(callback) {
-        return Reflect.getMetadata(constants_1.SSE_METADATA, callback);
+        return Reflect.getMetadata(SSE_METADATA, callback);
     }
-    exchangeKeysForValues(keys, metadata, moduleContext, contextId = constants_2.STATIC_CONTEXT, inquirerId, contextFactory) {
+    exchangeKeysForValues(keys, metadata, moduleContext, contextId = STATIC_CONTEXT, inquirerId, contextFactory) {
         this.pipesContextCreator.setModuleContext(moduleContext);
         return keys.map(key => {
-            const { index, data, pipes: pipesCollection } = metadata[key];
+            const { index, data, pipes: pipesCollection, schema } = metadata[key];
             const pipes = this.pipesContextCreator.createConcreteContext(pipesCollection, contextId, inquirerId);
             const type = this.contextUtils.mapParamType(key);
-            if (key.includes(constants_1.CUSTOM_ROUTE_ARGS_METADATA)) {
+            if (key.includes(CUSTOM_ROUTE_ARGS_METADATA)) {
                 const { factory } = metadata[key];
                 const customExtractValue = this.contextUtils.getCustomFactory(factory, data, contextFactory);
-                return { index, extractValue: customExtractValue, type, data, pipes };
+                return {
+                    index,
+                    extractValue: customExtractValue,
+                    type,
+                    data,
+                    pipes,
+                    schema,
+                };
             }
             const numericType = Number(type);
             const extractValue = (req, res, next) => this.paramsFactory.exchangeKeyForValue(numericType, data, {
@@ -112,29 +121,29 @@ class RouterExecutionContext {
                 res,
                 next,
             });
-            return { index, extractValue, type: numericType, data, pipes };
+            return { index, extractValue, type: numericType, data, pipes, schema };
         });
     }
-    async getParamValue(value, { metatype, type, data, }, pipes) {
-        if (!(0, shared_utils_1.isEmpty)(pipes)) {
-            return this.pipesConsumer.apply(value, { metatype, type, data }, pipes);
+    async getParamValue(value, metadata, pipes) {
+        if (!isEmptyArray(pipes)) {
+            return this.pipesConsumer.apply(value, metadata, pipes);
         }
         return value;
     }
     isPipeable(type) {
-        return (type === route_paramtypes_enum_1.RouteParamtypes.BODY ||
-            type === route_paramtypes_enum_1.RouteParamtypes.RAW_BODY ||
-            type === route_paramtypes_enum_1.RouteParamtypes.QUERY ||
-            type === route_paramtypes_enum_1.RouteParamtypes.PARAM ||
-            type === route_paramtypes_enum_1.RouteParamtypes.FILE ||
-            type === route_paramtypes_enum_1.RouteParamtypes.FILES ||
-            (0, shared_utils_1.isString)(type));
+        return (type === RouteParamtypes.BODY ||
+            type === RouteParamtypes.RAW_BODY ||
+            type === RouteParamtypes.QUERY ||
+            type === RouteParamtypes.PARAM ||
+            type === RouteParamtypes.FILE ||
+            type === RouteParamtypes.FILES ||
+            isString(type));
     }
     createGuardsFn(guards, instance, callback, contextType) {
         const canActivateFn = async (args) => {
             const canActivate = await this.guardsConsumer.tryActivate(guards, args, instance, callback, contextType);
             if (!canActivate) {
-                throw new common_1.ForbiddenException(guards_1.FORBIDDEN_MESSAGE);
+                throw new ForbiddenException(FORBIDDEN_MESSAGE);
             }
         };
         return guards.length ? canActivateFn : null;
@@ -142,10 +151,10 @@ class RouterExecutionContext {
     createPipesFn(pipes, paramsOptions) {
         const pipesFn = async (args, req, res, next) => {
             const resolveParamValue = async (param) => {
-                const { index, extractValue, type, data, metatype, pipes: paramPipes, } = param;
+                const { index, extractValue, type, data, metatype, pipes: paramPipes, schema, } = param;
                 const value = extractValue(req, res, next);
                 args[index] = this.isPipeable(type)
-                    ? await this.getParamValue(value, { metatype, type, data }, pipes.concat(paramPipes))
+                    ? await this.getParamValue(value, { metatype, type, data, schema }, pipes.concat(paramPipes))
                     : value;
             };
             await Promise.all(paramsOptions.map(resolveParamValue));
@@ -159,7 +168,7 @@ class RouterExecutionContext {
                 return await this.responseController.render(result, res, renderTemplate);
             };
         }
-        if (redirectResponse && (0, shared_utils_1.isString)(redirectResponse.url)) {
+        if (redirectResponse && isString(redirectResponse.url)) {
             return async (result, res) => {
                 await this.responseController.redirect(result, res, redirectResponse);
             };
@@ -178,9 +187,8 @@ class RouterExecutionContext {
         };
     }
     isResponseHandled(instance, methodName, paramsMetadata) {
-        const hasResponseOrNextDecorator = paramsMetadata.some(({ type }) => type === route_paramtypes_enum_1.RouteParamtypes.RESPONSE || type === route_paramtypes_enum_1.RouteParamtypes.NEXT);
+        const hasResponseOrNextDecorator = paramsMetadata.some(({ type }) => type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT);
         const isPassthroughEnabled = this.contextUtils.reflectPassthrough(instance, methodName);
         return hasResponseOrNextDecorator && !isPassthroughEnabled;
     }
 }
-exports.RouterExecutionContext = RouterExecutionContext;

package/router/router-explorer.d.ts

@@ -1,19 +1,17 @@
-import { HttpServer } from '@nestjs/common';
-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';
-import { ApplicationConfig } from '../application-config';
-import { NestContainer } from '../injector/container';
-import { Injector } from '../injector/injector';
-import { InstanceWrapper } from '../injector/instance-wrapper';
-import { Module } from '../injector/module';
-import { GraphInspector } from '../inspector/graph-inspector';
-import { MetadataScanner } from '../metadata-scanner';
-import { ExceptionsFilter } from './interfaces/exceptions-filter.interface';
-import { RoutePathMetadata } from './interfaces/route-path-metadata.interface';
-import { RoutePathFactory } from './route-path-factory';
-import { RouterProxy, RouterProxyCallback } from './router-proxy';
+import type { HttpServer } from '@nestjs/common';
+import { ApplicationConfig } from '../application-config.js';
+import { NestContainer } from '../injector/container.js';
+import { Injector } from '../injector/injector.js';
+import { InstanceWrapper } from '../injector/instance-wrapper.js';
+import { Module } from '../injector/module.js';
+import { GraphInspector } from '../inspector/graph-inspector.js';
+import { MetadataScanner } from '../metadata-scanner.js';
+import { ExceptionsFilter } from './interfaces/exceptions-filter.interface.js';
+import { RoutePathMetadata } from './interfaces/route-path-metadata.interface.js';
+import { RoutePathFactory } from './route-path-factory.js';
+import { RouterProxy, RouterProxyCallback } from './router-proxy.js';
+import { type Controller, type VersionValue } from '@nestjs/common/internal';
+import { RequestMethod, type Type } from '@nestjs/common';
 export interface RouteDefinition {
     path: string[];
     requestMethod: RequestMethod;

package/router/router-explorer.js

@@ -1,26 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterExplorer = void 0;
-const constants_1 = require("@nestjs/common/constants");
-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");
-const path_to_regexp_1 = require("path-to-regexp");
-const unknown_request_mapping_exception_1 = require("../errors/exceptions/unknown-request-mapping.exception");
-const guards_1 = require("../guards");
-const context_id_factory_1 = require("../helpers/context-id-factory");
-const execution_context_host_1 = require("../helpers/execution-context-host");
-const messages_1 = require("../helpers/messages");
-const router_method_factory_1 = require("../helpers/router-method-factory");
-const constants_2 = require("../injector/constants");
-const interceptors_1 = require("../interceptors");
-const pipes_1 = require("../pipes");
-const paths_explorer_1 = require("./paths-explorer");
-const request_constants_1 = require("./request/request-constants");
-const route_params_factory_1 = require("./route-params-factory");
-const router_execution_context_1 = require("./router-execution-context");
-class RouterExplorer {
+import { pathToRegexp } from 'path-to-regexp';
+import { UnknownRequestMappingException } from '../errors/exceptions/unknown-request-mapping.exception.js';
+import { GuardsConsumer, GuardsContextCreator } from '../guards/index.js';
+import { ContextIdFactory } from '../helpers/context-id-factory.js';
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+import { ROUTE_MAPPED_MESSAGE, VERSIONED_ROUTE_MAPPED_MESSAGE, } from '../helpers/messages.js';
+import { RouterMethodFactory } from '../helpers/router-method-factory.js';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { InterceptorsConsumer, InterceptorsContextCreator, } from '../interceptors/index.js';
+import { PipesConsumer, PipesContextCreator } from '../pipes/index.js';
+import { PathsExplorer } from './paths-explorer.js';
+import { REQUEST_CONTEXT_ID } from './request/request-constants.js';
+import { RouteParamsFactory } from './route-params-factory.js';
+import { RouterExecutionContext } from './router-execution-context.js';
+import { PATH_METADATA, addLeadingSlash, isUndefined, } from '@nestjs/common/internal';
+import { RequestMethod, VersioningType, InternalServerErrorException, Logger, } from '@nestjs/common';
+export class RouterExplorer {
+    container;
+    injector;
+    routerProxy;
+    exceptionsFilter;
+    routePathFactory;
+    graphInspector;
+    executionContextCreator;
+    pathsExplorer;
+    routerMethodFactory = new RouterMethodFactory();
+    logger = new Logger(RouterExplorer.name, {
+        timestamp: true,
+    });
+    exceptionFiltersCache = new WeakMap();
     constructor(metadataScanner, container, injector, routerProxy, exceptionsFilter, config, routePathFactory, graphInspector) {
         this.container = container;
         this.injector = injector;
@@ -28,20 +35,15 @@ class RouterExplorer {
         this.exceptionsFilter = exceptionsFilter;
         this.routePathFactory = routePathFactory;
         this.graphInspector = graphInspector;
-        this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
-        this.logger = new logger_service_1.Logger(RouterExplorer.name, {
-            timestamp: true,
-        });
-        this.exceptionFiltersCache = new WeakMap();
-        this.pathsExplorer = new paths_explorer_1.PathsExplorer(metadataScanner);
-        const routeParamsFactory = new route_params_factory_1.RouteParamsFactory();
-        const pipesContextCreator = new pipes_1.PipesContextCreator(container, config);
-        const pipesConsumer = new pipes_1.PipesConsumer();
-        const guardsContextCreator = new guards_1.GuardsContextCreator(container, config);
-        const guardsConsumer = new guards_1.GuardsConsumer();
-        const interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, config);
-        const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
-        this.executionContextCreator = new router_execution_context_1.RouterExecutionContext(routeParamsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getHttpAdapterRef());
+        this.pathsExplorer = new PathsExplorer(metadataScanner);
+        const routeParamsFactory = new RouteParamsFactory();
+        const pipesContextCreator = new PipesContextCreator(container, config);
+        const pipesConsumer = new PipesConsumer();
+        const guardsContextCreator = new GuardsContextCreator(container, config);
+        const guardsConsumer = new GuardsConsumer();
+        const interceptorsContextCreator = new InterceptorsContextCreator(container, config);
+        const interceptorsConsumer = new InterceptorsConsumer();
+        this.executionContextCreator = new RouterExecutionContext(routeParamsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getHttpAdapterRef());
     }
     explore(instanceWrapper, moduleKey, httpAdapterRef, host, routePathMetadata) {
         const { instance } = instanceWrapper;
@@ -49,14 +51,14 @@ class RouterExplorer {
         this.applyPathsToRouterProxy(httpAdapterRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
     }
     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(metatype);
+        const path = Reflect.getMetadata(PATH_METADATA, metatype);
+        if (isUndefined(path)) {
+            throw new UnknownRequestMappingException(metatype);
         }
         if (Array.isArray(path)) {
-            return path.map(p => (0, shared_utils_1.addLeadingSlash)(p));
+            return path.map(p => addLeadingSlash(p));
         }
-        return [(0, shared_utils_1.addLeadingSlash)(path)];
+        return [addLeadingSlash(path)];
     }
     applyPathsToRouterProxy(router, routeDefinitions, instanceWrapper, moduleKey, routePathMetadata, host) {
         (routeDefinitions || []).forEach(routeDefinition => {
@@ -81,7 +83,7 @@ class RouterExplorer {
         let routeHandler = this.applyHostFilter(host, proxy);
         paths.forEach(path => {
             if (isVersioned &&
-                routePathMetadata.versioningOptions.type !== enums_1.VersioningType.URI) {
+                routePathMetadata.versioningOptions.type !== VersioningType.URI) {
                 // All versioning (except for URI Versioning) is done via the "Version Filter"
                 routeHandler = this.applyVersionFilter(router, routePathMetadata, routeHandler);
             }
@@ -96,7 +98,7 @@ class RouterExplorer {
                     metadata: {
                         key: path,
                         path,
-                        requestMethod: enums_1.RequestMethod[requestMethod],
+                        requestMethod: RequestMethod[requestMethod],
                         methodVersion: routePathMetadata.methodVersion,
                         controllerVersion: routePathMetadata.controllerVersion,
                     },
@@ -125,10 +127,10 @@ class RouterExplorer {
             pathsToLog.forEach(path => {
                 if (isVersioned) {
                     const version = this.routePathFactory.getVersion(routePathMetadata);
-                    this.logger.log((0, messages_1.VERSIONED_ROUTE_MAPPED_MESSAGE)(path, requestMethod, version));
+                    this.logger.log(VERSIONED_ROUTE_MAPPED_MESSAGE(path, requestMethod, version));
                 }
                 else {
-                    this.logger.log((0, messages_1.ROUTE_MAPPED_MESSAGE)(path, requestMethod));
+                    this.logger.log(ROUTE_MAPPED_MESSAGE(path, requestMethod));
                 }
             });
         });
@@ -142,7 +144,7 @@ class RouterExplorer {
         const hostRegExps = hosts.map((host) => {
             if (typeof host === 'string') {
                 try {
-                    return (0, path_to_regexp_1.pathToRegexp)(host);
+                    return pathToRegexp(host);
                 }
                 catch (e) {
                     if (e instanceof TypeError) {
@@ -174,7 +176,7 @@ class RouterExplorer {
                 }
             }
             if (!next) {
-                throw new exceptions_1.InternalServerErrorException(unsupportedFilteringErrorMessage);
+                throw new InternalServerErrorException(unsupportedFilteringErrorMessage);
             }
             return next();
         };
@@ -183,7 +185,7 @@ class RouterExplorer {
         const version = this.routePathFactory.getVersion(routePathMetadata);
         return router.applyVersionFilter(handler, version, routePathMetadata.versioningOptions);
     }
-    createCallbackProxy(instance, callback, methodName, moduleRef, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    createCallbackProxy(instance, callback, methodName, moduleRef, requestMethod, contextId = STATIC_CONTEXT, inquirerId) {
         const executionContext = this.executionContextCreator.create(instance, callback, methodName, moduleRef, requestMethod, contextId, inquirerId);
         const exceptionFilter = this.exceptionsFilter.create(instance, callback, moduleRef, contextId, inquirerId);
         return this.routerProxy.createProxy(executionContext, exceptionFilter);
@@ -204,15 +206,15 @@ class RouterExplorer {
                     exceptionFilter = this.exceptionsFilter.create(instance, instance[methodName], moduleKey);
                     this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
                 }
-                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                const host = new ExecutionContextHost([req, res, next]);
                 exceptionFilter.next(err, host);
             }
         };
     }
     getContextId(request, isTreeDurable) {
-        const contextId = context_id_factory_1.ContextIdFactory.getByRequest(request);
-        if (!request[request_constants_1.REQUEST_CONTEXT_ID]) {
-            Object.defineProperty(request, request_constants_1.REQUEST_CONTEXT_ID, {
+        const contextId = ContextIdFactory.getByRequest(request);
+        if (!request[REQUEST_CONTEXT_ID]) {
+            Object.defineProperty(request, REQUEST_CONTEXT_ID, {
                 value: contextId,
                 enumerable: false,
                 writable: false,
@@ -231,4 +233,3 @@ class RouterExplorer {
         }
     }
 }
-exports.RouterExplorer = RouterExplorer;

package/router/router-module.d.ts

@@ -1,7 +1,7 @@
-import { DynamicModule } from '@nestjs/common';
-import { Module as ModuleClass } from '../injector/module';
-import { ModulesContainer } from '../injector/modules-container';
-import { Routes } from './interfaces';
+import { type DynamicModule } from '@nestjs/common';
+import { Module as ModuleClass } from '../injector/module.js';
+import { ModulesContainer } from '../injector/modules-container.js';
+import { Routes } from './interfaces/index.js';
 export declare const ROUTES: unique symbol;
 export declare const targetModulesByContainer: WeakMap<ModulesContainer, WeakSet<ModuleClass>>;
 /**

package/router/router-module.js

@@ -1,19 +1,17 @@
-"use strict";
 var RouterModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterModule = exports.targetModulesByContainer = exports.ROUTES = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const constants_1 = require("@nestjs/common/constants");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const modules_container_1 = require("../injector/modules-container");
-const utils_1 = require("./utils");
-exports.ROUTES = Symbol('ROUTES');
-exports.targetModulesByContainer = new WeakMap();
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, Module } from '@nestjs/common';
+import { ModulesContainer } from '../injector/modules-container.js';
+import { flattenRoutePaths } from './utils/index.js';
+import { MODULE_PATH, normalizePath } from '@nestjs/common/internal';
+export const ROUTES = Symbol('ROUTES');
+export const targetModulesByContainer = new WeakMap();
 /**
  * @publicApi
  */
 let RouterModule = RouterModule_1 = class RouterModule {
+    modulesContainer;
+    routes;
     constructor(modulesContainer, routes) {
         this.modulesContainer = modulesContainer;
         this.routes = routes;
@@ -25,7 +23,7 @@ let RouterModule = RouterModule_1 = class RouterModule {
             module: RouterModule_1,
             providers: [
                 {
-                    provide: exports.ROUTES,
+                    provide: ROUTES,
                     useValue: routes,
                 },
             ],
@@ -46,24 +44,24 @@ let RouterModule = RouterModule_1 = class RouterModule {
         });
     }
     initialize() {
-        const flattenedRoutes = (0, utils_1.flattenRoutePaths)(this.routes);
+        const flattenedRoutes = flattenRoutePaths(this.routes);
         flattenedRoutes.forEach(route => {
-            const modulePath = (0, shared_utils_1.normalizePath)(route.path);
+            const modulePath = normalizePath(route.path);
             this.registerModulePathMetadata(route.module, modulePath);
             this.updateTargetModulesCache(route.module);
         });
     }
     registerModulePathMetadata(moduleCtor, modulePath) {
-        Reflect.defineMetadata(constants_1.MODULE_PATH + this.modulesContainer.applicationId, modulePath, moduleCtor);
+        Reflect.defineMetadata(MODULE_PATH + this.modulesContainer.applicationId, modulePath, moduleCtor);
     }
     updateTargetModulesCache(moduleCtor) {
         let moduleClassSet;
-        if (exports.targetModulesByContainer.has(this.modulesContainer)) {
-            moduleClassSet = exports.targetModulesByContainer.get(this.modulesContainer);
+        if (targetModulesByContainer.has(this.modulesContainer)) {
+            moduleClassSet = targetModulesByContainer.get(this.modulesContainer);
         }
         else {
             moduleClassSet = new WeakSet();
-            exports.targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
+            targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
         }
         const moduleRef = Array.from(this.modulesContainer.values()).find(item => item?.metatype === moduleCtor);
         if (!moduleRef) {
@@ -72,9 +70,9 @@ let RouterModule = RouterModule_1 = class RouterModule {
         moduleClassSet.add(moduleRef);
     }
 };
-exports.RouterModule = RouterModule;
-exports.RouterModule = RouterModule = RouterModule_1 = tslib_1.__decorate([
-    (0, common_1.Module)({}),
-    tslib_1.__param(1, (0, common_1.Inject)(exports.ROUTES)),
-    tslib_1.__metadata("design:paramtypes", [modules_container_1.ModulesContainer, Array])
+RouterModule = RouterModule_1 = __decorate([
+    Module({}),
+    __param(1, Inject(ROUTES)),
+    __metadata("design:paramtypes", [ModulesContainer, Array])
 ], RouterModule);
+export { RouterModule };

package/router/router-proxy.d.ts

@@ -1,4 +1,4 @@
-import { ExceptionsHandler } from '../exceptions/exceptions-handler';
+import { ExceptionsHandler } from '../exceptions/exceptions-handler.js';
 export type RouterProxyCallback = <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => void | Promise<void>;
 export declare class RouterProxy {
     createProxy(targetCallback: RouterProxyCallback, exceptionsHandler: ExceptionsHandler): <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<TResponse | undefined>;

package/router/router-proxy.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterProxy = void 0;
-const execution_context_host_1 = require("../helpers/execution-context-host");
-class RouterProxy {
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+export class RouterProxy {
     createProxy(targetCallback, exceptionsHandler) {
         return async (req, res, next) => {
             try {
                 await targetCallback(req, res, next);
             }
             catch (e) {
-                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                const host = new ExecutionContextHost([req, res, next]);
                 exceptionsHandler.next(e, host);
                 return res;
             }
@@ -21,11 +18,10 @@ class RouterProxy {
                 await targetCallback(err, req, res, next);
             }
             catch (e) {
-                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                const host = new ExecutionContextHost([req, res, next]);
                 exceptionsHandler.next(e, host);
                 return res;
             }
         };
     }
 }
-exports.RouterProxy = RouterProxy;

package/router/router-response-controller.d.ts

@@ -1,7 +1,7 @@
-import { HttpServer, RequestMethod } from '@nestjs/common';
+import { type HttpServer, RequestMethod } from '@nestjs/common';
 import { IncomingMessage } from 'http';
 import { Observable } from 'rxjs';
-import { AdditionalHeaders, WritableHeaderStream } from './sse-stream';
+import { AdditionalHeaders, WritableHeaderStream } from './sse-stream.js';
 export interface CustomHeader {
     name: string;
     value: string | (() => string);