@depup/nestjs__core 11.2.3-depup.0 → 12.0.2-depup.0

package/router/routes-resolver.js

@@ -1,38 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutesResolver = void 0;
-const common_1 = require("@nestjs/common");
-const constants_1 = require("@nestjs/common/constants");
-const logger_service_1 = require("@nestjs/common/services/logger.service");
-const messages_1 = require("../helpers/messages");
-const metadata_scanner_1 = require("../metadata-scanner");
-const route_path_factory_1 = require("./route-path-factory");
-const router_exception_filters_1 = require("./router-exception-filters");
-const router_explorer_1 = require("./router-explorer");
-const router_proxy_1 = require("./router-proxy");
-class RoutesResolver {
+import { Logger, NotFoundException, } from '@nestjs/common';
+import { HOST_METADATA, MODULE_PATH, VERSION_METADATA, } from '@nestjs/common/internal';
+import { CONTROLLER_MAPPING_MESSAGE, VERSIONED_CONTROLLER_MAPPING_MESSAGE, } from '../helpers/messages.js';
+import { MetadataScanner } from '../metadata-scanner.js';
+import { RoutePathFactory } from './route-path-factory.js';
+import { RouterExceptionFilters } from './router-exception-filters.js';
+import { RouterExplorer } from './router-explorer.js';
+import { RouterProxy } from './router-proxy.js';
+export class RoutesResolver {
+    container;
+    applicationConfig;
+    injector;
+    logger = new Logger(RoutesResolver.name, {
+        timestamp: true,
+    });
+    routerProxy = new RouterProxy();
+    routePathFactory;
+    routerExceptionsFilter;
+    routerExplorer;
     constructor(container, applicationConfig, injector, graphInspector) {
         this.container = container;
         this.applicationConfig = applicationConfig;
         this.injector = injector;
-        this.logger = new logger_service_1.Logger(RoutesResolver.name, {
-            timestamp: true,
-        });
-        this.routerProxy = new router_proxy_1.RouterProxy();
         const httpAdapterRef = container.getHttpAdapterRef();
-        this.routerExceptionsFilter = new router_exception_filters_1.RouterExceptionFilters(container, applicationConfig, httpAdapterRef);
-        this.routePathFactory = new route_path_factory_1.RoutePathFactory(this.applicationConfig);
-        const metadataScanner = new metadata_scanner_1.MetadataScanner();
-        this.routerExplorer = new router_explorer_1.RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory, graphInspector);
+        this.routerExceptionsFilter = new RouterExceptionFilters(container, applicationConfig, httpAdapterRef);
+        this.routePathFactory = new RoutePathFactory(this.applicationConfig);
+        const metadataScanner = new MetadataScanner();
+        this.routerExplorer = new RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory, graphInspector);
     }
-    resolve(applicationRef, globalPrefix) {
+    resolve(applicationRef, globalPrefix, options = {}) {
         const modules = this.container.getModules();
         modules.forEach(({ controllers, metatype }, moduleName) => {
             const modulePath = this.getModulePathMetadata(metatype);
-            this.registerRouters(controllers, moduleName, globalPrefix, modulePath, applicationRef);
+            this.registerRouters(controllers, moduleName, globalPrefix, modulePath, applicationRef, options);
         });
     }
-    registerRouters(routes, moduleName, globalPrefix, modulePath, applicationRef) {
+    registerResolvedRoute(applicationRef, route) {
+        this.routerExplorer.registerResolvedRoute(applicationRef, route);
+    }
+    registerRouters(routes, moduleName, globalPrefix, modulePath, applicationRef, options = {}) {
         routes.forEach(instanceWrapper => {
             const { metatype } = instanceWrapper;
             const host = this.getHostMetadata(metatype);
@@ -47,13 +52,13 @@ class RoutesResolver {
                 });
                 if (!controllerVersion) {
                     pathsToLog.forEach(path => {
-                        const logMessage = (0, messages_1.CONTROLLER_MAPPING_MESSAGE)(controllerName, path);
+                        const logMessage = CONTROLLER_MAPPING_MESSAGE(controllerName, path);
                         this.logger.log(logMessage);
                     });
                 }
                 else {
                     pathsToLog.forEach(path => {
-                        const logMessage = (0, messages_1.VERSIONED_CONTROLLER_MAPPING_MESSAGE)(controllerName, path, controllerVersion);
+                        const logMessage = VERSIONED_CONTROLLER_MAPPING_MESSAGE(controllerName, path, controllerVersion);
                         this.logger.log(logMessage);
                     });
                 }
@@ -65,7 +70,7 @@ class RoutesResolver {
                     controllerVersion,
                     versioningOptions,
                 };
-                this.routerExplorer.explore(instanceWrapper, moduleName, applicationRef, host, routePathMetadata);
+                this.routerExplorer.explore(instanceWrapper, moduleName, applicationRef, host, routePathMetadata, options);
             });
         });
     }
