@depup/nestjs__core 11.1.17-depup.0

package/inspector/interfaces/serialized-graph-metadata.interface.d.ts

@@ -0,0 +1,10 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+export interface SerializedGraphMetadata {
+    cause: {
+        type: 'unknown-dependencies' | 'unknown';
+        context?: InjectorDependencyContext;
+        moduleId?: string;
+        nodeId?: string;
+        error?: any;
+    };
+}

package/inspector/interfaces/serialized-graph-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/noop-graph-inspector.d.ts

@@ -0,0 +1,2 @@
+import { GraphInspector } from './graph-inspector';
+export declare const NoopGraphInspector: GraphInspector;

package/inspector/noop-graph-inspector.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopGraphInspector = void 0;
+const graph_inspector_1 = require("./graph-inspector");
+const noop = () => { };
+exports.NoopGraphInspector = new Proxy(graph_inspector_1.GraphInspector.prototype, {
+    get: () => noop,
+});

package/inspector/partial-graph.host.d.ts

@@ -0,0 +1,7 @@
+import { SerializedGraph } from './serialized-graph';
+export declare class PartialGraphHost {
+    private static partialGraph;
+    static toJSON(): import("./interfaces/serialized-graph-json.interface").SerializedGraphJson;
+    static toString(): string;
+    static register(partialGraph: SerializedGraph): void;
+}

package/inspector/partial-graph.host.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialGraphHost = void 0;
+class PartialGraphHost {
+    static toJSON() {
+        return this.partialGraph?.toJSON();
+    }
+    static toString() {
+        return this.partialGraph?.toString();
+    }
+    static register(partialGraph) {
+        this.partialGraph = partialGraph;
+    }
+}
+exports.PartialGraphHost = PartialGraphHost;

package/inspector/serialized-graph.d.ts

@@ -0,0 +1,52 @@
+import { InjectionToken } from '@nestjs/common';
+import { Edge } from './interfaces/edge.interface';
+import { Entrypoint } from './interfaces/entrypoint.interface';
+import { OrphanedEnhancerDefinition } from './interfaces/extras.interface';
+import { Node } from './interfaces/node.interface';
+import { SerializedGraphJson } from './interfaces/serialized-graph-json.interface';
+import { SerializedGraphMetadata } from './interfaces/serialized-graph-metadata.interface';
+export type SerializedGraphStatus = 'partial' | 'complete';
+type WithOptionalId<T extends Record<'id', string>> = Omit<T, 'id'> & Partial<Pick<T, 'id'>>;
+export declare class SerializedGraph {
+    private readonly nodes;
+    private readonly edges;
+    private readonly entrypoints;
+    private readonly extras;
+    private _status;
+    private _metadata?;
+    private static readonly INTERNAL_PROVIDERS;
+    set status(status: SerializedGraphStatus);
+    set metadata(metadata: SerializedGraphMetadata);
+    insertNode(nodeDefinition: Node): Node | undefined;
+    insertEdge(edgeDefinition: WithOptionalId<Edge>): {
+        id: string;
+        source: string;
+        target: string;
+        metadata: ({
+            type: "module-to-module";
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        }) | ({
+            type: "class-to-class";
+            sourceClassName: string;
+            targetClassName: string;
+            sourceClassToken: InjectionToken;
+            targetClassToken: InjectionToken;
+            injectionType: "constructor" | "property" | "decorator";
+            keyOrIndex?: string | number | symbol;
+            internal?: boolean;
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        });
+    };
+    insertEntrypoint<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(nodeId: string): void;
+    getNodeById(id: string): Node | undefined;
+    toJSON(): SerializedGraphJson;
+    toString(): string;
+    private generateUuidByEdgeDefinition;
+}
+export {};

