@nestjs/core 11.1.16 → 12.0.0-alpha.0

package/middleware/middleware-module.js

@@ -1,35 +1,39 @@
-"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");
-const runtime_exception_1 = require("../errors/exceptions/runtime.exception");
-const context_id_factory_1 = require("../helpers/context-id-factory");
-const execution_context_host_1 = require("../helpers/execution-context-host");
-const constants_1 = require("../injector/constants");
-const request_constants_1 = require("../router/request/request-constants");
-const router_exception_filters_1 = require("../router/router-exception-filters");
-const router_proxy_1 = require("../router/router-proxy");
-const utils_1 = require("../router/utils");
-const builder_1 = require("./builder");
-const resolver_1 = require("./resolver");
-const route_info_path_extractor_1 = require("./route-info-path-extractor");
-const routes_mapper_1 = require("./routes-mapper");
-class MiddlewareModule {
-    constructor() {
-        this.routerProxy = new router_proxy_1.RouterProxy();
-        this.exceptionFiltersCache = new WeakMap();
-        this.logger = new common_1.Logger(MiddlewareModule.name);
-    }
+import { Logger } from '@nestjs/common';
+import { InvalidMiddlewareException } from '../errors/exceptions/invalid-middleware.exception.js';
+import { RuntimeException } from '../errors/exceptions/runtime.exception.js';
+import { ContextIdFactory } from '../helpers/context-id-factory.js';
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { REQUEST_CONTEXT_ID } from '../router/request/request-constants.js';
+import { RouterExceptionFilters } from '../router/router-exception-filters.js';
+import { RouterProxy } from '../router/router-proxy.js';
+import { isRequestMethodAll } from '../router/utils/index.js';
+import { MiddlewareBuilder } from './builder.js';
+import { MiddlewareResolver } from './resolver.js';
+import { RouteInfoPathExtractor } from './route-info-path-extractor.js';
+import { RoutesMapper } from './routes-mapper.js';
+import { RequestMethod } from '@nestjs/common';
+import { isUndefined, } from '@nestjs/common/internal';
+export class MiddlewareModule {
+    routerProxy = new RouterProxy();
+    exceptionFiltersCache = new WeakMap();
+    logger = new Logger(MiddlewareModule.name);
+    injector;
+    routerExceptionFilter;
+    routesMapper;
+    resolver;
+    container;
+    httpAdapter;
+    graphInspector;
+    appOptions;
+    routeInfoPathExtractor;
     async register(middlewareContainer, container, config, injector, httpAdapter, graphInspector, options) {
         this.appOptions = options;
         const appRef = container.getHttpAdapterRef();
-        this.routerExceptionFilter = new router_exception_filters_1.RouterExceptionFilters(container, config, appRef);
-        this.routesMapper = new routes_mapper_1.RoutesMapper(container, config);
-        this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer, injector);
-        this.routeInfoPathExtractor = new route_info_path_extractor_1.RouteInfoPathExtractor(config);
+        this.routerExceptionFilter = new RouterExceptionFilters(container, config, appRef);
+        this.routesMapper = new RoutesMapper(container, config);
+        this.resolver = new MiddlewareResolver(middlewareContainer, injector);
+        this.routeInfoPathExtractor = new RouteInfoPathExtractor(config);
         this.injector = injector;
         this.container = container;
         this.httpAdapter = httpAdapter;
@@ -50,7 +54,7 @@ class MiddlewareModule {
         if (!instance.configure) {
             return;
         }
-        const middlewareBuilder = new builder_1.MiddlewareBuilder(this.routesMapper, this.httpAdapter, this.routeInfoPathExtractor);
+        const middlewareBuilder = new MiddlewareBuilder(this.routesMapper, this.httpAdapter, this.routeInfoPathExtractor);
         try {
             await instance.configure(middlewareBuilder);
         }
@@ -62,7 +66,7 @@ class MiddlewareModule {
                 ` (possibly due to missing dependencies). Note: you can ignore this message, just be aware that some of those conditional middlewares will not be reflected in your graph.`;
             this.logger.warn(warningMessage);
         }
-        if (!(middlewareBuilder instanceof builder_1.MiddlewareBuilder)) {
+        if (!(middlewareBuilder instanceof MiddlewareBuilder)) {
             return;
         }
         const config = middlewareBuilder.build();
@@ -107,8 +111,8 @@ class MiddlewareModule {
         for (const metatype of middlewareCollection) {
             const collection = middlewareContainer.getMiddlewareCollection(moduleKey);
             const instanceWrapper = collection.get(metatype);
-            if ((0, shared_utils_1.isUndefined)(instanceWrapper)) {
-                throw new runtime_exception_1.RuntimeException();
+            if (isUndefined(instanceWrapper)) {
+                throw new RuntimeException();
             }
             if (instanceWrapper.isTransient) {
                 return;
@@ -122,7 +126,7 @@ class MiddlewareModule {
                 metadata: {
                     key: routeInfo.path,
                     path: routeInfo.path,
-                    requestMethod: request_method_enum_1.RequestMethod[routeInfo.method] ??
+                    requestMethod: RequestMethod[routeInfo.method] ??
                         'ALL',
                     version: routeInfo.version,
                 },
@@ -133,8 +137,8 @@ class MiddlewareModule {
     }
     async bindHandler(wrapper, applicationRef, routeInfo, moduleRef, collection) {
         const { instance, metatype } = wrapper;
-        if ((0, shared_utils_1.isUndefined)(instance?.use)) {
-            throw new invalid_middleware_exception_1.InvalidMiddlewareException(metatype.name);
+        if (isUndefined(instance?.use)) {
+            throw new InvalidMiddlewareException(metatype.name);
         }
         const isStatic = wrapper.isDependencyTreeStatic();
         if (isStatic) {
@@ -155,12 +159,12 @@ class MiddlewareModule {
                     exceptionsHandler = this.routerExceptionFilter.create(instance, instance.use, undefined);
                     this.exceptionFiltersCache.set(instance.use, exceptionsHandler);
                 }
-                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                const host = new ExecutionContextHost([req, res, next]);
                 exceptionsHandler.next(err, host);
             }
         });
     }
-    async createProxy(instance, contextId = constants_1.STATIC_CONTEXT) {
+    async createProxy(instance, contextId = STATIC_CONTEXT) {
         const exceptionsHandler = this.routerExceptionFilter.create(instance, instance.use, undefined, contextId);
         const middleware = instance.use.bind(instance);
         return this.routerProxy.createProxy(middleware, exceptionsHandler);
@@ -168,8 +172,8 @@ class MiddlewareModule {
     async registerHandler(applicationRef, routeInfo, proxy) {
         const { method } = routeInfo;
         const paths = this.routeInfoPathExtractor.extractPathsFrom(routeInfo);
-        const isMethodAll = (0, utils_1.isRequestMethodAll)(method);
-        const requestMethod = request_method_enum_1.RequestMethod[method];
+        const isMethodAll = isRequestMethodAll(method);
+        const requestMethod = RequestMethod[method];
         const router = await applicationRef.createMiddlewareFactory(method);
         const middlewareFunction = isMethodAll
             ? proxy
@@ -186,9 +190,9 @@ class MiddlewareModule {
         pathsToApplyMiddleware.forEach(path => router(path, middlewareFunction));
     }
     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,
@@ -202,4 +206,3 @@ class MiddlewareModule {
         return contextId;
     }
 }
-exports.MiddlewareModule = MiddlewareModule;

package/middleware/resolver.d.ts

@@ -1,6 +1,6 @@
-import { Injector } from '../injector/injector';
-import { Module } from '../injector/module';
-import { MiddlewareContainer } from './container';
+import { Injector } from '../injector/injector.js';
+import { Module } from '../injector/module.js';
+import { MiddlewareContainer } from './container.js';
 export declare class MiddlewareResolver {
     private readonly middlewareContainer;
     private readonly injector;

package/middleware/resolver.js

@@ -1,7 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareResolver = void 0;
-class MiddlewareResolver {
+export class MiddlewareResolver {
+    middlewareContainer;
+    injector;
     constructor(middlewareContainer, injector) {
         this.middlewareContainer = middlewareContainer;
         this.injector = injector;
@@ -15,4 +14,3 @@ class MiddlewareResolver {
         await this.injector.loadMiddleware(wrapper, middlewareMap, moduleRef);
     }
 }
-exports.MiddlewareResolver = MiddlewareResolver;

package/middleware/route-info-path-extractor.d.ts

@@ -1,5 +1,5 @@
-import { RouteInfo } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from '../application-config';
+import { ApplicationConfig } from '../application-config.js';
+import { type RouteInfo } from '@nestjs/common/internal';
 export declare class RouteInfoPathExtractor {
     private readonly applicationConfig;
     private readonly routePathFactory;

package/middleware/route-info-path-extractor.js

@@ -1,15 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteInfoPathExtractor = void 0;
-const common_1 = require("@nestjs/common");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const utils_1 = require("../router/utils");
-const route_path_factory_1 = require("./../router/route-path-factory");
-class RouteInfoPathExtractor {
+import { VersioningType } from '@nestjs/common';
+import { isRouteExcluded } from '../router/utils/index.js';
+import { RoutePathFactory } from './../router/route-path-factory.js';
+import { addLeadingSlash, stripEndSlash, } from '@nestjs/common/internal';
+export class RouteInfoPathExtractor {
+    applicationConfig;
+    routePathFactory;
+    prefixPath;
+    excludedGlobalPrefixRoutes;
+    versioningConfig;
     constructor(applicationConfig) {
         this.applicationConfig = applicationConfig;
-        this.routePathFactory = new route_path_factory_1.RoutePathFactory(applicationConfig);
-        this.prefixPath = (0, shared_utils_1.stripEndSlash)((0, shared_utils_1.addLeadingSlash)(this.applicationConfig.getGlobalPrefix()));
+        this.routePathFactory = new RoutePathFactory(applicationConfig);
+        this.prefixPath = stripEndSlash(addLeadingSlash(this.applicationConfig.getGlobalPrefix()));
         this.excludedGlobalPrefixRoutes =
             this.applicationConfig.getGlobalPrefixOptions().exclude;
         this.versioningConfig = this.applicationConfig.getVersioning();
@@ -21,19 +23,19 @@ class RouteInfoPathExtractor {
                 ? versionPaths
                     .map(versionPath => [
                     this.prefixPath + versionPath + '$',
-                    this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path),
+                    this.prefixPath + versionPath + addLeadingSlash(path),
                 ])
                     .flat()
                 : this.prefixPath
-                    ? [this.prefixPath + '$', this.prefixPath + (0, shared_utils_1.addLeadingSlash)(path)]
-                    : [(0, shared_utils_1.addLeadingSlash)(path)];
+                    ? [this.prefixPath + '$', this.prefixPath + addLeadingSlash(path)]
+                    : [addLeadingSlash(path)];
             return Array.isArray(this.excludedGlobalPrefixRoutes)
                 ? [
                     ...entries,
                     ...this.excludedGlobalPrefixRoutes
                         .map(route => Array.isArray(versionPaths) && versionPaths.length > 0
-                        ? versionPaths.map(v => v + (0, shared_utils_1.addLeadingSlash)(route.path))
-                        : (0, shared_utils_1.addLeadingSlash)(route.path))
+                        ? versionPaths.map(v => v + addLeadingSlash(route.path))
+                        : addLeadingSlash(route.path))
                         .flat(),
                 ]
                 : entries;
@@ -42,7 +44,7 @@ class RouteInfoPathExtractor {
     }
     extractPathFrom(route) {
         if (this.isAWildcard(route.path) && !route.version) {
-            return [(0, shared_utils_1.addLeadingSlash)(route.path)];
+            return [addLeadingSlash(route.path)];
         }
         return this.extractNonWildcardPathsFrom(route);
     }
@@ -57,25 +59,24 @@ class RouteInfoPathExtractor {
     extractNonWildcardPathsFrom({ path, method, version, }) {
         const versionPaths = this.extractVersionPathFrom(version);
         if (Array.isArray(this.excludedGlobalPrefixRoutes) &&
-            (0, utils_1.isRouteExcluded)(this.excludedGlobalPrefixRoutes, path, method)) {
+            isRouteExcluded(this.excludedGlobalPrefixRoutes, path, method)) {
             if (!versionPaths.length) {
-                return [(0, shared_utils_1.addLeadingSlash)(path)];
+                return [addLeadingSlash(path)];
             }
-            return versionPaths.map(versionPath => versionPath + (0, shared_utils_1.addLeadingSlash)(path));
+            return versionPaths.map(versionPath => versionPath + addLeadingSlash(path));
         }
         if (!versionPaths.length) {
-            return [this.prefixPath + (0, shared_utils_1.addLeadingSlash)(path)];
+            return [this.prefixPath + addLeadingSlash(path)];
         }
-        return versionPaths.map(versionPath => this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path));
+        return versionPaths.map(versionPath => this.prefixPath + versionPath + addLeadingSlash(path));
     }
     extractVersionPathFrom(versionValue) {
-        if (!versionValue || this.versioningConfig?.type !== common_1.VersioningType.URI)
+        if (!versionValue || this.versioningConfig?.type !== VersioningType.URI)
             return [];
         const versionPrefix = this.routePathFactory.getVersionPrefix(this.versioningConfig);
         if (Array.isArray(versionValue)) {
-            return versionValue.map(version => (0, shared_utils_1.addLeadingSlash)(versionPrefix + version.toString()));
+            return versionValue.map(version => addLeadingSlash(versionPrefix + version.toString()));
         }
-        return [(0, shared_utils_1.addLeadingSlash)(versionPrefix + versionValue.toString())];
+        return [addLeadingSlash(versionPrefix + versionValue.toString())];
     }
 }
-exports.RouteInfoPathExtractor = RouteInfoPathExtractor;

package/middleware/routes-mapper.d.ts

@@ -1,6 +1,7 @@
-import { RouteInfo, Type } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from '../application-config';
-import { NestContainer } from '../injector/container';
+import { ApplicationConfig } from '../application-config.js';
+import { NestContainer } from '../injector/container.js';
+import { type RouteInfo } from '@nestjs/common/internal';
+import { type Type } from '@nestjs/common';
 export declare class RoutesMapper {
     private readonly container;
     private readonly applicationConfig;

package/middleware/routes-mapper.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutesMapper = void 0;
-const constants_1 = require("@nestjs/common/constants");
-const interfaces_1 = require("@nestjs/common/interfaces");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const metadata_scanner_1 = require("../metadata-scanner");
-const paths_explorer_1 = require("../router/paths-explorer");
-const router_module_1 = require("../router/router-module");
-class RoutesMapper {
+import { MetadataScanner } from '../metadata-scanner.js';
+import { PathsExplorer } from '../router/paths-explorer.js';
+import { targetModulesByContainer } from '../router/router-module.js';
+import { MODULE_PATH, PATH_METADATA, VERSION_METADATA, addLeadingSlash, isString, isUndefined, } from '@nestjs/common/internal';
+import { VERSION_NEUTRAL } from '@nestjs/common';
+export class RoutesMapper {
+    container;
+    applicationConfig;
+    pathsExplorer;
     constructor(container, applicationConfig) {
         this.container = container;
         this.applicationConfig = applicationConfig;
-        this.pathsExplorer = new paths_explorer_1.PathsExplorer(new metadata_scanner_1.MetadataScanner());
+        this.pathsExplorer = new PathsExplorer(new MetadataScanner());
     }
     mapRouteToRouteInfo(controllerOrRoute) {
-        if ((0, shared_utils_1.isString)(controllerOrRoute)) {
+        if (isString(controllerOrRoute)) {
             return this.getRouteInfoFromPath(controllerOrRoute);
         }
         const routePathOrPaths = this.getRoutePath(controllerOrRoute);
@@ -27,14 +26,14 @@ class RoutesMapper {
         const defaultRequestMethod = -1;
         return [
             {
-                path: (0, shared_utils_1.addLeadingSlash)(routePath),
+                path: addLeadingSlash(routePath),
                 method: defaultRequestMethod,
             },
         ];
     }
     getRouteInfoFromObject(routeInfoObject) {
         const routeInfo = {
-            path: (0, shared_utils_1.addLeadingSlash)(routeInfoObject.path),
+            path: addLeadingSlash(routeInfoObject.path),
             method: routeInfoObject.method,
         };
         if (routeInfoObject.version) {
@@ -49,10 +48,10 @@ class RoutesMapper {
         const moduleRef = this.getHostModuleOfController(controller);
         const modulePath = this.getModulePath(moduleRef?.metatype);
         const concatPaths = (acc, currentValue) => acc.concat(currentValue);
-        const toUndefinedIfNeural = (version) => version === interfaces_1.VERSION_NEUTRAL ? undefined : version;
+        const toUndefinedIfNeural = (version) => version === VERSION_NEUTRAL ? undefined : version;
         const toRouteInfo = (item, prefix) => item.path?.flatMap(p => {
             let endpointPath = modulePath ?? '';
-            endpointPath += this.normalizeGlobalPath(prefix) + (0, shared_utils_1.addLeadingSlash)(p);
+            endpointPath += this.normalizeGlobalPath(prefix) + addLeadingSlash(p);
             const routeInfo = {
                 path: endpointPath,
                 method: item.requestMethod,
@@ -77,21 +76,21 @@ class RoutesMapper {
             .reduce(concatPaths, []);
     }
     isRouteInfo(path, objectOrClass) {
-        return (0, shared_utils_1.isUndefined)(path);
+        return isUndefined(path);
     }
     normalizeGlobalPath(path) {
-        const prefix = (0, shared_utils_1.addLeadingSlash)(path);
+        const prefix = addLeadingSlash(path);
         return prefix === '/' ? '' : prefix;
     }
     getRoutePath(route) {
-        return Reflect.getMetadata(constants_1.PATH_METADATA, route);
+        return Reflect.getMetadata(PATH_METADATA, route);
     }
     getHostModuleOfController(metatype) {
         if (!metatype) {
             return;
         }
         const modulesContainer = this.container.getModules();
-        const moduleRefsSet = router_module_1.targetModulesByContainer.get(modulesContainer);
+        const moduleRefsSet = targetModulesByContainer.get(modulesContainer);
         if (!moduleRefsSet) {
             return;
         }
@@ -103,15 +102,14 @@ class RoutesMapper {
             return;
         }
         const modulesContainer = this.container.getModules();
-        const modulePath = Reflect.getMetadata(constants_1.MODULE_PATH + modulesContainer.applicationId, metatype);
-        return modulePath ?? Reflect.getMetadata(constants_1.MODULE_PATH, metatype);
+        const modulePath = Reflect.getMetadata(MODULE_PATH + modulesContainer.applicationId, metatype);
+        return modulePath ?? Reflect.getMetadata(MODULE_PATH, metatype);
     }
     getVersionMetadata(metatype) {
         const versioningConfig = this.applicationConfig.getVersioning();
         if (versioningConfig) {
-            return (Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ??
+            return (Reflect.getMetadata(VERSION_METADATA, metatype) ??
                 versioningConfig.defaultVersion);
         }
     }
 }
-exports.RoutesMapper = RoutesMapper;

package/middleware/utils.d.ts

@@ -1,5 +1,6 @@
-import { HttpServer, RouteInfo, Type } from '@nestjs/common/interfaces';
-import { ExcludeRouteMetadata } from '../router/interfaces/exclude-route-metadata.interface';
+import { ExcludeRouteMetadata } from '../router/interfaces/exclude-route-metadata.interface.js';
+import type { HttpServer, Type } from '@nestjs/common';
+import { type RouteInfo } from '@nestjs/common/internal';
 export declare const mapToExcludeRoute: (routes: (string | RouteInfo)[]) => ExcludeRouteMetadata[];
 export declare const filterMiddleware: <T extends Function | Type<any> = any>(middleware: T[], routes: RouteInfo[], httpAdapter: HttpServer) => Type<any>[];
 export declare const mapToClass: <T extends Function | Type<any>>(middleware: T, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer) => Type<any>;

package/middleware/utils.js

@@ -1,53 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToClass = exports.filterMiddleware = exports.mapToExcludeRoute = void 0;
-exports.isMiddlewareClass = isMiddlewareClass;
-exports.assignToken = assignToken;
-exports.isMiddlewareRouteExcluded = isMiddlewareRouteExcluded;
-const common_1 = require("@nestjs/common");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const path_to_regexp_1 = require("path-to-regexp");
-const uid_1 = require("uid");
-const legacy_route_converter_1 = require("../router/legacy-route-converter");
-const utils_1 = require("../router/utils");
-const mapToExcludeRoute = (routes) => {
+import { RequestMethod } from '@nestjs/common';
+import { iterate } from 'iterare';
+import { pathToRegexp } from 'path-to-regexp';
+import { uid } from 'uid';
+import { LegacyRouteConverter } from '../router/legacy-route-converter.js';
+import { isRouteExcluded } from '../router/utils/index.js';
+import { addLeadingSlash, isFunction, isString, } from '@nestjs/common/internal';
+export const mapToExcludeRoute = (routes) => {
     return routes.map(route => {
-        const originalPath = (0, shared_utils_1.isString)(route) ? route : route.path;
-        const path = legacy_route_converter_1.LegacyRouteConverter.tryConvert(originalPath);
+        const originalPath = isString(route) ? route : route.path;
+        const path = LegacyRouteConverter.tryConvert(originalPath);
         try {
-            if ((0, shared_utils_1.isString)(route)) {
+            if (isString(route)) {
                 return {
                     path,
-                    requestMethod: common_1.RequestMethod.ALL,
-                    pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
+                    requestMethod: RequestMethod.ALL,
+                    pathRegex: pathToRegexp(addLeadingSlash(path)).regexp,
                 };
             }
             return {
                 path,
                 requestMethod: route.method,
-                pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
+                pathRegex: pathToRegexp(addLeadingSlash(path)).regexp,
             };
         }
         catch (e) {
             if (e instanceof TypeError) {
-                legacy_route_converter_1.LegacyRouteConverter.printError(originalPath);
+                LegacyRouteConverter.printError(originalPath);
             }
             throw e;
         }
     });
 };
-exports.mapToExcludeRoute = mapToExcludeRoute;
-const filterMiddleware = (middleware, routes, httpAdapter) => {
-    const excludedRoutes = (0, exports.mapToExcludeRoute)(routes);
-    return (0, iterare_1.iterate)([])
+export const filterMiddleware = (middleware, routes, httpAdapter) => {
+    const excludedRoutes = mapToExcludeRoute(routes);
+    return iterate([])
         .concat(middleware)
-        .filter(shared_utils_1.isFunction)
-        .map((item) => (0, exports.mapToClass)(item, excludedRoutes, httpAdapter))
+        .filter(isFunction)
+        .map((item) => mapToClass(item, excludedRoutes, httpAdapter))
         .toArray();
 };
-exports.filterMiddleware = filterMiddleware;
-const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
+export const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
     if (isMiddlewareClass(middleware)) {
         if (excludedRoutes.length <= 0) {
             return middleware;
@@ -65,20 +57,17 @@ const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
         return assignToken(MiddlewareHost, middleware.name);
     }
     return assignToken(class {
-        constructor() {
-            this.use = (...params) => {
-                const [req, _, next] = params;
-                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
-                if (isExcluded) {
-                    return next();
-                }
-                return middleware(...params);
-            };
-        }
+        use = (...params) => {
+            const [req, _, next] = params;
+            const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
+            if (isExcluded) {
+                return next();
+            }
+            return middleware(...params);
+        };
     });
 };
-exports.mapToClass = mapToClass;
-function isMiddlewareClass(middleware) {
+export function isMiddlewareClass(middleware) {
     const middlewareStr = middleware.toString();
     if (middlewareStr.substring(0, 5) === 'class') {
         return true;
@@ -86,13 +75,13 @@ function isMiddlewareClass(middleware) {
     const middlewareArr = middlewareStr.split(' ');
     return (middlewareArr[0] === 'function' &&
         /[A-Z]/.test(middlewareArr[1]?.[0]) &&
-        (0, shared_utils_1.isFunction)(middleware.prototype?.use));
+        isFunction(middleware.prototype?.use));
 }
-function assignToken(metatype, token = (0, uid_1.uid)(21)) {
+export function assignToken(metatype, token = uid(21)) {
     Object.defineProperty(metatype, 'name', { value: token });
     return metatype;
 }
-function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
+export function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
     if (excludedRoutes.length <= 0) {
         return false;
     }
@@ -102,5 +91,5 @@ function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
     const pathname = queryParamsIndex >= 0
         ? originalUrl.slice(0, queryParamsIndex)
         : originalUrl;
-    return (0, utils_1.isRouteExcluded)(excludedRoutes, pathname, common_1.RequestMethod[reqMethod]);
+    return isRouteExcluded(excludedRoutes, pathname, RequestMethod[reqMethod]);
 }

package/nest-application-context.d.ts

@@ -1,12 +1,12 @@
-import { INestApplicationContext, Logger, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
-import { DynamicModule, SelectOptions, ShutdownHooksOptions, Type } from '@nestjs/common/interfaces';
-import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
-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';
+import { type INestApplicationContext, Logger, type LoggerService, type LogLevel, ShutdownSignal } from '@nestjs/common';
+import { AbstractInstanceResolver } from './injector/abstract-instance-resolver.js';
+import { NestContainer } from './injector/container.js';
+import { Injector } from './injector/injector.js';
+import { InstanceLinksHost } from './injector/instance-links-host.js';
+import { ContextId } from './injector/instance-wrapper.js';
+import { Module } from './injector/module.js';
+import type { DynamicModule, Type } from '@nestjs/common';
+import { type SelectOptions, type ShutdownHooksOptions, type NestApplicationContextOptions } from '@nestjs/common/internal';
 /**
  * @publicApi
  */
@@ -129,6 +129,7 @@ export declare class NestApplicationContext<TOptions extends NestApplicationCont
      * @returns {this} The Nest application context instance
      */
     enableShutdownHooks(signals?: (ShutdownSignal | string)[], options?: ShutdownHooksOptions): this;
+    protected prepareClose(): Promise<void>;
     protected dispose(): Promise<void>;
     /**
      * Listens to shutdown signals by listening to