@depup/nestjs__core 11.1.17-depup.0

package/middleware/routes-mapper.js

@@ -0,0 +1,117 @@
+"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 {
+    constructor(container, applicationConfig) {
+        this.container = container;
+        this.applicationConfig = applicationConfig;
+        this.pathsExplorer = new paths_explorer_1.PathsExplorer(new metadata_scanner_1.MetadataScanner());
+    }
+    mapRouteToRouteInfo(controllerOrRoute) {
+        if ((0, shared_utils_1.isString)(controllerOrRoute)) {
+            return this.getRouteInfoFromPath(controllerOrRoute);
+        }
+        const routePathOrPaths = this.getRoutePath(controllerOrRoute);
+        if (this.isRouteInfo(routePathOrPaths, controllerOrRoute)) {
+            return this.getRouteInfoFromObject(controllerOrRoute);
+        }
+        return this.getRouteInfoFromController(controllerOrRoute, routePathOrPaths);
+    }
+    getRouteInfoFromPath(routePath) {
+        const defaultRequestMethod = -1;
+        return [
+            {
+                path: (0, shared_utils_1.addLeadingSlash)(routePath),
+                method: defaultRequestMethod,
+            },
+        ];
+    }
+    getRouteInfoFromObject(routeInfoObject) {
+        const routeInfo = {
+            path: (0, shared_utils_1.addLeadingSlash)(routeInfoObject.path),
+            method: routeInfoObject.method,
+        };
+        if (routeInfoObject.version) {
+            routeInfo.version = routeInfoObject.version;
+        }
+        return [routeInfo];
+    }
+    getRouteInfoFromController(controller, routePath) {
+        const controllerPaths = this.pathsExplorer.scanForPaths(Object.create(controller), controller.prototype);
+        const controllerVersion = this.getVersionMetadata(controller);
+        const versioningConfig = this.applicationConfig.getVersioning();
+        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 toRouteInfo = (item, prefix) => item.path?.flatMap(p => {
+            let endpointPath = modulePath ?? '';
+            endpointPath += this.normalizeGlobalPath(prefix) + (0, shared_utils_1.addLeadingSlash)(p);
+            const routeInfo = {
+                path: endpointPath,
+                method: item.requestMethod,
+            };
+            const version = item.version ?? controllerVersion;
+            if (version && versioningConfig) {
+                if (typeof version !== 'string' && Array.isArray(version)) {
+                    return version.map(v => ({
+                        ...routeInfo,
+                        version: toUndefinedIfNeural(v),
+                    }));
+                }
+                routeInfo.version = toUndefinedIfNeural(version);
+            }
+            return routeInfo;
+        });
+        return []
+            .concat(routePath)
+            .map(routePath => controllerPaths
+            .map(item => toRouteInfo(item, routePath))
+            .reduce(concatPaths, []))
+            .reduce(concatPaths, []);
+    }
+    isRouteInfo(path, objectOrClass) {
+        return (0, shared_utils_1.isUndefined)(path);
+    }
+    normalizeGlobalPath(path) {
+        const prefix = (0, shared_utils_1.addLeadingSlash)(path);
+        return prefix === '/' ? '' : prefix;
+    }
+    getRoutePath(route) {
+        return Reflect.getMetadata(constants_1.PATH_METADATA, route);
+    }
+    getHostModuleOfController(metatype) {
+        if (!metatype) {
+            return;
+        }
+        const modulesContainer = this.container.getModules();
+        const moduleRefsSet = router_module_1.targetModulesByContainer.get(modulesContainer);
+        if (!moduleRefsSet) {
+            return;
+        }
+        const modules = Array.from(modulesContainer.values()).filter(moduleRef => moduleRefsSet.has(moduleRef));
+        return modules.find(({ controllers }) => controllers.has(metatype));
+    }
+    getModulePath(metatype) {
+        if (!metatype) {
+            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);
+    }
+    getVersionMetadata(metatype) {
+        const versioningConfig = this.applicationConfig.getVersioning();
+        if (versioningConfig) {
+            return (Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ??
+                versioningConfig.defaultVersion);
+        }
+    }
+}
+exports.RoutesMapper = RoutesMapper;

package/middleware/utils.d.ts

@@ -0,0 +1,8 @@
+import { HttpServer, RouteInfo, Type } from '@nestjs/common/interfaces';
+import { ExcludeRouteMetadata } from '../router/interfaces/exclude-route-metadata.interface';
+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>;
+export declare function isMiddlewareClass(middleware: any): middleware is Type<any>;
+export declare function assignToken(metatype: Type<any>, token?: string): Type<any>;
+export declare function isMiddlewareRouteExcluded(req: Record<string, any>, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer): boolean;

package/middleware/utils.js

