@nestjs/core 11.1.16 → 12.0.0-alpha.0

package/router/paths-explorer.d.ts

@@ -1,8 +1,7 @@
-import { RequestMethod } from '@nestjs/common/enums';
-import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
-import { VersionValue } from '@nestjs/common/interfaces/version-options.interface';
-import { MetadataScanner } from '../metadata-scanner';
-import { RouterProxyCallback } from './router-proxy';
+import { MetadataScanner } from '../metadata-scanner.js';
+import { RouterProxyCallback } from './router-proxy.js';
+import { type Controller, type VersionValue } from '@nestjs/common/internal';
+import type { RequestMethod } from '@nestjs/common';
 export interface RouteDefinition {
     path: string[];
     requestMethod: RequestMethod;

package/router/paths-explorer.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathsExplorer = void 0;
-const constants_1 = require("@nestjs/common/constants");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-class PathsExplorer {
+import { METHOD_METADATA, PATH_METADATA, VERSION_METADATA, addLeadingSlash, isString, isUndefined, } from '@nestjs/common/internal';
+export class PathsExplorer {
+    metadataScanner;
     constructor(metadataScanner) {
         this.metadataScanner = metadataScanner;
     }
     scanForPaths(instance, prototype) {
-        const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
+        const instancePrototype = isUndefined(prototype)
             ? Object.getPrototypeOf(instance)
             : prototype;
         return this.metadataScanner
@@ -24,15 +21,15 @@ class PathsExplorer {
     exploreMethodMetadata(instance, prototype, methodName) {
         const instanceCallback = instance[methodName];
         const prototypeCallback = prototype[methodName];
-        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
-        if ((0, shared_utils_1.isUndefined)(routePath)) {
+        const routePath = Reflect.getMetadata(PATH_METADATA, prototypeCallback);
+        if (isUndefined(routePath)) {
             return null;
         }
-        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
-        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
-        const path = (0, shared_utils_1.isString)(routePath)
-            ? [(0, shared_utils_1.addLeadingSlash)(routePath)]
-            : routePath.map((p) => (0, shared_utils_1.addLeadingSlash)(p));
+        const requestMethod = Reflect.getMetadata(METHOD_METADATA, prototypeCallback);
+        const version = Reflect.getMetadata(VERSION_METADATA, prototypeCallback);
+        const path = isString(routePath)
+            ? [addLeadingSlash(routePath)]
+            : routePath.map((p) => addLeadingSlash(p));
         return {
             path,
             requestMethod,
@@ -42,4 +39,3 @@ class PathsExplorer {
         };
     }
 }
-exports.PathsExplorer = PathsExplorer;

package/router/request/index.d.ts

@@ -1 +1 @@
-export { REQUEST } from './request-constants';
+export { REQUEST } from './request-constants.js';

package/router/request/index.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUEST = void 0;
-var request_constants_1 = require("./request-constants");
-Object.defineProperty(exports, "REQUEST", { enumerable: true, get: function () { return request_constants_1.REQUEST; } });
+export { REQUEST } from './request-constants.js';

package/router/request/request-constants.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUEST_CONTEXT_ID = exports.REQUEST = void 0;
-exports.REQUEST = 'REQUEST';
-exports.REQUEST_CONTEXT_ID = Symbol('REQUEST_CONTEXT_ID');
+export const REQUEST = 'REQUEST';
+export const REQUEST_CONTEXT_ID = Symbol('REQUEST_CONTEXT_ID');

package/router/request/request-providers.d.ts

@@ -1,2 +1,2 @@
-import { Provider } from '@nestjs/common';
+import { type Provider } from '@nestjs/common';
 export declare const requestProvider: Provider;

package/router/request/request-providers.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestProvider = void 0;
-const common_1 = require("@nestjs/common");
-const request_constants_1 = require("./request-constants");
+import { Scope } from '@nestjs/common';
+import { REQUEST } from './request-constants.js';
 const noop = () => { };
-exports.requestProvider = {
-    provide: request_constants_1.REQUEST,
-    scope: common_1.Scope.REQUEST,
+export const requestProvider = {
+    provide: REQUEST,
+    scope: Scope.REQUEST,
     useFactory: noop,
 };

package/router/route-params-factory.d.ts

@@ -1,5 +1,5 @@
-import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
-import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
+import { IRouteParamsFactory } from './interfaces/route-params-factory.interface.js';
+import { RouteParamtypes } from '@nestjs/common/internal';
 export declare class RouteParamsFactory implements IRouteParamsFactory {
     exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: string, { req, res, next }: {
         req: TRequest;

package/router/route-params-factory.js

@@ -1,41 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteParamsFactory = void 0;
-const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
-class RouteParamsFactory {
+import { RouteParamtypes } from '@nestjs/common/internal';
+export class RouteParamsFactory {
     exchangeKeyForValue(key, data, { req, res, next }) {
         switch (key) {
-            case route_paramtypes_enum_1.RouteParamtypes.NEXT:
+            case RouteParamtypes.NEXT:
                 return next;
-            case route_paramtypes_enum_1.RouteParamtypes.REQUEST:
+            case RouteParamtypes.REQUEST:
                 return req;
-            case route_paramtypes_enum_1.RouteParamtypes.RESPONSE:
+            case RouteParamtypes.RESPONSE:
                 return res;
-            case route_paramtypes_enum_1.RouteParamtypes.BODY:
+            case RouteParamtypes.BODY:
                 return data && req.body ? req.body[data] : req.body;
-            case route_paramtypes_enum_1.RouteParamtypes.RAW_BODY:
+            case RouteParamtypes.RAW_BODY:
                 return req.rawBody;
-            case route_paramtypes_enum_1.RouteParamtypes.PARAM:
+            case RouteParamtypes.PARAM:
                 return data ? req.params[data] : req.params;
-            case route_paramtypes_enum_1.RouteParamtypes.HOST:
+            case RouteParamtypes.HOST:
                 /* eslint-disable-next-line no-case-declarations */
                 const hosts = req.hosts || {};
                 return data ? hosts[data] : hosts;
-            case route_paramtypes_enum_1.RouteParamtypes.QUERY:
+            case RouteParamtypes.QUERY:
                 return data ? req.query[data] : req.query;
-            case route_paramtypes_enum_1.RouteParamtypes.HEADERS:
+            case RouteParamtypes.HEADERS:
                 return data ? req.headers[data.toLowerCase()] : req.headers;
-            case route_paramtypes_enum_1.RouteParamtypes.SESSION:
+            case RouteParamtypes.SESSION:
                 return req.session;
-            case route_paramtypes_enum_1.RouteParamtypes.FILE:
+            case RouteParamtypes.FILE:
                 return req[data || 'file'];
-            case route_paramtypes_enum_1.RouteParamtypes.FILES:
+            case RouteParamtypes.FILES:
                 return req.files;
-            case route_paramtypes_enum_1.RouteParamtypes.IP:
+            case RouteParamtypes.IP:
                 return req.ip;
             default:
                 return null;
         }
     }
 }
-exports.RouteParamsFactory = RouteParamsFactory;

package/router/route-path-factory.d.ts

@@ -1,7 +1,7 @@
-import { RequestMethod, VersioningOptions } from '@nestjs/common';
-import { VersionValue } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from '../application-config';
-import { RoutePathMetadata } from './interfaces/route-path-metadata.interface';
+import { type RequestMethod, type VersioningOptions } from '@nestjs/common';
+import { ApplicationConfig } from '../application-config.js';
+import { RoutePathMetadata } from './interfaces/route-path-metadata.interface.js';
+import { type VersionValue } from '@nestjs/common/internal';
 export declare class RoutePathFactory {
     private readonly applicationConfig;
     constructor(applicationConfig: ApplicationConfig);

package/router/route-path-factory.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutePathFactory = void 0;
-const common_1 = require("@nestjs/common");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const utils_1 = require("./utils");
-class RoutePathFactory {
+import { VERSION_NEUTRAL, VersioningType, flatten, } from '@nestjs/common';
+import { isRouteExcluded } from './utils/index.js';
+import { addLeadingSlash, isUndefined, stripEndSlash, } from '@nestjs/common/internal';
+export class RoutePathFactory {
+    applicationConfig;
     constructor(applicationConfig) {
         this.applicationConfig = applicationConfig;
     }
@@ -12,18 +10,18 @@ class RoutePathFactory {
         let paths = [''];
         const versionOrVersions = this.getVersion(metadata);
         if (versionOrVersions &&
-            metadata.versioningOptions?.type === common_1.VersioningType.URI) {
+            metadata.versioningOptions?.type === VersioningType.URI) {
             const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
             if (Array.isArray(versionOrVersions)) {
-                paths = (0, common_1.flatten)(paths.map(path => versionOrVersions.map(version => 
+                paths = flatten(paths.map(path => versionOrVersions.map(version => 
                 // Version Neutral - Do not include version in URL
-                version === common_1.VERSION_NEUTRAL
+                version === VERSION_NEUTRAL
                     ? path
                     : `${path}/${versionPrefix}${version}`)));
             }
             else {
                 // Version Neutral - Do not include version in URL
-                if (versionOrVersions !== common_1.VERSION_NEUTRAL) {
+                if (versionOrVersions !== VERSION_NEUTRAL) {
                     paths = paths.map(path => `${path}/${versionPrefix}${versionOrVersions}`);
                 }
             }
@@ -36,12 +34,12 @@ class RoutePathFactory {
                 if (this.isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, metadata.versioningOptions)) {
                     return path;
                 }
-                return (0, shared_utils_1.stripEndSlash)(metadata.globalPrefix || '') + path;
+                return stripEndSlash(metadata.globalPrefix || '') + path;
             });
         }
         return paths
-            .map(path => (0, shared_utils_1.addLeadingSlash)(path || '/'))
-            .map(path => (path !== '/' ? (0, shared_utils_1.stripEndSlash)(path) : path));
+            .map(path => addLeadingSlash(path || '/'))
+            .map(path => (path !== '/' ? stripEndSlash(path) : path));
     }
     getVersion(metadata) {
         // The version will be either the path version or the controller version,
@@ -50,7 +48,7 @@ class RoutePathFactory {
     }
     getVersionPrefix(versioningOptions) {
         const defaultPrefix = 'v';
-        if (versioningOptions.type === common_1.VersioningType.URI) {
+        if (versioningOptions.type === VersioningType.URI) {
             if (versioningOptions.prefix === false) {
                 return '';
             }
@@ -64,26 +62,26 @@ class RoutePathFactory {
         if (!fragmentToAppend) {
             return paths;
         }
-        const concatPaths = (a, b) => (0, shared_utils_1.stripEndSlash)(a) + (0, shared_utils_1.addLeadingSlash)(b);
+        const concatPaths = (a, b) => stripEndSlash(a) + addLeadingSlash(b);
         if (Array.isArray(fragmentToAppend)) {
             const paths2dArray = paths.map(path => fragmentToAppend.map(fragment => concatPaths(path, fragment)));
-            return (0, common_1.flatten)(paths2dArray);
+            return flatten(paths2dArray);
         }
         return paths.map(path => concatPaths(path, fragmentToAppend));
     }
     isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, versioningOptions) {
-        if ((0, shared_utils_1.isUndefined)(requestMethod)) {
+        if (isUndefined(requestMethod)) {
             return false;
         }
         const options = this.applicationConfig.getGlobalPrefixOptions();
         const excludedRoutes = options.exclude;
         if (versionOrVersions &&
-            versionOrVersions !== common_1.VERSION_NEUTRAL &&
-            versioningOptions?.type === common_1.VersioningType.URI) {
+            versionOrVersions !== VERSION_NEUTRAL &&
+            versioningOptions?.type === VersioningType.URI) {
             path = this.truncateVersionPrefixFromPath(path, versionOrVersions, versioningOptions);
         }
         return (Array.isArray(excludedRoutes) &&
-            (0, utils_1.isRouteExcluded)(excludedRoutes, path, requestMethod));
+            isRouteExcluded(excludedRoutes, path, requestMethod));
     }
     truncateVersionPrefixFromPath(path, versionValue, versioningOptions) {
         if (typeof versionValue !== 'string') {
@@ -98,4 +96,3 @@ class RoutePathFactory {
         return path.startsWith(prefix) ? path.replace(prefix, '') : path;
     }
 }
-exports.RoutePathFactory = RoutePathFactory;

package/router/router-exception-filters.d.ts

@@ -1,14 +1,14 @@
-import { HttpServer } from '@nestjs/common';
-import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
-import { ApplicationConfig } from '../application-config';
-import { BaseExceptionFilterContext } from '../exceptions/base-exception-filter-context';
-import { ExceptionsHandler } from '../exceptions/exceptions-handler';
-import { NestContainer } from '../injector/container';
-import { RouterProxyCallback } from './router-proxy';
+import type { HttpServer } from '@nestjs/common';
+import { ApplicationConfig } from '../application-config.js';
+import { BaseExceptionFilterContext } from '../exceptions/base-exception-filter-context.js';
+import { ExceptionsHandler } from '../exceptions/exceptions-handler.js';
+import { NestContainer } from '../injector/container.js';
+import { RouterProxyCallback } from './router-proxy.js';
+import { type Controller } from '@nestjs/common/internal';
 export declare class RouterExceptionFilters extends BaseExceptionFilterContext {
     private readonly config;
     private readonly applicationRef;
     constructor(container: NestContainer, config: ApplicationConfig, applicationRef: HttpServer);
-    create(instance: Controller, callback: RouterProxyCallback, moduleKey: string | undefined, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExceptionsHandler;
-    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+    create(instance: Controller, callback: RouterProxyCallback, moduleKey: string | undefined, contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): ExceptionsHandler;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): T;
 }

package/router/router-exception-filters.js

@@ -1,35 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterExceptionFilters = 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 base_exception_filter_context_1 = require("../exceptions/base-exception-filter-context");
-const exceptions_handler_1 = require("../exceptions/exceptions-handler");
-const constants_2 = require("../injector/constants");
-class RouterExceptionFilters extends base_exception_filter_context_1.BaseExceptionFilterContext {
+import { iterate } from 'iterare';
+import { BaseExceptionFilterContext } from '../exceptions/base-exception-filter-context.js';
+import { ExceptionsHandler } from '../exceptions/exceptions-handler.js';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { EXCEPTION_FILTERS_METADATA, isEmptyArray, } from '@nestjs/common/internal';
+export class RouterExceptionFilters extends BaseExceptionFilterContext {
+    config;
+    applicationRef;
     constructor(container, config, applicationRef) {
         super(container);
         this.config = config;
         this.applicationRef = applicationRef;
     }
-    create(instance, callback, moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    create(instance, callback, moduleKey, contextId = STATIC_CONTEXT, inquirerId) {
         this.moduleContext = moduleKey;
-        const exceptionHandler = new exceptions_handler_1.ExceptionsHandler(this.applicationRef);
-        const filters = this.createContext(instance, callback, constants_1.EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
-        if ((0, shared_utils_1.isEmpty)(filters)) {
+        const exceptionHandler = new ExceptionsHandler(this.applicationRef);
+        const filters = this.createContext(instance, callback, EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
+        if (isEmptyArray(filters)) {
             return exceptionHandler;
         }
         exceptionHandler.setCustomFilters(filters.reverse());
         return exceptionHandler;
     }
-    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    getGlobalMetadata(contextId = STATIC_CONTEXT, inquirerId) {
         const globalFilters = this.config.getGlobalFilters();
-        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+        if (contextId === STATIC_CONTEXT && !inquirerId) {
             return globalFilters;
         }
         const scopedFilterWrappers = this.config.getGlobalRequestFilters();
-        const scopedFilters = (0, iterare_1.iterate)(scopedFilterWrappers)
+        const scopedFilters = iterate(scopedFilterWrappers)
             .map(wrapper => wrapper.getInstanceByContextId(contextId, inquirerId))
             .filter(host => !!host)
             .map(host => host.instance)
@@ -37,4 +35,3 @@ class RouterExceptionFilters extends base_exception_filter_context_1.BaseExcepti
         return globalFilters.concat(scopedFilters);
     }
 }
-exports.RouterExceptionFilters = RouterExceptionFilters;

package/router/router-execution-context.d.ts

@@ -1,22 +1,23 @@
-import { CanActivate, HttpServer, ParamData, PipeTransform, RequestMethod } from '@nestjs/common';
-import { RouteParamMetadata } from '@nestjs/common/decorators';
-import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
-import { ContextType, Controller } from '@nestjs/common/interfaces';
-import { GuardsConsumer, GuardsContextCreator } from '../guards';
-import { ExecutionContextHost } from '../helpers/execution-context-host';
-import { HandleResponseFn, HandlerMetadata } from '../helpers/handler-metadata-storage';
-import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
-import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
-import { PipesConsumer } from '../pipes/pipes-consumer';
-import { PipesContextCreator } from '../pipes/pipes-context-creator';
-import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
-import { CustomHeader, RedirectResponse } from './router-response-controller';
+import type { ArgumentMetadata, ContextType, RouteParamMetadata } from '@nestjs/common';
+import { type CanActivate, type HttpServer, type ParamData, type PipeTransform, type RequestMethod } from '@nestjs/common';
+import { type Controller, RouteParamtypes } from '@nestjs/common/internal';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { GuardsConsumer, GuardsContextCreator } from '../guards/index.js';
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+import { HandleResponseFn, HandlerMetadata } from '../helpers/handler-metadata-storage.js';
+import { InterceptorsConsumer } from '../interceptors/interceptors-consumer.js';
+import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator.js';
+import { PipesConsumer } from '../pipes/pipes-consumer.js';
+import { PipesContextCreator } from '../pipes/pipes-context-creator.js';
+import { IRouteParamsFactory } from './interfaces/route-params-factory.interface.js';
+import { CustomHeader, RedirectResponse } from './router-response-controller.js';
 export interface ParamProperties {
     index: number;
     type: RouteParamtypes | string;
     data: ParamData;
     pipes: PipeTransform[];
     extractValue: <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => any;
+    schema?: StandardSchemaV1;
 }
 export declare class RouterExecutionContext {
     private readonly paramsFactory;
@@ -31,19 +32,15 @@ export declare class RouterExecutionContext {
     private readonly contextUtils;
     private readonly responseController;
     constructor(paramsFactory: IRouteParamsFactory, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, applicationRef: HttpServer);
-    create(instance: Controller, callback: (...args: any[]) => unknown, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextId?: import("..").ContextId, inquirerId?: string): <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => Promise<void>;
+    create(instance: Controller, callback: (...args: any[]) => unknown, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextId?: import("../index.js").ContextId, inquirerId?: string): <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => Promise<void>;
     getMetadata<TContext extends ContextType = ContextType>(instance: Controller, callback: (...args: any[]) => any, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextType: TContext): HandlerMetadata;
     reflectRedirect(callback: (...args: unknown[]) => unknown): RedirectResponse;
     reflectHttpStatusCode(callback: (...args: unknown[]) => unknown): number;
     reflectRenderTemplate(callback: (...args: unknown[]) => unknown): string;
     reflectResponseHeaders(callback: (...args: unknown[]) => unknown): CustomHeader[];
     reflectSse(callback: (...args: unknown[]) => unknown): string;
-    exchangeKeysForValues(keys: string[], metadata: Record<number, RouteParamMetadata>, moduleContext: string, contextId?: import("..").ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
-    getParamValue<T>(value: T, { metatype, type, data, }: {
-        metatype: unknown;
-        type: RouteParamtypes;
-        data: unknown;
-    }, pipes: PipeTransform[]): Promise<unknown>;
+    exchangeKeysForValues(keys: string[], metadata: Record<number, RouteParamMetadata>, moduleContext: string, contextId?: import("../index.js").ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
+    getParamValue<T>(value: T, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<unknown>;
     isPipeable(type: number | string): boolean;
     createGuardsFn<TContext extends string = ContextType>(guards: CanActivate[], instance: Controller, callback: (...args: any[]) => any, contextType?: TContext): ((args: any[]) => Promise<void>) | null;
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {