@depup/nestjs__core 11.1.17-depup.0

package/router/route-params-factory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteParamsFactory = void 0;
+const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+class RouteParamsFactory {
+    exchangeKeyForValue(key, data, { req, res, next }) {
+        switch (key) {
+            case route_paramtypes_enum_1.RouteParamtypes.NEXT:
+                return next;
+            case route_paramtypes_enum_1.RouteParamtypes.REQUEST:
+                return req;
+            case route_paramtypes_enum_1.RouteParamtypes.RESPONSE:
+                return res;
+            case route_paramtypes_enum_1.RouteParamtypes.BODY:
+                return data && req.body ? req.body[data] : req.body;
+            case route_paramtypes_enum_1.RouteParamtypes.RAW_BODY:
+                return req.rawBody;
+            case route_paramtypes_enum_1.RouteParamtypes.PARAM:
+                return data ? req.params[data] : req.params;
+            case route_paramtypes_enum_1.RouteParamtypes.HOST:
+                /* eslint-disable-next-line no-case-declarations */
+                const hosts = req.hosts || {};
+                return data ? hosts[data] : hosts;
+            case route_paramtypes_enum_1.RouteParamtypes.QUERY:
+                return data ? req.query[data] : req.query;
+            case route_paramtypes_enum_1.RouteParamtypes.HEADERS:
+                return data ? req.headers[data.toLowerCase()] : req.headers;
+            case route_paramtypes_enum_1.RouteParamtypes.SESSION:
+                return req.session;
+            case route_paramtypes_enum_1.RouteParamtypes.FILE:
+                return req[data || 'file'];
+            case route_paramtypes_enum_1.RouteParamtypes.FILES:
+                return req.files;
+            case route_paramtypes_enum_1.RouteParamtypes.IP:
+                return req.ip;
+            default:
+                return null;
+        }
+    }
+}
+exports.RouteParamsFactory = RouteParamsFactory;

package/router/route-path-factory.d.ts

@@ -0,0 +1,14 @@
+import { RequestMethod, VersioningOptions } from '@nestjs/common';
+import { VersionValue } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { RoutePathMetadata } from './interfaces/route-path-metadata.interface';
+export declare class RoutePathFactory {
+    private readonly applicationConfig;
+    constructor(applicationConfig: ApplicationConfig);
+    create(metadata: RoutePathMetadata, requestMethod?: RequestMethod): string[];
+    getVersion(metadata: RoutePathMetadata): VersionValue | undefined;
+    getVersionPrefix(versioningOptions: VersioningOptions): string;
+    appendToAllIfDefined(paths: string[], fragmentToAppend: string | string[] | undefined): string[];
+    isExcludedFromGlobalPrefix(path: string, requestMethod?: RequestMethod, versionOrVersions?: VersionValue, versioningOptions?: VersioningOptions): boolean;
+    private truncateVersionPrefixFromPath;
+}