package/inspector/serialized-graph.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedGraph = void 0;
+const application_config_1 = require("../application-config");
+const external_context_creator_1 = require("../helpers/external-context-creator");
+const http_adapter_host_1 = require("../helpers/http-adapter-host");
+const inquirer_constants_1 = require("../injector/inquirer/inquirer-constants");
+const lazy_module_loader_1 = require("../injector/lazy-module-loader/lazy-module-loader");
+const module_ref_1 = require("../injector/module-ref");
+const modules_container_1 = require("../injector/modules-container");
+const request_constants_1 = require("../router/request/request-constants");
+const reflector_service_1 = require("../services/reflector.service");
+const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
+class SerializedGraph {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.entrypoints = new Map();
+        this.extras = {
+            orphanedEnhancers: [],
+            attachedEnhancers: [],
+        };
+        this._status = 'complete';
+    }
+    set status(status) {
+        this._status = status;
+    }
+    set metadata(metadata) {
+        this._metadata = metadata;
+    }
+    insertNode(nodeDefinition) {
+        if (nodeDefinition.metadata.type === 'provider' &&
+            SerializedGraph.INTERNAL_PROVIDERS.includes(nodeDefinition.metadata.token)) {
+            nodeDefinition.metadata = {
+                ...nodeDefinition.metadata,
+                internal: true,
+            };
+        }
+        if (this.nodes.has(nodeDefinition.id)) {
+            return this.nodes.get(nodeDefinition.id);
+        }
+        this.nodes.set(nodeDefinition.id, nodeDefinition);
+        return nodeDefinition;
+    }
+    insertEdge(edgeDefinition) {
+        if (edgeDefinition.metadata.type === 'class-to-class' &&
+            (SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.sourceClassToken) ||
+                SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.targetClassToken))) {
+            edgeDefinition.metadata = {
+                ...edgeDefinition.metadata,
+                internal: true,
+            };
+        }
+        const id = edgeDefinition.id ?? this.generateUuidByEdgeDefinition(edgeDefinition);
+        const edge = {
+            ...edgeDefinition,
+            id,
+        };
+        this.edges.set(id, edge);
+        return edge;
+    }
+    insertEntrypoint(definition, parentId) {
+        if (this.entrypoints.has(parentId)) {
+            const existingCollection = this.entrypoints.get(parentId);
+            existingCollection.push(definition);
+        }
+        else {
+            this.entrypoints.set(parentId, [definition]);
+        }
+    }
+    insertOrphanedEnhancer(entry) {
+        this.extras.orphanedEnhancers.push(entry);
+    }
+    insertAttachedEnhancer(nodeId) {
+        this.extras.attachedEnhancers.push({
+            nodeId,
+        });
+    }
+    getNodeById(id) {
+        return this.nodes.get(id);
+    }
+    toJSON() {
+        const json = {
+            nodes: Object.fromEntries(this.nodes),
+            edges: Object.fromEntries(this.edges),
+            entrypoints: Object.fromEntries(this.entrypoints),
+            extras: this.extras,
+        };
+        if (this._status) {
+            json['status'] = this._status;
+        }
+        if (this._metadata) {
+            json['metadata'] = this._metadata;
+        }
+        return json;
+    }
+    toString() {
+        const replacer = (key, value) => {
+            if (typeof value === 'symbol') {
+                return value.toString();
+            }
+            return typeof value === 'function' ? (value.name ?? 'Function') : value;
+        };
+        return JSON.stringify(this.toJSON(), replacer, 2);
+    }
+    generateUuidByEdgeDefinition(edgeDefinition) {
+        return deterministic_uuid_registry_1.DeterministicUuidRegistry.get(JSON.stringify(edgeDefinition));
+    }
+}
+exports.SerializedGraph = SerializedGraph;
+SerializedGraph.INTERNAL_PROVIDERS = [
+    application_config_1.ApplicationConfig,
+    module_ref_1.ModuleRef,
+    http_adapter_host_1.HttpAdapterHost,
+    lazy_module_loader_1.LazyModuleLoader,
+    external_context_creator_1.ExternalContextCreator,
+    modules_container_1.ModulesContainer,
+    reflector_service_1.Reflector,
+    SerializedGraph,
+    http_adapter_host_1.HttpAdapterHost.name,
+    reflector_service_1.Reflector.name,
+    request_constants_1.REQUEST,
+    inquirer_constants_1.INQUIRER,
+];

package/inspector/uuid-factory.d.ts

@@ -0,0 +1,9 @@
+export declare enum UuidFactoryMode {
+    Random = "random",
+    Deterministic = "deterministic"
+}
+export declare class UuidFactory {
+    private static _mode;
+    static set mode(value: UuidFactoryMode);
+    static get(key?: string): any;
+}

package/inspector/uuid-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidFactory = exports.UuidFactoryMode = void 0;
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
+var UuidFactoryMode;
+(function (UuidFactoryMode) {
+    UuidFactoryMode["Random"] = "random";
+    UuidFactoryMode["Deterministic"] = "deterministic";
+})(UuidFactoryMode || (exports.UuidFactoryMode = UuidFactoryMode = {}));
+class UuidFactory {
+    static set mode(value) {
+        this._mode = value;
+    }
+    static get(key = '') {
+        return this._mode === UuidFactoryMode.Deterministic
+            ? deterministic_uuid_registry_1.DeterministicUuidRegistry.get(key)
+            : (0, random_string_generator_util_1.randomStringGenerator)();
+    }
+}
+exports.UuidFactory = UuidFactory;
+UuidFactory._mode = UuidFactoryMode.Random;

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/interceptors/interceptors-consumer.d.ts

