@nestjs/core 11.1.15 → 12.0.0-alpha.0

package/router/router-response-controller.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterResponseController = void 0;
-const common_1 = require("@nestjs/common");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const sse_stream_1 = require("./sse-stream");
-class RouterResponseController {
+import { HttpStatus, Logger, RequestMethod, } from '@nestjs/common';
+import { EMPTY, lastValueFrom, isObservable } from 'rxjs';
+import { catchError, concatMap, map } from 'rxjs/operators';
+import { SseStream, } from './sse-stream.js';
+import { isObject } from '@nestjs/common/internal';
+export class RouterResponseController {
+    applicationRef;
+    logger = new Logger(RouterResponseController.name);
     constructor(applicationRef) {
         this.applicationRef = applicationRef;
-        this.logger = new common_1.Logger(RouterResponseController.name);
     }
     async apply(result, response, httpStatusCode) {
         return this.applicationRef.reply(response, result, httpStatusCode);
@@ -20,7 +18,7 @@ class RouterResponseController {
             ? result.statusCode
             : redirectResponse.statusCode
                 ? redirectResponse.statusCode
-                : common_1.HttpStatus.FOUND;
+                : HttpStatus.FOUND;
         const url = result && result.url ? result.url : redirectResponse.url;
         this.applicationRef.redirect(response, statusCode, url);
     }
@@ -29,17 +27,17 @@ class RouterResponseController {
         return this.applicationRef.render(response, template, result);
     }
     async transformToResult(resultOrDeferred) {
-        if ((0, rxjs_1.isObservable)(resultOrDeferred)) {
-            return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
+        if (isObservable(resultOrDeferred)) {
+            return lastValueFrom(resultOrDeferred);
         }
         return resultOrDeferred;
     }
     getStatusByMethod(requestMethod) {
         switch (requestMethod) {
-            case common_1.RequestMethod.POST:
-                return common_1.HttpStatus.CREATED;
+            case RequestMethod.POST:
+                return HttpStatus.CREATED;
             default:
-                return common_1.HttpStatus.OK;
+                return HttpStatus.OK;
         }
     }
     setHeaders(response, headers) {
@@ -55,7 +53,7 @@ class RouterResponseController {
         }
         const observableResult = await Promise.resolve(result);
         this.assertObservable(observableResult);
-        const stream = new sse_stream_1.SseStream(request);
+        const stream = new SseStream(request);
         // Extract custom status code from response if it was set
         const customStatusCode = response.statusCode;
         const pipeOptions = typeof customStatusCode !== 'undefined'
@@ -63,19 +61,19 @@ class RouterResponseController {
             : options;
         stream.pipe(response, pipeOptions);
         const subscription = observableResult
-            .pipe((0, operators_1.map)((message) => {
-            if ((0, shared_utils_1.isObject)(message)) {
+            .pipe(map((message) => {
+            if (isObject(message)) {
                 return message;
             }
             return { data: message };
-        }), (0, operators_1.concatMap)(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), (0, operators_1.catchError)(err => {
+        }), concatMap(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), catchError(err => {
             const data = err instanceof Error ? err.message : err;
             stream.writeMessage({ type: 'error', data }, writeError => {
                 if (writeError) {
                     this.logger.error(writeError);
                 }
             });
-            return rxjs_1.EMPTY;
+            return EMPTY;
         }))
             .subscribe({
             complete: () => {
@@ -90,9 +88,8 @@ class RouterResponseController {
         });
     }
     assertObservable(value) {
-        if (!(0, rxjs_1.isObservable)(value)) {
+        if (!isObservable(value)) {
             throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
         }
     }
 }
-exports.RouterResponseController = RouterResponseController;

package/router/routes-resolver.d.ts

@@ -1,10 +1,11 @@
-import { Controller, HttpServer } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from '../application-config';
-import { NestContainer } from '../injector/container';
-import { Injector } from '../injector/injector';
-import { InstanceWrapper } from '../injector/instance-wrapper';
-import { GraphInspector } from '../inspector/graph-inspector';
-import { Resolver } from './interfaces/resolver.interface';
+import { ApplicationConfig } from '../application-config.js';
+import { NestContainer } from '../injector/container.js';
+import { Injector } from '../injector/injector.js';
+import { InstanceWrapper } from '../injector/instance-wrapper.js';
+import { GraphInspector } from '../inspector/graph-inspector.js';
+import { Resolver } from './interfaces/resolver.interface.js';
+import { type Controller } from '@nestjs/common/internal';
+import { type HttpServer } from '@nestjs/common';
 export declare class RoutesResolver implements Resolver {
     private readonly container;
     private readonly applicationConfig;
@@ -19,8 +20,6 @@ export declare class RoutesResolver implements Resolver {
     registerRouters(routes: Map<string | symbol | Function, InstanceWrapper<Controller>>, moduleName: string, globalPrefix: string, modulePath: string, applicationRef: HttpServer): void;
     registerNotFoundHandler(): void;
     registerExceptionHandler(): void;
-    mapExternalException(err: any): any;
-    private isHttpFastifyError;
     private getModulePathMetadata;
     private getHostMetadata;
     private getVersionMetadata;

package/router/routes-resolver.js

@@ -1,29 +1,32 @@
-"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 { NotFoundException, } from '@nestjs/common';
+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';
+import { HOST_METADATA, MODULE_PATH, VERSION_METADATA, } from '@nestjs/common/internal';
+import { Logger } from '@nestjs/common';
+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) {
         const modules = this.container.getModules();
@@ -47,13 +50,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);
                     });
                 }
@@ -74,56 +77,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;

package/router/sse-stream.js

@@ -1,10 +1,7 @@
-"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 { isObject } from '@nestjs/common/internal';
 function toDataString(data) {
-    if ((0, shared_utils_1.isObject)(data)) {
+    if (isObject(data)) {
         return toDataString(JSON.stringify(data));
     }
     return data
@@ -25,10 +22,10 @@ function toDataString(data) {
  * 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;
     constructor(req) {
         super({ objectMode: true });
-        this.lastEventId = null;
         if (req && req.socket) {
             req.socket.setKeepAlive(true);
             req.socket.setNoDelay(true);
@@ -80,4 +77,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>[];