@depup/nestjs__core 11.1.17-depup.0

package/helpers/external-context-creator.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalContextCreator = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const rxjs_1 = require("rxjs");
+const external_exception_filter_context_1 = require("../exceptions/external-exception-filter-context");
+const guards_1 = require("../guards");
+const constants_2 = require("../guards/constants");
+const constants_3 = require("../injector/constants");
+const interceptors_1 = require("../interceptors");
+const pipes_1 = require("../pipes");
+const context_utils_1 = require("./context-utils");
+const external_proxy_1 = require("./external-proxy");
+const handler_metadata_storage_1 = require("./handler-metadata-storage");
+class ExternalContextCreator {
+    constructor(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, modulesContainer, pipesContextCreator, pipesConsumer, filtersContextCreator) {
+        this.guardsContextCreator = guardsContextCreator;
+        this.guardsConsumer = guardsConsumer;
+        this.interceptorsContextCreator = interceptorsContextCreator;
+        this.interceptorsConsumer = interceptorsConsumer;
+        this.modulesContainer = modulesContainer;
+        this.pipesContextCreator = pipesContextCreator;
+        this.pipesConsumer = pipesConsumer;
+        this.filtersContextCreator = filtersContextCreator;
+        this.contextUtils = new context_utils_1.ContextUtils();
+        this.externalErrorProxy = new external_proxy_1.ExternalErrorProxy();
+        this.handlerMetadataStorage = new handler_metadata_storage_1.HandlerMetadataStorage();
+    }
+    static fromContainer(container) {
+        const guardsContextCreator = new guards_1.GuardsContextCreator(container, container.applicationConfig);
+        const guardsConsumer = new guards_1.GuardsConsumer();
+        const interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, container.applicationConfig);
+        const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
+        const pipesContextCreator = new pipes_1.PipesContextCreator(container, container.applicationConfig);
+        const pipesConsumer = new pipes_1.PipesConsumer();
+        const filtersContextCreator = new external_exception_filter_context_1.ExternalExceptionFilterContext(container, container.applicationConfig);
+        const externalContextCreator = new ExternalContextCreator(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getModules(), pipesContextCreator, pipesConsumer, filtersContextCreator);
+        externalContextCreator.container = container;
+        return externalContextCreator;
+    }
+    create(instance, callback, methodName, metadataKey, paramsFactory, contextId = constants_3.STATIC_CONTEXT, inquirerId, options = {
+        interceptors: true,
+        guards: true,
+        filters: true,
+    }, contextType = 'http') {
+        const moduleKey = this.getContextModuleKey(instance.constructor);
+        const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata(instance, methodName, metadataKey, paramsFactory, contextType);
+        const pipes = this.pipesContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const guards = this.guardsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const exceptionFilter = this.filtersContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const interceptors = options.interceptors
+            ? this.interceptorsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId)
+            : [];
+        const paramsMetadata = getParamsMetadata(moduleKey, contextId, inquirerId);
+        const paramsOptions = paramsMetadata
+            ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes)
+            : [];
+        const fnCanActivate = options.guards
+            ? this.createGuardsFn(guards, instance, callback, contextType)
+            : null;
+        const fnApplyPipes = this.createPipesFn(pipes, paramsOptions);
+        const handler = (initialArgs, ...args) => async () => {
+            if (fnApplyPipes) {
+                await fnApplyPipes(initialArgs, ...args);
+                return callback.apply(instance, initialArgs);
+            }
+            return callback.apply(instance, args);
+        };
+        const target = async (...args) => {
+            const initialArgs = this.contextUtils.createNullArray(argsLength);
+            fnCanActivate && (await fnCanActivate(args));
+            const result = await this.interceptorsConsumer.intercept(interceptors, args, instance, callback, handler(initialArgs, ...args), contextType);
+            return this.transformToResult(result);
+        };
+        return options.filters
+            ? this.externalErrorProxy.createProxy(target, exceptionFilter, contextType)
+            : target;
+    }
+    getMetadata(instance, methodName, metadataKey, paramsFactory, contextType) {
+        const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
+        if (cacheMetadata) {
+            return cacheMetadata;
+        }
+        const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, metadataKey || '') || {};
+        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, instance[methodName]);
+        const getParamsMetadata = (moduleKey, contextId = constants_3.STATIC_CONTEXT, inquirerId) => paramsFactory
+            ? this.exchangeKeysForValues(keys, metadata, moduleKey, paramsFactory, contextId, inquirerId, contextFactory)
+            : null;
+        const handlerMetadata = {
+            argsLength,
+            paramtypes,
+            getParamsMetadata: getParamsMetadata,
+        };
+        this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
+        return handlerMetadata;
+    }
+    getContextModuleKey(moduleCtor) {
+        const emptyModuleKey = '';
+        if (!moduleCtor) {
+            return emptyModuleKey;
+        }
+        const moduleContainerEntries = this.modulesContainer.entries();
+        for (const [key, moduleRef] of moduleContainerEntries) {
+            if (moduleRef.hasProvider(moduleCtor)) {
+                return key;
+            }
+        }
+        return emptyModuleKey;
+    }
+    exchangeKeysForValues(keys, metadata, moduleContext, paramsFactory, contextId = constants_3.STATIC_CONTEXT, inquirerId, contextFactory = this.contextUtils.getContextFactory('http')) {
+        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 = (...args) => paramsFactory.exchangeKeyForValue(numericType, data, args);
+            return { index, extractValue, type: numericType, data, pipes };
+        });
+    }
+    createPipesFn(pipes, paramsOptions) {
+        const pipesFn = async (args, ...params) => {
+            const resolveParamValue = async (param) => {
+                const { index, extractValue, type, data, metatype, pipes: paramPipes, } = param;
+                const value = extractValue(...params);
+                args[index] = await this.getParamValue(value, { metatype, type, data }, pipes.concat(paramPipes));
+            };
+            await Promise.all(paramsOptions.map(resolveParamValue));
+        };
+        return paramsOptions.length ? pipesFn : null;
+    }
+    async getParamValue(value, { metatype, type, data }, pipes) {
+        return (0, shared_utils_1.isEmpty)(pipes)
+            ? value
+            : this.pipesConsumer.apply(value, { metatype, type, data }, pipes);
+    }
+    async transformToResult(resultOrDeferred) {
+        if ((0, rxjs_1.isObservable)(resultOrDeferred)) {
+            return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
+        }
+        return resultOrDeferred;
+    }
+    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(constants_2.FORBIDDEN_MESSAGE);
+            }
+        };
+        return guards.length ? canActivateFn : null;
+    }
+    registerRequestProvider(request, contextId) {
+        this.container.registerRequestProvider(request, contextId);
+    }
+}
+exports.ExternalContextCreator = ExternalContextCreator;