@@ -0,0 +1,9 @@
+import { NestInterceptor } from '@nestjs/common';
+import { ContextType, Controller } from '@nestjs/common/interfaces';
+import { Observable } from 'rxjs';
+import { ExecutionContextHost } from '../helpers/execution-context-host';
+export declare class InterceptorsConsumer {
+    intercept<TContext extends string = ContextType>(interceptors: NestInterceptor[], args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown, next: () => Promise<unknown>, type?: TContext): Promise<unknown>;
+    createContext(args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    transformDeferred(next: () => Promise<any>): Observable<any>;
+}

package/interceptors/interceptors-consumer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptorsConsumer = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const async_hooks_1 = require("async_hooks");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class InterceptorsConsumer {
+    async intercept(interceptors, args, instance, callback, next, type) {
+        if ((0, shared_utils_1.isEmpty)(interceptors)) {
+            return next();
+        }
+        const context = this.createContext(args, instance, callback);
+        context.setType(type);
+        const nextFn = async (i = 0) => {
+            if (i >= interceptors.length) {
+                return (0, rxjs_1.defer)(async_hooks_1.AsyncResource.bind(() => this.transformDeferred(next)));
+            }
+            const handler = {
+                handle: () => (0, rxjs_1.defer)(async_hooks_1.AsyncResource.bind(() => nextFn(i + 1))).pipe((0, operators_1.mergeAll)()),
+            };
+            return interceptors[i].intercept(context, handler);
+        };
+        return (0, rxjs_1.defer)(() => nextFn()).pipe((0, operators_1.mergeAll)());
+    }
+    createContext(args, instance, callback) {
+        return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
+    }
+    transformDeferred(next) {
+        return (0, rxjs_1.from)(next()).pipe((0, operators_1.switchMap)(res => {
+            const isDeferred = res instanceof Promise || res instanceof rxjs_1.Observable;
+            return isDeferred ? res : Promise.resolve(res);
+        }));
+    }
+}
+exports.InterceptorsConsumer = InterceptorsConsumer;

package/interceptors/interceptors-context-creator.d.ts

@@ -0,0 +1,16 @@
+import { Controller, NestInterceptor, Type } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { ContextCreator } from '../helpers/context-creator';
+import { NestContainer } from '../injector/container';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+export declare class InterceptorsContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
+    create(instance: Controller, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): NestInterceptor[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getInterceptorInstance(metatype: Function | NestInterceptor, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): NestInterceptor | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+}

package/interceptors/interceptors-context-creator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptorsContextCreator = 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 context_creator_1 = require("../helpers/context-creator");
+const constants_2 = require("../injector/constants");
+class InterceptorsContextCreator extends context_creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        return this.createContext(instance, callback, constants_1.INTERCEPTORS_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return (0, iterare_1.iterate)(metadata)
+            .filter(interceptor => interceptor && (interceptor.name || interceptor.intercept))
+            .map(interceptor => this.getInterceptorInstance(interceptor, contextId, inquirerId))
+            .filter((interceptor) => interceptor ? (0, shared_utils_1.isFunction)(interceptor.intercept) : false)
+            .toArray();
+    }
+    getInterceptorInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!metatype.intercept;
+        if (isObject) {
+            return metatype;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(metatype);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalInterceptors = this.config.getGlobalInterceptors();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalInterceptors;
+        }
+        const scopedInterceptorWrappers = this.config.getGlobalRequestInterceptors();
+        const scopedInterceptors = (0, iterare_1.iterate)(scopedInterceptorWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalInterceptors.concat(scopedInterceptors);
+    }
+}
+exports.InterceptorsContextCreator = InterceptorsContextCreator;

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module-definition.interface.js';
+export * from './module-override.interface.js';

package/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './module-definition.interface.js';
+export * from './module-override.interface.js';

package/interfaces/module-definition.interface.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModule, ForwardReference } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces';
+export type ModuleDefinition = ForwardReference | Type<unknown> | DynamicModule | Promise<DynamicModule>;

package/interfaces/module-definition.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/module-override.interface.d.ts

@@ -0,0 +1,5 @@
+import { ModuleDefinition } from './module-definition.interface';
+export interface ModuleOverride {
+    moduleToReplace: ModuleDefinition;
+    newModule: ModuleDefinition;
+}