@@ -74,56 +79,38 @@ class RoutesResolver {
         const callback = (req, res) => {
             const method = applicationRef.getRequestMethod(req);
             const url = applicationRef.getRequestUrl(req);
-            throw new common_1.NotFoundException(`Cannot ${method} ${url}`);
+            throw new NotFoundException(`Cannot ${method} ${url}`);
         };
         const handler = this.routerExceptionsFilter.create({}, callback, undefined);
         const proxy = this.routerProxy.createProxy(callback, handler);
+        const prefix = this.applicationConfig.getGlobalPrefix();
         applicationRef.setNotFoundHandler &&
-            applicationRef.setNotFoundHandler(proxy, this.applicationConfig.getGlobalPrefix());
+            applicationRef.setNotFoundHandler(proxy, prefix);
     }
     registerExceptionHandler() {
         const callback = (err, req, res, next) => {
-            throw this.mapExternalException(err);
+            throw this.container.getHttpAdapterRef().mapException(err);
         };
         const handler = this.routerExceptionsFilter.create({}, callback, undefined);
         const proxy = this.routerProxy.createExceptionLayerProxy(callback, handler);
         const applicationRef = this.container.getHttpAdapterRef();
+        const prefix = this.applicationConfig.getGlobalPrefix();
         applicationRef.setErrorHandler &&
-            applicationRef.setErrorHandler(proxy, this.applicationConfig.getGlobalPrefix());
-    }
-    mapExternalException(err) {
-        switch (true) {
-            // SyntaxError is thrown by Express body-parser when given invalid JSON (#422, #430)
-            // URIError is thrown by Express when given a path parameter with an invalid percentage
-            // encoding, e.g. '%FF' (#8915)
-            case err instanceof SyntaxError || err instanceof URIError:
-                return new common_1.BadRequestException(err.message);
-            case this.isHttpFastifyError(err):
-                return new common_1.HttpException(err.message, err.statusCode);
-            default:
-                return err;
-        }
-    }
-    isHttpFastifyError(error) {
-        // condition based on this code - https://github.com/fastify/fastify-error/blob/d669b150a82968322f9f7be992b2f6b463272de3/index.js#L22
-        return (error.statusCode !== undefined &&
-            error instanceof Error &&
-            error.name === 'FastifyError');
+            applicationRef.setErrorHandler(proxy, prefix);
     }
     getModulePathMetadata(metatype) {
         const modulesContainer = this.container.getModules();
-        const modulePath = Reflect.getMetadata(constants_1.MODULE_PATH + modulesContainer.applicationId, metatype);
-        return modulePath ?? Reflect.getMetadata(constants_1.MODULE_PATH, metatype);
+        const modulePath = Reflect.getMetadata(MODULE_PATH + modulesContainer.applicationId, metatype);
+        return modulePath ?? Reflect.getMetadata(MODULE_PATH, metatype);
     }
     getHostMetadata(metatype) {
-        return Reflect.getMetadata(constants_1.HOST_METADATA, metatype);
+        return Reflect.getMetadata(HOST_METADATA, metatype);
     }
     getVersionMetadata(metatype) {
         const versioningConfig = this.applicationConfig.getVersioning();
         if (versioningConfig) {
-            return (Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ??
+            return (Reflect.getMetadata(VERSION_METADATA, metatype) ??
                 versioningConfig.defaultVersion);
         }
     }
 }
-exports.RoutesResolver = RoutesResolver;

package/router/sse-stream.d.ts

@@ -1,6 +1,6 @@
-import { MessageEvent } from '@nestjs/common/interfaces';
 import { IncomingMessage, OutgoingHttpHeaders } from 'http';
 import { Transform } from 'stream';