package/helpers/external-proxy.d.ts

@@ -0,0 +1,5 @@
+import { ContextType } from '@nestjs/common/interfaces';
+import { ExternalExceptionsHandler } from '../exceptions/external-exceptions-handler';
+export declare class ExternalErrorProxy {
+    createProxy<TContext extends string = ContextType>(targetCallback: (...args: any[]) => any, exceptionsHandler: ExternalExceptionsHandler, type?: TContext): (...args: any[]) => Promise<any>;
+}

package/helpers/external-proxy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalErrorProxy = void 0;
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class ExternalErrorProxy {
+    createProxy(targetCallback, exceptionsHandler, type) {
+        return async (...args) => {
+            try {
+                return await targetCallback(...args);
+            }
+            catch (e) {
+                const host = new execution_context_host_1.ExecutionContextHost(args);
+                host.setType(type);
+                return exceptionsHandler.next(e, host);
+            }
+        };
+    }
+}
+exports.ExternalErrorProxy = ExternalErrorProxy;

package/helpers/get-class-scope.d.ts

@@ -0,0 +1,3 @@
+import { Scope } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export declare function getClassScope(provider: Type<unknown>): Scope;

package/helpers/get-class-scope.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassScope = getClassScope;
+const constants_1 = require("@nestjs/common/constants");
+function getClassScope(provider) {
+    const metadata = Reflect.getMetadata(constants_1.SCOPE_OPTIONS_METADATA, provider);
+    return metadata && metadata.scope;
+}