package/interfaces/module-override.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/internal.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Internal module - not part of the public API.
+ * These exports are used by sibling @nestjs packages.
+ * Do not depend on these in your application code.
+ * @internal
+ * @module
+ */
+export { RuntimeException } from './errors/exceptions/runtime.exception.js';
+export { InvalidExceptionFilterException } from './errors/exceptions/invalid-exception-filter.exception.js';
+export { MESSAGES } from './constants.js';
+export { DependenciesScanner } from './scanner.js';
+export { Injector, InjectorDependencyContext } from './injector/injector.js';
+export { InstanceLoader } from './injector/instance-loader.js';
+export { InstanceWrapper } from './injector/instance-wrapper.js';
+export { Module } from './injector/module.js';
+export { STATIC_CONTEXT } from './injector/constants.js';
+export { ExecutionContextHost } from './helpers/execution-context-host.js';
+export { ContextUtils, ParamProperties } from './helpers/context-utils.js';
+export { HandlerMetadataStorage } from './helpers/handler-metadata-storage.js';
+export { RouterMethodFactory } from './helpers/router-method-factory.js';
+export { loadAdapter } from './helpers/load-adapter.js';
+export { optionalRequire } from './helpers/optional-require.js';
+export { ParamsMetadata } from './helpers/interfaces/index.js';
+export { GuardsConsumer } from './guards/guards-consumer.js';
+export { GuardsContextCreator } from './guards/guards-context-creator.js';
+export { FORBIDDEN_MESSAGE } from './guards/constants.js';
+export { PipesConsumer } from './pipes/pipes-consumer.js';
+export { PipesContextCreator } from './pipes/pipes-context-creator.js';
+export { ParamsTokenFactory } from './pipes/params-token-factory.js';
+export { InterceptorsConsumer } from './interceptors/interceptors-consumer.js';
+export { InterceptorsContextCreator } from './interceptors/interceptors-context-creator.js';
+export { BaseExceptionFilterContext } from './exceptions/base-exception-filter-context.js';
+export { LegacyRouteConverter } from './router/legacy-route-converter.js';
+export { REQUEST_CONTEXT_ID } from './router/request/request-constants.js';
+export { NoopGraphInspector } from './inspector/noop-graph-inspector.js';
+export { UuidFactory, UuidFactoryMode } from './inspector/uuid-factory.js';
+export { ModuleDefinition } from './interfaces/module-definition.interface.js';
+export { ModuleOverride } from './interfaces/module-override.interface.js';

package/internal.js

@@ -0,0 +1,46 @@
+/**
+ * Internal module - not part of the public API.
+ * These exports are used by sibling @nestjs packages.
+ * Do not depend on these in your application code.
+ * @internal
+ * @module
+ */
+// Errors
+export { RuntimeException } from './errors/exceptions/runtime.exception.js';
+export { InvalidExceptionFilterException } from './errors/exceptions/invalid-exception-filter.exception.js';
+// Constants
+export { MESSAGES } from './constants.js';
+// Scanner
+export { DependenciesScanner } from './scanner.js';
+// Injector
+export { Injector } from './injector/injector.js';
+export { InstanceLoader } from './injector/instance-loader.js';
+export { InstanceWrapper } from './injector/instance-wrapper.js';
+export { Module } from './injector/module.js';
+export { STATIC_CONTEXT } from './injector/constants.js';
+// Helpers
+export { ExecutionContextHost } from './helpers/execution-context-host.js';
+export { ContextUtils } from './helpers/context-utils.js';
+export { HandlerMetadataStorage } from './helpers/handler-metadata-storage.js';
+export { RouterMethodFactory } from './helpers/router-method-factory.js';
+export { loadAdapter } from './helpers/load-adapter.js';
+export { optionalRequire } from './helpers/optional-require.js';
+// Guards
+export { GuardsConsumer } from './guards/guards-consumer.js';
+export { GuardsContextCreator } from './guards/guards-context-creator.js';
+export { FORBIDDEN_MESSAGE } from './guards/constants.js';
+// Pipes
+export { PipesConsumer } from './pipes/pipes-consumer.js';
+export { PipesContextCreator } from './pipes/pipes-context-creator.js';
+export { ParamsTokenFactory } from './pipes/params-token-factory.js';
+// Interceptors
+export { InterceptorsConsumer } from './interceptors/interceptors-consumer.js';
+export { InterceptorsContextCreator } from './interceptors/interceptors-context-creator.js';
+// Exceptions
+export { BaseExceptionFilterContext } from './exceptions/base-exception-filter-context.js';
+// Router
+export { LegacyRouteConverter } from './router/legacy-route-converter.js';
+export { REQUEST_CONTEXT_ID } from './router/request/request-constants.js';
+// Inspector
+export { NoopGraphInspector } from './inspector/noop-graph-inspector.js';
+export { UuidFactory, UuidFactoryMode } from './inspector/uuid-factory.js';