@@ -0,0 +1,106 @@
+"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) => {
+    return routes.map(route => {
+        const originalPath = (0, shared_utils_1.isString)(route) ? route : route.path;
+        const path = legacy_route_converter_1.LegacyRouteConverter.tryConvert(originalPath);
+        try {
+            if ((0, shared_utils_1.isString)(route)) {
+                return {
+                    path,
+                    requestMethod: common_1.RequestMethod.ALL,
+                    pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
+                };
+            }
+            return {
+                path,
+                requestMethod: route.method,
+                pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
+            };
+        }
+        catch (e) {
+            if (e instanceof TypeError) {
+                legacy_route_converter_1.LegacyRouteConverter.printError(originalPath);
+            }
+            throw e;
+        }
+    });
+};
+exports.mapToExcludeRoute = mapToExcludeRoute;
+const filterMiddleware = (middleware, routes, httpAdapter) => {
+    const excludedRoutes = (0, exports.mapToExcludeRoute)(routes);
+    return (0, iterare_1.iterate)([])
+        .concat(middleware)
+        .filter(shared_utils_1.isFunction)
+        .map((item) => (0, exports.mapToClass)(item, excludedRoutes, httpAdapter))
+        .toArray();
+};
+exports.filterMiddleware = filterMiddleware;
+const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
+    if (isMiddlewareClass(middleware)) {
+        if (excludedRoutes.length <= 0) {
+            return middleware;
+        }
+        const MiddlewareHost = class extends middleware {
+            use(...params) {
+                const [req, _, next] = params;
+                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
+                if (isExcluded) {
+                    return next();
+                }
+                return super.use(...params);
+            }
+        };
+        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);
+            };
+        }
+    });
+};
+exports.mapToClass = mapToClass;
+function isMiddlewareClass(middleware) {
+    const middlewareStr = middleware.toString();
+    if (middlewareStr.substring(0, 5) === 'class') {
+        return true;
+    }
+    const middlewareArr = middlewareStr.split(' ');
+    return (middlewareArr[0] === 'function' &&
+        /[A-Z]/.test(middlewareArr[1]?.[0]) &&
+        (0, shared_utils_1.isFunction)(middleware.prototype?.use));
+}
+function assignToken(metatype, token = (0, uid_1.uid)(21)) {
+    Object.defineProperty(metatype, 'name', { value: token });
+    return metatype;
+}
+function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
+    if (excludedRoutes.length <= 0) {
+        return false;
+    }
+    const reqMethod = httpAdapter.getRequestMethod(req);
+    const originalUrl = httpAdapter.getRequestUrl(req);
+    const queryParamsIndex = originalUrl ? originalUrl.indexOf('?') : -1;
+    const pathname = queryParamsIndex >= 0
+        ? originalUrl.slice(0, queryParamsIndex)
+        : originalUrl;
+    return (0, utils_1.isRouteExcluded)(excludedRoutes, pathname, common_1.RequestMethod[reqMethod]);
+}

package/nest-application-context.d.ts

@@ -0,0 +1,173 @@
+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';
+/**
+ * @publicApi
+ */
+export declare class NestApplicationContext<TOptions extends NestApplicationContextOptions = NestApplicationContextOptions> extends AbstractInstanceResolver implements INestApplicationContext {
+    protected readonly container: NestContainer;
+    protected readonly appOptions: TOptions;
+    private contextModule;
+    private readonly scope;
+    protected isInitialized: boolean;
+    protected injector: Injector;
+    protected readonly logger: Logger;
+    private shouldFlushLogsOnOverride;
+    private readonly activeShutdownSignals;
+    private readonly moduleCompiler;
+    private shutdownCleanupRef?;
+    private _instanceLinksHost;
+    private _moduleRefsForHooksByDistance?;
+    private initializationPromise?;
+    protected get instanceLinksHost(): InstanceLinksHost;
+    constructor(container: NestContainer, appOptions?: TOptions, contextModule?: Module | null, scope?: Type<any>[]);
+    selectContextModule(): void;
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {INestApplicationContext}
+     */
+    select<T>(moduleType: Type<T> | DynamicModule, selectOptions?: SelectOptions): INestApplicationContext;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
+    /**
+     * Initializes the Nest application.
+     * Calls the Nest lifecycle events.
+     *
+     * @returns {Promise<this>} The NestApplicationContext instance as Promise
+     */
+    init(): Promise<this>;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    close(signal?: string): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs(): void;
+    /**
+     * Define that it must flush logs right after defining a custom logger.
+     */
+    flushLogsOnOverride(): void;
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     * @param {ShutdownHooksOptions} [options={}] Options for configuring shutdown hooks behavior
+     *
+     * @returns {this} The Nest application context instance
+     */
+    enableShutdownHooks(signals?: (ShutdownSignal | string)[], options?: ShutdownHooksOptions): this;
+    protected dispose(): Promise<void>;
+    /**
+     * Listens to shutdown signals by listening to
+     * process events
+     *
+     * @param {string[]} signals The system signals it should listen to
+     * @param {ShutdownHooksOptions} options Options for configuring shutdown hooks behavior
+     */
+    protected listenToShutdownSignals(signals: string[], options?: ShutdownHooksOptions): void;
+    /**
+     * Unsubscribes from shutdown signals (process events)
+     */
+    protected unsubscribeFromProcessSignals(): void;
+    /**
+     * Calls the `onModuleInit` function on the registered
+     * modules and its children.
+     */
+    protected callInitHook(): Promise<void>;
+    /**
+     * Calls the `onModuleDestroy` function on the registered
+     * modules and its children.
+     */
+    protected callDestroyHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationBootstrap` function on the registered
+     * modules and its children.
+     */
+    protected callBootstrapHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callShutdownHook(signal?: string): Promise<void>;
+    /**
+     * Calls the `beforeApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callBeforeShutdownHook(signal?: string): Promise<void>;
+    protected assertNotInPreviewMode(methodName: string): void;
+    private getModulesToTriggerHooksOn;
+    private printInPreviewModeWarning;
+}