package/helpers/handler-metadata-storage.d.ts

@@ -0,0 +1,27 @@
+import { Type } from '@nestjs/common/interfaces';
+import { IncomingMessage } from 'http';
+import { Observable } from 'rxjs';
+import { ContextId } from '../injector/instance-wrapper';
+import { HeaderStream } from '../router/sse-stream';
+import { ParamProperties } from './context-utils';
+export declare const HANDLER_METADATA_SYMBOL: unique symbol;
+export type HandleResponseFn = HandlerResponseBasicFn | HandleSseResponseFn;
+export type HandlerResponseBasicFn = <TResult, TResponse>(result: TResult, res: TResponse, req?: any) => any;
+export type HandleSseResponseFn = <TResult extends Observable<unknown> = any, TResponse extends HeaderStream = any, TRequest extends IncomingMessage = any>(result: TResult, res: TResponse, req: TRequest) => any;
+export interface HandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    httpStatusCode: number;
+    responseHeaders: any[];
+    hasCustomHeaders: boolean;
+    getParamsMetadata: (moduleKey: string, contextId?: ContextId, inquirerId?: string) => (ParamProperties & {
+        metatype?: any;
+    })[];
+    fnHandleResponse: HandleResponseFn;
+}
+export declare class HandlerMetadataStorage<TValue = HandlerMetadata, TKey extends Type<unknown> = any> {
+    private readonly [HANDLER_METADATA_SYMBOL];
+    set(controller: TKey, methodName: string, metadata: TValue): void;
+    get(controller: TKey, methodName: string): TValue | undefined;
+    private getMetadataKey;
+}

package/helpers/handler-metadata-storage.js

@@ -0,0 +1,26 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlerMetadataStorage = exports.HANDLER_METADATA_SYMBOL = void 0;
+const constants_1 = require("../injector/constants");
+exports.HANDLER_METADATA_SYMBOL = Symbol.for('handler_metadata:cache');
+class HandlerMetadataStorage {
+    constructor() {
+        this[_a] = new Map();
+    }
+    set(controller, methodName, metadata) {
+        const metadataKey = this.getMetadataKey(controller, methodName);
+        this[exports.HANDLER_METADATA_SYMBOL].set(metadataKey, metadata);
+    }
+    get(controller, methodName) {
+        const metadataKey = this.getMetadataKey(controller, methodName);
+        return this[exports.HANDLER_METADATA_SYMBOL].get(metadataKey);
+    }
+    getMetadataKey(controller, methodName) {
+        const ctor = controller.constructor;
+        const controllerKey = ctor && (ctor[constants_1.CONTROLLER_ID_KEY] || ctor.name);
+        return controllerKey + methodName;
+    }
+}
+exports.HandlerMetadataStorage = HandlerMetadataStorage;
+_a = exports.HANDLER_METADATA_SYMBOL;

package/helpers/http-adapter-host.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from 'rxjs';
+import { AbstractHttpAdapter } from '../adapters/http-adapter';
+/**
+ * Defines the `HttpAdapterHost` object.
+ *
+ * `HttpAdapterHost` wraps the underlying
+ * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
+ * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
+ * provides methods to `get` and `set` the underlying HttpAdapter.
+ *
+ * @see [Http adapter](https://docs.nestjs.com/faq/http-adapter)
+ *
+ * @publicApi
+ */
+export declare class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {
+    private _httpAdapter?;
+    private _listen$;
+    private _init$;
+    private isListening;
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @param httpAdapter reference to the `HttpAdapter` to be set
+     */
+    set httpAdapter(httpAdapter: T);
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @example
+     * `const httpAdapter = adapterHost.httpAdapter;`
+     */
+    get httpAdapter(): T;
+    /**
+     * Observable that allows to subscribe to the `listen` event.
+     * This event is emitted when the HTTP application is listening for incoming requests.
+     */
+    get listen$(): Observable<void>;
+    /**
+     * Observable that allows to subscribe to the `init` event.
+     * This event is emitted when the HTTP application is initialized.
+     */
+    get init$(): Observable<void>;
+    /**
+     * Sets the listening state of the application.
+     */
+    set listening(listening: boolean);
+    /**
+     * Returns a boolean indicating whether the application is listening for incoming requests.
+     */
+    get listening(): boolean;
+}