package/metadata-scanner.d.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
+export declare class MetadataScanner {
+    private readonly cachedScannedPrototypes;
+    /**
+     * @deprecated
+     * @see {@link getAllMethodNames}
+     * @see getAllMethodNames
+     */
+    scanFromPrototype<T extends Injectable, R = any>(instance: T, prototype: object | null, callback: (name: string) => R): R[];
+    /**
+     * @deprecated
+     * @see {@link getAllMethodNames}
+     * @see getAllMethodNames
+     */
+    getAllFilteredMethodNames(prototype: object): IterableIterator<string>;
+    getAllMethodNames(prototype: object | null): string[];
+}

package/metadata-scanner.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataScanner = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+class MetadataScanner {
+    constructor() {
+        this.cachedScannedPrototypes = new Map();
+    }
+    /**
+     * @deprecated
+     * @see {@link getAllMethodNames}
+     * @see getAllMethodNames
+     */
+    scanFromPrototype(instance, prototype, callback) {
+        if (!prototype) {
+            return [];
+        }
+        const visitedNames = new Map();
+        const result = [];
+        do {
+            for (const property of Object.getOwnPropertyNames(prototype)) {
+                if (visitedNames.has(property)) {
+                    continue;
+                }
+                visitedNames.set(property, true);
+                // reason: https://github.com/nestjs/nest/pull/10821#issuecomment-1411916533
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+                if (descriptor.set ||
+                    descriptor.get ||
+                    (0, shared_utils_1.isConstructor)(property) ||
+                    !(0, shared_utils_1.isFunction)(prototype[property])) {
+                    continue;
+                }
+                const value = callback(property);
+                if ((0, shared_utils_1.isNil)(value)) {
+                    continue;
+                }
+                result.push(value);
+            }
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+            prototype !== Object.prototype);
+        return result;
+    }
+    /**
+     * @deprecated
+     * @see {@link getAllMethodNames}
+     * @see getAllMethodNames
+     */
+    *getAllFilteredMethodNames(prototype) {
+        yield* this.getAllMethodNames(prototype);
+    }
+    getAllMethodNames(prototype) {
+        if (!prototype) {
+            return [];
+        }
+        if (this.cachedScannedPrototypes.has(prototype)) {
+            return this.cachedScannedPrototypes.get(prototype);
+        }
+        const visitedNames = new Map();
+        const result = [];
+        this.cachedScannedPrototypes.set(prototype, result);
+        do {
+            for (const property of Object.getOwnPropertyNames(prototype)) {
+                if (visitedNames.has(property)) {
+                    continue;
+                }
+                visitedNames.set(property, true);
+                // reason: https://github.com/nestjs/nest/pull/10821#issuecomment-1411916533
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+                if (descriptor.set ||
+                    descriptor.get ||
+                    (0, shared_utils_1.isConstructor)(property) ||
+                    !(0, shared_utils_1.isFunction)(prototype[property])) {
+                    continue;
+                }
+                result.push(property);
+            }
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+            prototype !== Object.prototype);
+        return result;
+    }
+}
+exports.MetadataScanner = MetadataScanner;

package/middleware/builder.d.ts

@@ -0,0 +1,15 @@
+import { HttpServer, MiddlewareConsumer, Type } from '@nestjs/common/interfaces';
+import { MiddlewareConfigProxy, MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware';
+import { RouteInfoPathExtractor } from './route-info-path-extractor';
+import { RoutesMapper } from './routes-mapper';
+export declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly routesMapper;
+    private readonly httpAdapter;
+    private readonly routeInfoPathExtractor;
+    private readonly middlewareCollection;
+    constructor(routesMapper: RoutesMapper, httpAdapter: HttpServer, routeInfoPathExtractor: RouteInfoPathExtractor);
+    apply(...middleware: Array<Type<any> | Function | Array<Type<any> | Function>>): MiddlewareConfigProxy;
+    build(): MiddlewareConfiguration[];
+    getHttpAdapter(): HttpServer;
+    private static readonly ConfigProxy;
+}