@nestjs/core 11.1.16 → 12.0.0-alpha.1

package/exceptions/exceptions-handler.js

@@ -1,15 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExceptionsHandler = void 0;
-const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
-const base_exception_filter_1 = require("./base-exception-filter");
-class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
-    constructor() {
-        super(...arguments);
-        this.filters = [];
-    }
+import { InvalidExceptionFilterException } from '../errors/exceptions/invalid-exception-filter.exception.js';
+import { BaseExceptionFilter } from './base-exception-filter.js';
+import { selectExceptionFilterMetadata, isEmptyArray, } from '@nestjs/common/internal';
+export class ExceptionsHandler extends BaseExceptionFilter {
+    filters = [];
     next(exception, ctx) {
         if (this.invokeCustomFilters(exception, ctx)) {
             return;
@@ -18,17 +11,16 @@ class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
     }
     setCustomFilters(filters) {
         if (!Array.isArray(filters)) {
-            throw new invalid_exception_filter_exception_1.InvalidExceptionFilterException();
+            throw new InvalidExceptionFilterException();
         }
         this.filters = filters;
     }
     invokeCustomFilters(exception, ctx) {
-        if ((0, shared_utils_1.isEmpty)(this.filters)) {
+        if (isEmptyArray(this.filters)) {
             return false;
         }
-        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
+        const filter = selectExceptionFilterMetadata(this.filters, exception);
         filter && filter.func(exception, ctx);
         return !!filter;
     }
 }
-exports.ExceptionsHandler = ExceptionsHandler;

package/exceptions/external-exception-filter-context.d.ts

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

package/exceptions/external-exception-filter-context.js

@@ -1,37 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalExceptionFilterContext = 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 constants_2 = require("../injector/constants");
-const base_exception_filter_context_1 = require("./base-exception-filter-context");
-const external_exceptions_handler_1 = require("./external-exceptions-handler");
-class ExternalExceptionFilterContext extends base_exception_filter_context_1.BaseExceptionFilterContext {
+import { iterate } from 'iterare';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { BaseExceptionFilterContext } from './base-exception-filter-context.js';
+import { ExternalExceptionsHandler } from './external-exceptions-handler.js';
+import { EXCEPTION_FILTERS_METADATA, isEmptyArray, } from '@nestjs/common/internal';
+export class ExternalExceptionFilterContext extends BaseExceptionFilterContext {
+    config;
     constructor(container, config) {
         super(container);
         this.config = config;
     }
-    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    create(instance, callback, module, contextId = STATIC_CONTEXT, inquirerId) {
         this.moduleContext = module;
-        const exceptionHandler = new external_exceptions_handler_1.ExternalExceptionsHandler();
-        const filters = this.createContext(instance, callback, constants_1.EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
-        if ((0, shared_utils_1.isEmpty)(filters)) {
+        const exceptionHandler = new ExternalExceptionsHandler();
+        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) {
         if (!this.config) {
             return [];
         }
         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)
@@ -39,4 +36,3 @@ class ExternalExceptionFilterContext extends base_exception_filter_context_1.Bas
         return globalFilters.concat(scopedFilters);
     }
 }
-exports.ExternalExceptionFilterContext = ExternalExceptionFilterContext;

package/exceptions/external-exception-filter.d.ts

@@ -1,4 +1,4 @@
-import { ArgumentsHost } from '@nestjs/common';
+import { type ArgumentsHost } from '@nestjs/common';
 export declare class ExternalExceptionFilter<T = any, R = any> {
     private static readonly logger;
     catch(exception: T, host: ArgumentsHost): R | Promise<R>;

package/exceptions/external-exception-filter.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalExceptionFilter = void 0;
-const common_1 = require("@nestjs/common");
-class ExternalExceptionFilter {
+import { IntrinsicException, Logger } from '@nestjs/common';
+export class ExternalExceptionFilter {
+    static logger = new Logger('ExceptionsHandler');
     catch(exception, host) {
         if (exception instanceof Error &&
-            !(exception instanceof common_1.IntrinsicException)) {
+            !(exception instanceof IntrinsicException)) {
             ExternalExceptionFilter.logger.error(exception);
         }
         throw exception;
     }
 }
-exports.ExternalExceptionFilter = ExternalExceptionFilter;
-ExternalExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');

package/exceptions/external-exceptions-handler.d.ts

@@ -1,6 +1,6 @@
-import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
-import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
-import { ExternalExceptionFilter } from './external-exception-filter';
+import { ExternalExceptionFilter } from './external-exception-filter.js';
+import { type ExceptionFilterMetadata } from '@nestjs/common/internal';
+import type { ArgumentsHost } from '@nestjs/common';
 export declare class ExternalExceptionsHandler extends ExternalExceptionFilter {
     private filters;
     next(exception: Error, host: ArgumentsHost): Promise<any>;

package/exceptions/external-exceptions-handler.js

@@ -1,15 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalExceptionsHandler = void 0;
-const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
-const external_exception_filter_1 = require("./external-exception-filter");
-class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExceptionFilter {
-    constructor() {
-        super(...arguments);
-        this.filters = [];
-    }
+import { InvalidExceptionFilterException } from '../errors/exceptions/invalid-exception-filter.exception.js';
+import { ExternalExceptionFilter } from './external-exception-filter.js';
+import { selectExceptionFilterMetadata, isEmptyArray, } from '@nestjs/common/internal';
+export class ExternalExceptionsHandler extends ExternalExceptionFilter {
+    filters = [];
     next(exception, host) {
         const result = this.invokeCustomFilters(exception, host);
         if (result) {
@@ -19,16 +12,15 @@ class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExce
     }
     setCustomFilters(filters) {
         if (!Array.isArray(filters)) {
-            throw new invalid_exception_filter_exception_1.InvalidExceptionFilterException();
+            throw new InvalidExceptionFilterException();
         }
         this.filters = filters;
     }
     invokeCustomFilters(exception, host) {
-        if ((0, shared_utils_1.isEmpty)(this.filters)) {
+        if (isEmptyArray(this.filters)) {
             return null;
         }
-        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
+        const filter = selectExceptionFilterMetadata(this.filters, exception);
         return filter ? filter.func(exception, host) : null;
     }
 }
-exports.ExternalExceptionsHandler = ExternalExceptionsHandler;

package/exceptions/index.d.ts

@@ -1 +1 @@
-export * from './base-exception-filter';
+export * from './base-exception-filter.js';

package/exceptions/index.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./base-exception-filter"), exports);
+export * from './base-exception-filter.js';

package/guards/constants.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORBIDDEN_MESSAGE = void 0;
-exports.FORBIDDEN_MESSAGE = 'Forbidden resource';
+export const FORBIDDEN_MESSAGE = 'Forbidden resource';

package/guards/guards-consumer.d.ts

@@ -1,7 +1,8 @@
-import { CanActivate } from '@nestjs/common';
-import { ContextType, Controller } from '@nestjs/common/interfaces';
+import type { CanActivate } from '@nestjs/common';
 import { Observable } from 'rxjs';
-import { ExecutionContextHost } from '../helpers/execution-context-host';
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+import type { ContextType } from '@nestjs/common';
+import { type Controller } from '@nestjs/common/internal';
 export declare class GuardsConsumer {
     tryActivate<TContext extends string = ContextType>(guards: CanActivate[], args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown, type?: TContext): Promise<boolean>;
     createContext(args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown): ExecutionContextHost;

package/guards/guards-consumer.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuardsConsumer = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const rxjs_1 = require("rxjs");
-const execution_context_host_1 = require("../helpers/execution-context-host");
-class GuardsConsumer {
+import { lastValueFrom, Observable } from 'rxjs';
+import { ExecutionContextHost } from '../helpers/execution-context-host.js';
+import { isEmptyArray } from '@nestjs/common/internal';
+export class GuardsConsumer {
     async tryActivate(guards, args, instance, callback, type) {
-        if (!guards || (0, shared_utils_1.isEmpty)(guards)) {
+        if (!guards || isEmptyArray(guards)) {
             return true;
         }
         const context = this.createContext(args, instance, callback);
@@ -27,13 +24,12 @@ class GuardsConsumer {
         return true;
     }
     createContext(args, instance, callback) {
-        return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
+        return new ExecutionContextHost(args, instance.constructor, callback);
     }
     async pickResult(result) {
-        if (result instanceof rxjs_1.Observable) {
-            return (0, rxjs_1.lastValueFrom)(result);
+        if (result instanceof Observable) {
+            return lastValueFrom(result);
         }
         return result;
     }
 }
-exports.GuardsConsumer = GuardsConsumer;

package/guards/guards-context-creator.d.ts

@@ -1,17 +1,18 @@
-import { CanActivate } from '@nestjs/common';
-import { Controller, Type } from '@nestjs/common/interfaces';
-import { ApplicationConfig } from '../application-config';
-import { ContextCreator } from '../helpers/context-creator';
-import { NestContainer } from '../injector/container';
-import { InstanceWrapper } from '../injector/instance-wrapper';
+import type { CanActivate } from '@nestjs/common';
+import { ApplicationConfig } from '../application-config.js';
+import { ContextCreator } from '../helpers/context-creator.js';
+import { NestContainer } from '../injector/container.js';
+import { InstanceWrapper } from '../injector/instance-wrapper.js';
+import { type Controller } from '@nestjs/common/internal';
+import type { Type } from '@nestjs/common';
 export declare class GuardsContextCreator extends ContextCreator {
     private readonly container;
     private readonly config?;
     private moduleContext;
     constructor(container: NestContainer, config?: ApplicationConfig | undefined);
-    create(instance: Controller, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate[];
-    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
-    getGuardInstance(metatype: Function | CanActivate, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate | null;
+    create(instance: Controller, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): CanActivate[];
+    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): R;
+    getGuardInstance(metatype: Function | CanActivate, contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): CanActivate | null;
     getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
-    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper.js").ContextId, inquirerId?: string): T;
 }

package/guards/guards-context-creator.js

@@ -1,32 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuardsContextCreator = 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 context_creator_1 = require("../helpers/context-creator");
-const constants_2 = require("../injector/constants");
-class GuardsContextCreator extends context_creator_1.ContextCreator {
+import { iterate } from 'iterare';
+import { ContextCreator } from '../helpers/context-creator.js';
+import { STATIC_CONTEXT } from '../injector/constants.js';
+import { GUARDS_METADATA, isEmpty, isFunction, } from '@nestjs/common/internal';
+export class GuardsContextCreator extends ContextCreator {
+    container;
+    config;
+    moduleContext;
     constructor(container, config) {
         super();
         this.container = container;
         this.config = config;
     }
-    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    create(instance, callback, module, contextId = STATIC_CONTEXT, inquirerId) {
         this.moduleContext = module;
-        return this.createContext(instance, callback, constants_1.GUARDS_METADATA, contextId, inquirerId);
+        return this.createContext(instance, callback, GUARDS_METADATA, contextId, inquirerId);
     }
-    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        if ((0, shared_utils_1.isEmpty)(metadata)) {
+    createConcreteContext(metadata, contextId = STATIC_CONTEXT, inquirerId) {
+        if (isEmpty(metadata)) {
             return [];
         }
-        return (0, iterare_1.iterate)(metadata)
+        return iterate(metadata)
             .filter((guard) => guard && (guard.name || guard.canActivate))
             .map(guard => this.getGuardInstance(guard, contextId, inquirerId))
-            .filter((guard) => !!guard && (0, shared_utils_1.isFunction)(guard.canActivate))
+            .filter((guard) => !!guard && isFunction(guard.canActivate))
             .toArray();
     }
-    getGuardInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    getGuardInstance(metatype, contextId = STATIC_CONTEXT, inquirerId) {
         const isObject = !!metatype.canActivate;
         if (isObject) {
             return metatype;
@@ -50,16 +49,16 @@ class GuardsContextCreator extends context_creator_1.ContextCreator {
         const injectables = moduleRef.injectables;
         return injectables.get(metatype);
     }
-    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+    getGlobalMetadata(contextId = STATIC_CONTEXT, inquirerId) {
         if (!this.config) {
             return [];
         }
         const globalGuards = this.config.getGlobalGuards();
-        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+        if (contextId === STATIC_CONTEXT && !inquirerId) {
             return globalGuards;
         }
         const scopedGuardWrappers = this.config.getGlobalRequestGuards();
-        const scopedGuards = (0, iterare_1.iterate)(scopedGuardWrappers)
+        const scopedGuards = iterate(scopedGuardWrappers)
             .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
             .filter(host => !!host)
             .map(host => host.instance)
@@ -67,4 +66,3 @@ class GuardsContextCreator extends context_creator_1.ContextCreator {
         return globalGuards.concat(scopedGuards);
     }
 }
-exports.GuardsContextCreator = GuardsContextCreator;

package/guards/index.d.ts

@@ -1,3 +1,3 @@
-export * from './constants';
-export * from './guards-consumer';
-export * from './guards-context-creator';
+export * from './constants.js';
+export * from './guards-consumer.js';
+export * from './guards-context-creator.js';

package/guards/index.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./constants"), exports);
-tslib_1.__exportStar(require("./guards-consumer"), exports);
-tslib_1.__exportStar(require("./guards-context-creator"), exports);
+export * from './constants.js';
+export * from './guards-consumer.js';
+export * from './guards-context-creator.js';

package/helpers/barrier.js

@@ -1,10 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Barrier = void 0;
 /**
  * A simple barrier to synchronize flow of multiple async operations.
  */
-class Barrier {
+export class Barrier {
+    currentCount;
+    targetCount;
+    promise;
+    resolve;
     constructor(targetCount) {
         this.currentCount = 0;
         this.targetCount = targetCount;
@@ -43,4 +44,3 @@ class Barrier {
         return this.wait();
     }
 }
-exports.Barrier = Barrier;

package/helpers/context-creator.d.ts

@@ -1,5 +1,5 @@
-import { Controller } from '@nestjs/common/interfaces';
-import { ContextId, InstanceWrapper } from '../injector/instance-wrapper';
+import { ContextId, InstanceWrapper } from '../injector/instance-wrapper.js';
+import type { Controller } from '@nestjs/common/internal';
 export declare abstract class ContextCreator {
     abstract createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
     getGlobalMetadata?<T extends any[]>(contextId?: ContextId, inquirerId?: string): T;

package/helpers/context-creator.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextCreator = void 0;
-const constants_1 = require("../injector/constants");
-class ContextCreator {
-    createContext(instance, callback, metadataKey, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+import { STATIC_CONTEXT } from '../injector/constants.js';
+export class ContextCreator {
+    createContext(instance, callback, metadataKey, contextId = STATIC_CONTEXT, inquirerId) {
         const globalMetadata = this.getGlobalMetadata &&
             this.getGlobalMetadata(contextId, inquirerId);
         const classMetadata = this.reflectClassMetadata(instance, metadataKey);
@@ -30,4 +27,3 @@ class ContextCreator {
             : contextId;
     }
 }
-exports.ContextCreator = ContextCreator;

package/helpers/context-id-factory.d.ts

@@ -1,4 +1,4 @@
-import { ContextId, HostComponentInfo } from '../injector/instance-wrapper';
+import { ContextId, HostComponentInfo } from '../injector/instance-wrapper.js';
 export declare function createContextId(): ContextId;
 export type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;
 export interface ContextIdResolver {

package/helpers/context-id-factory.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextIdFactory = void 0;
-exports.createContextId = createContextId;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const request_constants_1 = require("../router/request/request-constants");
-function createContextId() {
+import { REQUEST_CONTEXT_ID } from '../router/request/request-constants.js';
+import { isObject } from '@nestjs/common/internal';
+export function createContextId() {
     /**
      * We are generating random identifier to track asynchronous
      * execution context. An identifier does not have to be neither unique
@@ -15,7 +11,8 @@ function createContextId() {
      */
     return { id: Math.random() };
 }
-class ContextIdFactory {
+export class ContextIdFactory {
+    static strategy;
     /**
      * Generates a context identifier based on the request object.
      */
@@ -30,12 +27,12 @@ class ContextIdFactory {
         if (!request) {
             return ContextIdFactory.create();
         }
-        if (request[request_constants_1.REQUEST_CONTEXT_ID]) {
-            return request[request_constants_1.REQUEST_CONTEXT_ID];
+        if (request[REQUEST_CONTEXT_ID]) {
+            return request[REQUEST_CONTEXT_ID];
         }
         for (const key of propsToInspect) {
-            if (request[key]?.[request_constants_1.REQUEST_CONTEXT_ID]) {
-                return request[key][request_constants_1.REQUEST_CONTEXT_ID];
+            if (request[key]?.[REQUEST_CONTEXT_ID]) {
+                return request[key][REQUEST_CONTEXT_ID];
             }
         }
         if (!this.strategy) {
@@ -61,7 +58,6 @@ class ContextIdFactory {
         this.strategy = strategy;
     }
     static isContextIdResolverWithPayload(resolverOrResolverFn) {
-        return (0, shared_utils_1.isObject)(resolverOrResolverFn);
+        return isObject(resolverOrResolverFn);
     }
 }
-exports.ContextIdFactory = ContextIdFactory;

package/helpers/context-utils.d.ts

@@ -1,12 +1,15 @@
-import { ParamData } from '@nestjs/common';
-import { ContextType, Controller, PipeTransform } from '@nestjs/common/interfaces';
-import { ExecutionContextHost } from './execution-context-host';
+import type { ParamData } from '@nestjs/common';
+import { ExecutionContextHost } from './execution-context-host.js';
+import { type Controller } from '@nestjs/common/internal';
+import type { ContextType, PipeTransform } from '@nestjs/common';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 export interface ParamProperties<T = any, IExtractor extends Function = any> {
     index: number;
     type: T | string;
     data: ParamData;
     pipes: PipeTransform[];
     extractValue: IExtractor;
+    schema?: StandardSchemaV1;
 }
 export declare class ContextUtils {
     mapParamType(key: string): string;

package/helpers/context-utils.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextUtils = void 0;
-const constants_1 = require("@nestjs/common/constants");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const execution_context_host_1 = require("./execution-context-host");
-class ContextUtils {
+import { ExecutionContextHost } from './execution-context-host.js';
+import { PARAMTYPES_METADATA, RESPONSE_PASSTHROUGH_METADATA, isFunction, } from '@nestjs/common/internal';
+export class ContextUtils {
     mapParamType(key) {
         const keyPair = key.split(':');
         return keyPair[0];
     }
     reflectCallbackParamtypes(instance, methodName) {
-        return Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, methodName);
+        return Reflect.getMetadata(PARAMTYPES_METADATA, instance, methodName);
     }
     reflectCallbackMetadata(instance, methodName, metadataKey) {
         return Reflect.getMetadata(metadataKey, instance.constructor, methodName);
     }
     reflectPassthrough(instance, methodName) {
-        return Reflect.getMetadata(constants_1.RESPONSE_PASSTHROUGH_METADATA, instance.constructor, methodName);
+        return Reflect.getMetadata(RESPONSE_PASSTHROUGH_METADATA, instance.constructor, methodName);
     }
     getArgumentsLength(keys, metadata) {
         return keys.length
@@ -39,17 +35,16 @@ class ContextUtils {
         }));
     }
     getCustomFactory(factory, data, contextFactory) {
-        return (0, shared_utils_1.isFunction)(factory)
+        return isFunction(factory)
             ? (...args) => factory(data, contextFactory(args))
             : () => null;
     }
     getContextFactory(contextType, instance, callback) {
         const type = instance && instance.constructor;
         return (args) => {
-            const ctx = new execution_context_host_1.ExecutionContextHost(args, type, callback);
+            const ctx = new ExecutionContextHost(args, type, callback);
             ctx.setType(contextType);
             return ctx;
         };
     }
 }
-exports.ContextUtils = ContextUtils;

package/helpers/execution-context-host.d.ts

@@ -1,6 +1,6 @@
-import { ExecutionContext } from '@nestjs/common';
-import { Type } from '@nestjs/common/interfaces';
-import { ContextType, HttpArgumentsHost, RpcArgumentsHost, WsArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+import type { ExecutionContext } from '@nestjs/common';
+import type { Type, ContextType } from '@nestjs/common';
+import type { HttpArgumentsHost, RpcArgumentsHost, WsArgumentsHost } from '@nestjs/common/internal';
 export declare class ExecutionContextHost implements ExecutionContext {
     private readonly args;
     private readonly constructorRef;

package/helpers/execution-context-host.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionContextHost = void 0;
-class ExecutionContextHost {
+export class ExecutionContextHost {
+    args;
+    constructorRef;
+    handler;
+    contextType = 'http';
     constructor(args, constructorRef = null, handler = null) {
         this.args = args;
         this.constructorRef = constructorRef;
         this.handler = handler;
-        this.contextType = 'http';
     }
     setType(type) {
         type && (this.contextType = type);
@@ -47,4 +47,3 @@ class ExecutionContextHost {
         });
     }
 }
-exports.ExecutionContextHost = ExecutionContextHost;