package/helpers/http-adapter-host.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapterHost = void 0;
+const rxjs_1 = require("rxjs");
+/**
+ * Defines the `HttpAdapterHost` object.
+ *
+ * `HttpAdapterHost` wraps the underlying
+ * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
+ * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
+ * provides methods to `get` and `set` the underlying HttpAdapter.
+ *
+ * @see [Http adapter](https://docs.nestjs.com/faq/http-adapter)
+ *
+ * @publicApi
+ */
+class HttpAdapterHost {
+    constructor() {
+        this._listen$ = new rxjs_1.Subject();
+        this._init$ = new rxjs_1.ReplaySubject();
+        this.isListening = false;
+    }
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @param httpAdapter reference to the `HttpAdapter` to be set
+     */
+    set httpAdapter(httpAdapter) {
+        this._httpAdapter = httpAdapter;
+        this._init$.next();
+        this._init$.complete();
+    }
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @example
+     * `const httpAdapter = adapterHost.httpAdapter;`
+     */
+    get httpAdapter() {
+        return this._httpAdapter;
+    }
+    /**
+     * Observable that allows to subscribe to the `listen` event.
+     * This event is emitted when the HTTP application is listening for incoming requests.
+     */
+    get listen$() {
+        return this._listen$.asObservable();
+    }
+    /**
+     * Observable that allows to subscribe to the `init` event.
+     * This event is emitted when the HTTP application is initialized.
+     */
+    get init$() {
+        return this._init$.asObservable();
+    }
+    /**
+     * Sets the listening state of the application.
+     */
+    set listening(listening) {
+        this.isListening = listening;
+        if (listening) {
+            this._listen$.next();
+            this._listen$.complete();
+        }
+    }
+    /**
+     * Returns a boolean indicating whether the application is listening for incoming requests.
+     */
+    get listening() {
+        return this.isListening;
+    }
+}
+exports.HttpAdapterHost = HttpAdapterHost;

package/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context-id-factory';
+export * from './external-context-creator';
+export * from './http-adapter-host';

package/helpers/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./context-id-factory"), exports);
+tslib_1.__exportStar(require("./external-context-creator"), exports);
+tslib_1.__exportStar(require("./http-adapter-host"), exports);

package/helpers/interfaces/external-handler-metadata.interface.d.ts

@@ -0,0 +1,11 @@
+import { ContextId } from '../../injector';
+import { ParamProperties } from '../context-utils';
+type ParamPropertiesWithMetatype<T = any> = ParamProperties & {
+    metatype?: T;
+};
+export interface ExternalHandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    getParamsMetadata: (moduleKey: string, contextId?: ContextId, inquirerId?: string) => ParamPropertiesWithMetatype[];
+}
+export {};

package/helpers/interfaces/external-handler-metadata.interface.js

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

package/helpers/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './external-handler-metadata.interface';
+export * from './params-metadata.interface';

package/helpers/interfaces/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./external-handler-metadata.interface"), exports);
+tslib_1.__exportStar(require("./params-metadata.interface"), exports);

package/helpers/interfaces/params-metadata.interface.d.ts

@@ -0,0 +1,6 @@
+import { ParamData } from '@nestjs/common';
+export type ParamsMetadata = Record<number, ParamMetadata>;
+export interface ParamMetadata {
+    index: number;
+    data?: ParamData;
+}

package/helpers/interfaces/params-metadata.interface.js

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

package/helpers/is-durable.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export declare function isDurable(provider: Type<unknown>): boolean | undefined;