package/router/route-path-factory.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutePathFactory = void 0;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const utils_1 = require("./utils");
+class RoutePathFactory {
+    constructor(applicationConfig) {
+        this.applicationConfig = applicationConfig;
+    }
+    create(metadata, requestMethod) {
+        let paths = [''];
+        const versionOrVersions = this.getVersion(metadata);
+        if (versionOrVersions &&
+            metadata.versioningOptions?.type === common_1.VersioningType.URI) {
+            const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
+            if (Array.isArray(versionOrVersions)) {
+                paths = (0, common_1.flatten)(paths.map(path => versionOrVersions.map(version => 
+                // Version Neutral - Do not include version in URL
+                version === common_1.VERSION_NEUTRAL
+                    ? path
+                    : `${path}/${versionPrefix}${version}`)));
+            }
+            else {
+                // Version Neutral - Do not include version in URL
+                if (versionOrVersions !== common_1.VERSION_NEUTRAL) {
+                    paths = paths.map(path => `${path}/${versionPrefix}${versionOrVersions}`);
+                }
+            }
+        }
+        paths = this.appendToAllIfDefined(paths, metadata.modulePath);
+        paths = this.appendToAllIfDefined(paths, metadata.ctrlPath);
+        paths = this.appendToAllIfDefined(paths, metadata.methodPath);
+        if (metadata.globalPrefix) {
+            paths = paths.map(path => {
+                if (this.isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, metadata.versioningOptions)) {
+                    return path;
+                }
+                return (0, shared_utils_1.stripEndSlash)(metadata.globalPrefix || '') + path;
+            });
+        }
+        return paths
+            .map(path => (0, shared_utils_1.addLeadingSlash)(path || '/'))
+            .map(path => (path !== '/' ? (0, shared_utils_1.stripEndSlash)(path) : path));
+    }
+    getVersion(metadata) {
+        // The version will be either the path version or the controller version,
+        // with the pathVersion taking priority.
+        return metadata.methodVersion || metadata.controllerVersion;
+    }
+    getVersionPrefix(versioningOptions) {
+        const defaultPrefix = 'v';
+        if (versioningOptions.type === common_1.VersioningType.URI) {
+            if (versioningOptions.prefix === false) {
+                return '';
+            }
+            else if (versioningOptions.prefix !== undefined) {
+                return versioningOptions.prefix;
+            }
+        }
+        return defaultPrefix;
+    }
+    appendToAllIfDefined(paths, fragmentToAppend) {
+        if (!fragmentToAppend) {
+            return paths;
+        }
+        const concatPaths = (a, b) => (0, shared_utils_1.stripEndSlash)(a) + (0, shared_utils_1.addLeadingSlash)(b);
+        if (Array.isArray(fragmentToAppend)) {
+            const paths2dArray = paths.map(path => fragmentToAppend.map(fragment => concatPaths(path, fragment)));
+            return (0, common_1.flatten)(paths2dArray);
+        }
+        return paths.map(path => concatPaths(path, fragmentToAppend));
+    }
+    isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, versioningOptions) {
+        if ((0, shared_utils_1.isUndefined)(requestMethod)) {
+            return false;
+        }
+        const options = this.applicationConfig.getGlobalPrefixOptions();
+        const excludedRoutes = options.exclude;
+        if (versionOrVersions &&
+            versionOrVersions !== common_1.VERSION_NEUTRAL &&
+            versioningOptions?.type === common_1.VersioningType.URI) {
+            path = this.truncateVersionPrefixFromPath(path, versionOrVersions, versioningOptions);
+        }
+        return (Array.isArray(excludedRoutes) &&
+            (0, utils_1.isRouteExcluded)(excludedRoutes, path, requestMethod));
+    }
+    truncateVersionPrefixFromPath(path, versionValue, versioningOptions) {
+        if (typeof versionValue !== 'string') {
+            versionValue.forEach(version => {
+                if (typeof version === 'string') {
+                    path = this.truncateVersionPrefixFromPath(path, version, versioningOptions);
+                }
+            });
+            return path;
+        }
+        const prefix = `/${this.getVersionPrefix(versioningOptions)}${versionValue}`;
+        return path.startsWith(prefix) ? path.replace(prefix, '') : path;
+    }
+}
+exports.RoutePathFactory = RoutePathFactory;

package/router/router-exception-filters.d.ts