+import type { MessageEvent } from '@nestjs/common';
 export type AdditionalHeaders = Record<string, string[] | string | number | undefined>;
 interface ReadHeaders {
     getHeaders?(): AdditionalHeaders;
@@ -33,6 +33,7 @@ export declare class SseStream extends Transform {
     private _destination;
     private _statusCode;
     private _additionalHeaders;
+    private readonly _isHttp2;
     constructor(req?: IncomingMessage);
     get headersCommitted(): boolean;
     pipe<T extends WritableHeaderStream>(destination: T, options?: {

package/router/sse-stream.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SseStream = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const stream_1 = require("stream");
+import { Transform } from 'stream';
+import { isNil, isObject, isUndefined } from '@nestjs/common/internal';
 function serializeSseLines(value, prefix) {
     return value
         .split(/\r\n|\r|\n/)
@@ -10,7 +7,7 @@ function serializeSseLines(value, prefix) {
         .join('');
 }
 function toDataString(data) {
-    if ((0, shared_utils_1.isObject)(data)) {
+    if (isObject(data)) {
         return toDataString(JSON.stringify(data));
     }
     return serializeSseLines(data, 'data: ');
@@ -19,10 +16,10 @@ function toCommentString(comment) {
     return serializeSseLines(comment, ': ');
 }
 function isCommentOnly(message) {
-    return (!(0, shared_utils_1.isNil)(message.comment) &&
-        (0, shared_utils_1.isUndefined)(message.data) &&
-        (0, shared_utils_1.isUndefined)(message.type) &&
-        (0, shared_utils_1.isUndefined)(message.retry));
+    return (!isNil(message.comment) &&
+        isUndefined(message.data) &&
+        isUndefined(message.type) &&
+        isUndefined(message.retry));
 }
 /**
  * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
@@ -38,14 +35,21 @@ function isCommentOnly(message) {
  * If constructed with a HTTP Request, it will optimise the socket for streaming.
  * If this stream is piped to an HTTP Response, it will set appropriate headers.
  */
-class SseStream extends stream_1.Transform {
+export class SseStream extends Transform {
+    lastEventId = null;
+    _headersCommitted = false;
+    _destination = null;
+    _statusCode = 200;
+    _additionalHeaders;
+    _isHttp2;
     constructor(req) {
         super({ objectMode: true });
-        this.lastEventId = null;
-        this._headersCommitted = false;
-        this._destination = null;
-        this._statusCode = 200;
-        if (req && req.socket) {
+        this._isHttp2 = (req?.httpVersionMajor ?? 1) > 1;
+        // Under HTTP/2 these calls are not request-scoped: `setTimeout` is routed
+        // to the shared `Http2Session` and the rest to the shared TCP socket, so
+        // tuning one SSE request would disable the idle timeout for every stream
+        // on that connection. See https://nodejs.org/api/http2.html#requestsocket
+        if (req && req.socket && !this._isHttp2) {
             req.socket.setKeepAlive(true);
             req.socket.setNoDelay(true);
             req.socket.setTimeout(0);
@@ -79,9 +83,11 @@ class SseStream extends stream_1.Transform {
         if (this._destination.writeHead) {
             this._destination.writeHead(statusCode, {
                 ...additionalHeaders,
-                // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
+                // See https://github.com/dunglas/mercure/blob/main/subscribe.go#L347-L362
                 'Content-Type': 'text/event-stream',
-                Connection: 'keep-alive',
+                // Hop-by-hop header, forbidden in HTTP/2
+                // https://www.rfc-editor.org/rfc/rfc9113#section-8.2.2
+                ...(!this._isHttp2 && { Connection: 'keep-alive' }),
                 // Disable cache, even for old browsers and proxies
                 'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform',
                 Pragma: 'no-cache',
@@ -97,10 +103,10 @@ class SseStream extends stream_1.Transform {
         this.commitHeaders();
         const sanitize = (val) => String(val).replace(/[\r\n]/g, '');
         let data = message.type ? `event: ${sanitize(message.type)}\n` : '';
-        data += !(0, shared_utils_1.isNil)(message.id) ? `id: ${sanitize(message.id)}\n` : '';
-        data += !(0, shared_utils_1.isNil)(message.retry) ? `retry: ${sanitize(message.retry)}\n` : '';
-        data += !(0, shared_utils_1.isNil)(message.comment) ? toCommentString(message.comment) : '';
-        data += !(0, shared_utils_1.isNil)(message.data) ? toDataString(message.data) : '';
+        data += !isNil(message.id) ? `id: ${sanitize(message.id)}\n` : '';
+        data += !isNil(message.retry) ? `retry: ${sanitize(message.retry)}\n` : '';
+        data += !isNil(message.comment) ? toCommentString(message.comment) : '';
+        data += !isNil(message.data) ? toDataString(message.data) : '';
         data += '\n';
         this.push(data);
         callback();
@@ -109,7 +115,7 @@ class SseStream extends stream_1.Transform {
      * Calls `.write` but handles the drain if needed
      */
     writeMessage(message, cb) {
-        if ((0, shared_utils_1.isNil)(message.id) && !isCommentOnly(message)) {
+        if (isNil(message.id) && !isCommentOnly(message)) {
             this.lastEventId++;
             message.id = this.lastEventId.toString();
         }
@@ -121,4 +127,3 @@ class SseStream extends stream_1.Transform {
         }
     }
 }
-exports.SseStream = SseStream;

package/router/utils/exclude-route.util.d.ts

@@ -1,4 +1,4 @@
 import { RequestMethod } from '@nestjs/common';
-import { ExcludeRouteMetadata } from '../interfaces/exclude-route-metadata.interface';
+import { ExcludeRouteMetadata } from '../interfaces/exclude-route-metadata.interface.js';
 export declare const isRequestMethodAll: (method: RequestMethod) => boolean;
 export declare function isRouteExcluded(excludedRoutes: ExcludeRouteMetadata[], path: string, requestMethod?: RequestMethod): boolean;

package/router/utils/exclude-route.util.js

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRequestMethodAll = void 0;
-exports.isRouteExcluded = isRouteExcluded;
-const common_1 = require("@nestjs/common");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const isRequestMethodAll = (method) => {
-    return common_1.RequestMethod.ALL === method || method === -1;
+import { RequestMethod } from '@nestjs/common';
+import { addLeadingSlash } from '@nestjs/common/internal';
+export const isRequestMethodAll = (method) => {
+    return RequestMethod.ALL === method || method === -1;
 };
-exports.isRequestMethodAll = isRequestMethodAll;
-function isRouteExcluded(excludedRoutes, path, requestMethod) {
+export function isRouteExcluded(excludedRoutes, path, requestMethod) {
     return excludedRoutes.some(route => {
-        if ((0, exports.isRequestMethodAll)(route.requestMethod) ||
+        if (isRequestMethodAll(route.requestMethod) ||
             route.requestMethod === requestMethod) {
-            return route.pathRegex.exec((0, shared_utils_1.addLeadingSlash)(path));
+            return route.pathRegex.exec(addLeadingSlash(path));
         }
         return false;
     });

package/router/utils/flatten-route-paths.util.d.ts

@@ -1,5 +1,5 @@
-import { Type } from '@nestjs/common';
-import { Routes } from '../interfaces/routes.interface';
+import type { Type } from '@nestjs/common';
+import { Routes } from '../interfaces/routes.interface.js';
 export declare function flattenRoutePaths(routes: Routes): {
     module: Type;
     path: string;

package/router/utils/flatten-route-paths.util.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenRoutePaths = flattenRoutePaths;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-function flattenRoutePaths(routes) {
+import { isString, normalizePath } from '@nestjs/common/internal';
+export function flattenRoutePaths(routes) {
     const result = [];
     routes.forEach(item => {
         if (item.module && item.path) {
@@ -11,8 +8,8 @@ function flattenRoutePaths(routes) {
         if (item.children) {
             const childrenRef = item.children;
             childrenRef.forEach(child => {
-                if (!(0, shared_utils_1.isString)(child) && (0, shared_utils_1.isString)(child.path)) {
-                    child.path = (0, shared_utils_1.normalizePath)((0, shared_utils_1.normalizePath)(item.path) + (0, shared_utils_1.normalizePath)(child.path));
+                if (!isString(child) && isString(child.path)) {
+                    child.path = normalizePath(normalizePath(item.path) + normalizePath(child.path));
                 }
                 else {
                     result.push({ path: item.path, module: child });

package/router/utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from './exclude-route.util';
-export * from './flatten-route-paths.util';
+export * from './exclude-route.util.js';
+export * from './flatten-route-paths.util.js';

package/router/utils/index.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./exclude-route.util"), exports);
-tslib_1.__exportStar(require("./flatten-route-paths.util"), exports);
+export * from './exclude-route.util.js';
+export * from './flatten-route-paths.util.js';

package/scanner.d.ts

@@ -1,14 +1,14 @@
-import { DynamicModule, ForwardReference, Provider } from '@nestjs/common';
-import { EnhancerSubtype } from '@nestjs/common/constants';
-import { ClassProvider, Controller, ExistingProvider, FactoryProvider, Injectable, Type, ValueProvider } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from './application-config';
-import { NestContainer } from './injector/container';
-import { InstanceWrapper } from './injector/instance-wrapper';
-import { Module } from './injector/module';
-import { GraphInspector } from './inspector/graph-inspector';
-import { ModuleDefinition } from './interfaces/module-definition.interface';
-import { ModuleOverride } from './interfaces/module-override.interface';
-import { MetadataScanner } from './metadata-scanner';
+import type { DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { ApplicationConfig } from './application-config.js';
+import { NestContainer } from './injector/container.js';
+import { InstanceWrapper } from './injector/instance-wrapper.js';
+import { Module } from './injector/module.js';
+import { GraphInspector } from './inspector/graph-inspector.js';
+import { ModuleDefinition } from './interfaces/module-definition.interface.js';
+import { ModuleOverride } from './interfaces/module-override.interface.js';
+import { MetadataScanner } from './metadata-scanner.js';
+import { type EnhancerSubtype, type Controller, type Injectable } from '@nestjs/common/internal';
+import { type ClassProvider, type ExistingProvider, type FactoryProvider, type Type, type ValueProvider } from '@nestjs/common';
 interface ModulesScanParameters {
     moduleDefinition: ModuleDefinition;
     scope?: Type<unknown>[];