package/helpers/is-durable.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDurable = isDurable;
+const constants_1 = require("@nestjs/common/constants");
+function isDurable(provider) {
+    const metadata = Reflect.getMetadata(constants_1.SCOPE_OPTIONS_METADATA, provider);
+    return metadata && metadata.durable;
+}

package/helpers/load-adapter.d.ts

@@ -0,0 +1 @@
+export declare function loadAdapter(defaultPlatform: string, transport: string, loaderFn?: Function): any;

package/helpers/load-adapter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAdapter = loadAdapter;
+const common_1 = require("@nestjs/common");
+const MISSING_REQUIRED_DEPENDENCY = (defaultPlatform, transport) => `No driver (${transport}) has been selected. In order to take advantage of the default driver, please, ensure to install the "${defaultPlatform}" package ($ npm install ${defaultPlatform}).`;
+const logger = new common_1.Logger('PackageLoader');
+function loadAdapter(defaultPlatform, transport, loaderFn) {
+    try {
+        return loaderFn ? loaderFn() : require(defaultPlatform);
+    }
+    catch (e) {
+        logger.error(MISSING_REQUIRED_DEPENDENCY(defaultPlatform, transport));
+        process.exit(1);
+    }
+}

package/helpers/messages.d.ts

@@ -0,0 +1,7 @@
+import { VersionValue } from '@nestjs/common/interfaces/version-options.interface';
+export declare const MODULE_INIT_MESSAGE: (text: TemplateStringsArray, module: string) => string;
+export declare const ROUTE_MAPPED_MESSAGE: (path: string, method: string | number) => string;
+export declare const VERSIONED_ROUTE_MAPPED_MESSAGE: (path: string, method: string | number, version: VersionValue) => string;
+export declare const CONTROLLER_MAPPING_MESSAGE: (name: string, path: string) => string;
+export declare const VERSIONED_CONTROLLER_MAPPING_MESSAGE: (name: string, path: string, version: VersionValue) => string;
+export declare const INVALID_EXECUTION_CONTEXT: (methodName: string, currentContext: string) => string;

package/helpers/messages.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_EXECUTION_CONTEXT = exports.VERSIONED_CONTROLLER_MAPPING_MESSAGE = exports.CONTROLLER_MAPPING_MESSAGE = exports.VERSIONED_ROUTE_MAPPED_MESSAGE = exports.ROUTE_MAPPED_MESSAGE = exports.MODULE_INIT_MESSAGE = void 0;
+const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
+const version_options_interface_1 = require("@nestjs/common/interfaces/version-options.interface");
+const MODULE_INIT_MESSAGE = (text, module) => `${module} dependencies initialized`;
+exports.MODULE_INIT_MESSAGE = MODULE_INIT_MESSAGE;
+const ROUTE_MAPPED_MESSAGE = (path, method) => `Mapped {${path}, ${request_method_enum_1.RequestMethod[method]}} route`;
+exports.ROUTE_MAPPED_MESSAGE = ROUTE_MAPPED_MESSAGE;
+const VERSIONED_ROUTE_MAPPED_MESSAGE = (path, method, version) => {
+    const controllerVersions = Array.isArray(version) ? version : [version];
+    const versions = controllerVersions
+        .map(version => (version === version_options_interface_1.VERSION_NEUTRAL ? 'Neutral' : version))
+        .join(',');
+    return `Mapped {${path}, ${request_method_enum_1.RequestMethod[method]}} (version: ${versions}) route`;
+};
+exports.VERSIONED_ROUTE_MAPPED_MESSAGE = VERSIONED_ROUTE_MAPPED_MESSAGE;
+const CONTROLLER_MAPPING_MESSAGE = (name, path) => `${name} {${path}}:`;
+exports.CONTROLLER_MAPPING_MESSAGE = CONTROLLER_MAPPING_MESSAGE;
+const VERSIONED_CONTROLLER_MAPPING_MESSAGE = (name, path, version) => {
+    const controllerVersions = Array.isArray(version) ? version : [version];
+    const versions = controllerVersions
+        .map(version => (version === version_options_interface_1.VERSION_NEUTRAL ? 'Neutral' : version))
+        .join(',');
+    return `${name} {${path}} (version: ${versions}):`;
+};
+exports.VERSIONED_CONTROLLER_MAPPING_MESSAGE = VERSIONED_CONTROLLER_MAPPING_MESSAGE;
+const INVALID_EXECUTION_CONTEXT = (methodName, currentContext) => `Calling ${methodName} is not allowed in this context. Your current execution context is "${currentContext}".`;
+exports.INVALID_EXECUTION_CONTEXT = INVALID_EXECUTION_CONTEXT;