@@ -0,0 +1,14 @@
+import { HttpServer } from '@nestjs/common';
+import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
+import { ApplicationConfig } from '../application-config';
+import { BaseExceptionFilterContext } from '../exceptions/base-exception-filter-context';
+import { ExceptionsHandler } from '../exceptions/exceptions-handler';
+import { NestContainer } from '../injector/container';
+import { RouterProxyCallback } from './router-proxy';
+export declare class RouterExceptionFilters extends BaseExceptionFilterContext {
+    private readonly config;
+    private readonly applicationRef;
+    constructor(container: NestContainer, config: ApplicationConfig, applicationRef: HttpServer);
+    create(instance: Controller, callback: RouterProxyCallback, moduleKey: string | undefined, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExceptionsHandler;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+}

package/router/router-exception-filters.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterExceptionFilters = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const base_exception_filter_context_1 = require("../exceptions/base-exception-filter-context");
+const exceptions_handler_1 = require("../exceptions/exceptions-handler");
+const constants_2 = require("../injector/constants");
+class RouterExceptionFilters extends base_exception_filter_context_1.BaseExceptionFilterContext {
+    constructor(container, config, applicationRef) {
+        super(container);
+        this.config = config;
+        this.applicationRef = applicationRef;
+    }
+    create(instance, callback, moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = moduleKey;
+        const exceptionHandler = new exceptions_handler_1.ExceptionsHandler(this.applicationRef);
+        const filters = this.createContext(instance, callback, constants_1.EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
+        if ((0, shared_utils_1.isEmpty)(filters)) {
+            return exceptionHandler;
+        }
+        exceptionHandler.setCustomFilters(filters.reverse());
+        return exceptionHandler;
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const globalFilters = this.config.getGlobalFilters();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalFilters;
+        }
+        const scopedFilterWrappers = this.config.getGlobalRequestFilters();
+        const scopedFilters = (0, iterare_1.iterate)(scopedFilterWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(contextId, inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalFilters.concat(scopedFilters);
+    }
+}
+exports.RouterExceptionFilters = RouterExceptionFilters;

package/router/router-execution-context.d.ts

@@ -0,0 +1,54 @@
+import { CanActivate, HttpServer, ParamData, PipeTransform, RequestMethod } from '@nestjs/common';
+import { RouteParamMetadata } from '@nestjs/common/decorators';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+import { ContextType, Controller } from '@nestjs/common/interfaces';
+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';
+import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
+import { PipesConsumer } from '../pipes/pipes-consumer';
+import { PipesContextCreator } from '../pipes/pipes-context-creator';
+import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
+import { CustomHeader, RedirectResponse } from './router-response-controller';
+export interface ParamProperties {
+    index: number;
+    type: RouteParamtypes | string;
+    data: ParamData;
+    pipes: PipeTransform[];
+    extractValue: <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => any;
+}
+export declare class RouterExecutionContext {
+    private readonly paramsFactory;
+    private readonly pipesContextCreator;
+    private readonly pipesConsumer;
+    private readonly guardsContextCreator;
+    private readonly guardsConsumer;
+    private readonly interceptorsContextCreator;
+    private readonly interceptorsConsumer;
+    readonly applicationRef: HttpServer;
+    private readonly handlerMetadataStorage;
+    private readonly contextUtils;
+    private readonly responseController;
+    constructor(paramsFactory: IRouteParamsFactory, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, applicationRef: HttpServer);
+    create(instance: Controller, callback: (...args: any[]) => unknown, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextId?: import("..").ContextId, inquirerId?: string): <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => Promise<void>;
+    getMetadata<TContext extends ContextType = ContextType>(instance: Controller, callback: (...args: any[]) => any, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextType: TContext): HandlerMetadata;
+    reflectRedirect(callback: (...args: unknown[]) => unknown): RedirectResponse;
+    reflectHttpStatusCode(callback: (...args: unknown[]) => unknown): number;
+    reflectRenderTemplate(callback: (...args: unknown[]) => unknown): string;
+    reflectResponseHeaders(callback: (...args: unknown[]) => unknown): CustomHeader[];
+    reflectSse(callback: (...args: unknown[]) => unknown): string;
+    exchangeKeysForValues(keys: string[], metadata: Record<number, RouteParamMetadata>, moduleContext: string, contextId?: import("..").ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
+    getParamValue<T>(value: T, { metatype, type, data, }: {
+        metatype: unknown;
+        type: RouteParamtypes;
+        data: unknown;
+    }, pipes: PipeTransform[]): Promise<unknown>;
+    isPipeable(type: number | string): boolean;
+    createGuardsFn<TContext extends string = ContextType>(guards: CanActivate[], instance: Controller, callback: (...args: any[]) => any, contextType?: TContext): ((args: any[]) => Promise<void>) | null;
+    createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
+        metatype?: any;
+    })[]): (<TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>) | null;
+    createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
+    private isResponseHandled;
+}

package/router/router-execution-context.js

@@ -0,0 +1,186 @@
+"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 {
+    constructor(paramsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, applicationRef) {
+        this.paramsFactory = paramsFactory;
+        this.pipesContextCreator = pipesContextCreator;
+        this.pipesConsumer = pipesConsumer;
+        this.guardsContextCreator = guardsContextCreator;
+        this.guardsConsumer = guardsConsumer;
+        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);
+    }
+    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);
+        const pipes = this.pipesContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const guards = this.guardsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const interceptors = this.interceptorsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const fnCanActivate = this.createGuardsFn(guards, instance, callback, contextType);
+        const fnApplyPipes = this.createPipesFn(pipes, paramsOptions);
+        const handler = (args, req, res, next) => async () => {
+            fnApplyPipes && (await fnApplyPipes(args, req, res, next));
+            return callback.apply(instance, args);
+        };
+        return async (req, res, next) => {
+            const args = this.contextUtils.createNullArray(argsLength);
+            fnCanActivate && (await fnCanActivate([req, res, next]));
+            this.responseController.setStatus(res, httpStatusCode);
+            hasCustomHeaders &&
+                this.responseController.setHeaders(res, responseHeaders);
+            const result = await this.interceptorsConsumer.intercept(interceptors, [req, res, next], instance, callback, handler(args, req, res, next), contextType);
+            await fnHandleResponse(result, res, req);
+        };
+    }
+    getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType) {
+        const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
+        if (cacheMetadata) {
+            return cacheMetadata;
+        }
+        const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, constants_1.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 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 responseHeaders = this.reflectResponseHeaders(callback);
+        const hasCustomHeaders = !(0, shared_utils_1.isEmpty)(responseHeaders);
+        const handlerMetadata = {
+            argsLength,
+            fnHandleResponse,
+            paramtypes,
+            getParamsMetadata,
+            httpStatusCode,
+            hasCustomHeaders,
+            responseHeaders,
+        };
+        this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
+        return handlerMetadata;
+    }
+    reflectRedirect(callback) {
+        return Reflect.getMetadata(constants_1.REDIRECT_METADATA, callback);
+    }
+    reflectHttpStatusCode(callback) {
+        return Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, callback);
+    }
+    reflectRenderTemplate(callback) {
+        return Reflect.getMetadata(constants_1.RENDER_METADATA, callback);
+    }
+    reflectResponseHeaders(callback) {
+        return Reflect.getMetadata(constants_1.HEADERS_METADATA, callback) || [];
+    }
+    reflectSse(callback) {
+        return Reflect.getMetadata(constants_1.SSE_METADATA, callback);
+    }
+    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];
+            const pipes = this.pipesContextCreator.createConcreteContext(pipesCollection, contextId, inquirerId);
+            const type = this.contextUtils.mapParamType(key);
+            if (key.includes(constants_1.CUSTOM_ROUTE_ARGS_METADATA)) {
+                const { factory } = metadata[key];
+                const customExtractValue = this.contextUtils.getCustomFactory(factory, data, contextFactory);
+                return { index, extractValue: customExtractValue, type, data, pipes };
+            }
+            const numericType = Number(type);
+            const extractValue = (req, res, next) => this.paramsFactory.exchangeKeyForValue(numericType, data, {
+                req: req,
+                res,
+                next,
+            });
+            return { index, extractValue, type: numericType, data, pipes };
+        });
+    }
+    async getParamValue(value, { metatype, type, data, }, pipes) {
+        if (!(0, shared_utils_1.isEmpty)(pipes)) {
+            return this.pipesConsumer.apply(value, { metatype, type, data }, 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));
+    }
+    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);
+            }
+        };
+        return guards.length ? canActivateFn : null;
+    }
+    createPipesFn(pipes, paramsOptions) {
+        const pipesFn = async (args, req, res, next) => {
+            const resolveParamValue = async (param) => {
+                const { index, extractValue, type, data, metatype, pipes: paramPipes, } = param;
+                const value = extractValue(req, res, next);
+                args[index] = this.isPipeable(type)
+                    ? await this.getParamValue(value, { metatype, type, data }, pipes.concat(paramPipes))
+                    : value;
+            };
+            await Promise.all(paramsOptions.map(resolveParamValue));
+        };
+        return paramsOptions.length ? pipesFn : null;
+    }
+    createHandleResponseFn(callback, isResponseHandled, redirectResponse, httpStatusCode) {
+        const renderTemplate = this.reflectRenderTemplate(callback);
+        if (renderTemplate) {
+            return async (result, res) => {
+                return await this.responseController.render(result, res, renderTemplate);
+            };
+        }
+        if (redirectResponse && (0, shared_utils_1.isString)(redirectResponse.url)) {
+            return async (result, res) => {
+                await this.responseController.redirect(result, res, redirectResponse);
+            };
+        }
+        const isSseHandler = !!this.reflectSse(callback);
+        if (isSseHandler) {
+            return async (result, res, req) => {
+                await this.responseController.sse(result, res.raw || res, req.raw || req, { additionalHeaders: res.getHeaders?.() });
+            };
+        }
+        return async (result, res) => {
+            result = await this.responseController.transformToResult(result);
+            !isResponseHandled &&
+                (await this.responseController.apply(result, res, httpStatusCode));
+            return res;
+        };
+    }
+    isResponseHandled(instance, methodName, paramsMetadata) {
+        const hasResponseOrNextDecorator = paramsMetadata.some(({ type }) => type === route_paramtypes_enum_1.RouteParamtypes.RESPONSE || type === route_paramtypes_enum_1.RouteParamtypes.NEXT);
+        const isPassthroughEnabled = this.contextUtils.reflectPassthrough(instance, methodName);
+        return hasResponseOrNextDecorator && !isPassthroughEnabled;
+    }
+}
+exports.RouterExecutionContext = RouterExecutionContext;