package/helpers/optional-require.d.ts

@@ -0,0 +1 @@
+export declare function optionalRequire(packageName: string, loaderFn?: Function): any;

package/helpers/optional-require.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalRequire = optionalRequire;
+function optionalRequire(packageName, loaderFn) {
+    try {
+        return loaderFn ? loaderFn() : require(packageName);
+    }
+    catch (e) {
+        return {};
+    }
+}

package/helpers/rethrow.d.ts

@@ -0,0 +1 @@
+export declare const rethrow: (err: unknown) => never;

package/helpers/rethrow.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rethrow = void 0;
+const rethrow = (err) => {
+    throw err;
+};
+exports.rethrow = rethrow;

package/helpers/router-method-factory.d.ts

@@ -0,0 +1,23 @@
+import { HttpServer } from '@nestjs/common';
+import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
+export declare const REQUEST_METHOD_MAP: {
+    readonly 0: "get";
+    readonly 1: "post";
+    readonly 2: "put";
+    readonly 3: "delete";
+    readonly 4: "patch";
+    readonly 5: "all";
+    readonly 6: "options";
+    readonly 7: "head";
+    readonly 8: "search";
+    readonly 9: "propfind";
+    readonly 10: "proppatch";
+    readonly 11: "mkcol";
+    readonly 12: "copy";
+    readonly 13: "move";
+    readonly 14: "lock";
+    readonly 15: "unlock";
+};
+export declare class RouterMethodFactory {
+    get(target: HttpServer, requestMethod: RequestMethod): Function;
+}

package/helpers/router-method-factory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterMethodFactory = exports.REQUEST_METHOD_MAP = void 0;
+const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
+exports.REQUEST_METHOD_MAP = {
+    [request_method_enum_1.RequestMethod.GET]: 'get',
+    [request_method_enum_1.RequestMethod.POST]: 'post',
+    [request_method_enum_1.RequestMethod.PUT]: 'put',
+    [request_method_enum_1.RequestMethod.DELETE]: 'delete',
+    [request_method_enum_1.RequestMethod.PATCH]: 'patch',
+    [request_method_enum_1.RequestMethod.ALL]: 'all',
+    [request_method_enum_1.RequestMethod.OPTIONS]: 'options',
+    [request_method_enum_1.RequestMethod.HEAD]: 'head',
+    [request_method_enum_1.RequestMethod.SEARCH]: 'search',
+    [request_method_enum_1.RequestMethod.PROPFIND]: 'propfind',
+    [request_method_enum_1.RequestMethod.PROPPATCH]: 'proppatch',
+    [request_method_enum_1.RequestMethod.MKCOL]: 'mkcol',
+    [request_method_enum_1.RequestMethod.COPY]: 'copy',
+    [request_method_enum_1.RequestMethod.MOVE]: 'move',
+    [request_method_enum_1.RequestMethod.LOCK]: 'lock',
+    [request_method_enum_1.RequestMethod.UNLOCK]: 'unlock',
+};
+class RouterMethodFactory {
+    get(target, requestMethod) {
+        const methodName = exports.REQUEST_METHOD_MAP[requestMethod];
+        const method = target[methodName];
+        if (!method) {
+            return target.use;
+        }
+        return method;
+    }
+}
+exports.RouterMethodFactory = RouterMethodFactory;

package/hooks/before-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+export declare function callBeforeAppShutdownHook(module: Module, signal?: string): Promise<void>;