package/router/router-explorer.d.ts

@@ -0,0 +1,47 @@
+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';
+export interface RouteDefinition {
+    path: string[];
+    requestMethod: RequestMethod;
+    targetCallback: RouterProxyCallback;
+    methodName: string;
+    version?: VersionValue;
+}
+export declare class RouterExplorer {
+    private readonly container;
+    private readonly injector;
+    private readonly routerProxy;
+    private readonly exceptionsFilter;
+    private readonly routePathFactory;
+    private readonly graphInspector;
+    private readonly executionContextCreator;
+    private readonly pathsExplorer;
+    private readonly routerMethodFactory;
+    private readonly logger;
+    private readonly exceptionFiltersCache;
+    constructor(metadataScanner: MetadataScanner, container: NestContainer, injector: Injector, routerProxy: RouterProxy, exceptionsFilter: ExceptionsFilter, config: ApplicationConfig, routePathFactory: RoutePathFactory, graphInspector: GraphInspector);
+    explore<T extends HttpServer = any>(instanceWrapper: InstanceWrapper, moduleKey: string, httpAdapterRef: T, host: string | RegExp | Array<string | RegExp>, routePathMetadata: RoutePathMetadata): void;
+    extractRouterPath(metatype: Type<Controller>): string[];
+    applyPathsToRouterProxy<T extends HttpServer>(router: T, routeDefinitions: RouteDefinition[], instanceWrapper: InstanceWrapper, moduleKey: string, routePathMetadata: RoutePathMetadata, host: string | RegExp | Array<string | RegExp>): void;
+    private applyCallbackToRouter;
+    private applyHostFilter;
+    private applyVersionFilter;
+    private createCallbackProxy;
+    createRequestScopedHandler(instanceWrapper: InstanceWrapper, requestMethod: RequestMethod, moduleRef: Module, moduleKey: string, methodName: string): <TRequest extends Record<any, any>, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<void>;
+    private getContextId;
+    private copyMetadataToCallback;
+}