@nestjs/core 12.0.0-alpha.2 → 12.0.0-alpha.4

package/Readme.md

@@ -29,7 +29,7 @@ Nest is a framework for building efficient, scalable <a href="https://nodejs.org
 
 ## Philosophy
 
-<p>In recent years, thanks to Node.js, JavaScript has become the “lingua franca” of the web for both front and backend applications, giving rise to awesome projects like <a href="https://angular.io/" target="_blank">Angular</a>, <a href="https://github.com/facebook/react" target="_blank">React</a>, and <a href="https://github.com/vuejs/vue" target="_blank">Vue</a>, which improve developer productivity and enable the construction of fast, testable, and extensible frontend applications. However, on the server-side, while there are a lot of superb libraries, helpers, and tools for Node, none of them effectively solve the main problem - the architecture.</p>
+<p>In recent years, thanks to Node.js, JavaScript has become the “lingua franca” of the web for both front-end and back-end applications, giving rise to awesome projects like <a href="https://angular.dev/" target="_blank">Angular</a>, <a href="https://react.dev/" target="_blank">React</a>, and <a href="https://vuejs.org/" target="_blank">Vue</a>, which improve developer productivity and enable the construction of fast, testable, and extensible frontend applications. However, on the server-side, while there are a lot of superb libraries, helpers, and tools for Node, none of them effectively solve the main problem - the architecture.</p>
 <p>Nest aims to provide an application architecture out of the box which allows for effortless creation of highly testable, scalable, and loosely coupled and easily maintainable applications. The architecture is heavily inspired by Angular.</p>
 
 ## Getting started
@@ -95,6 +95,7 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <td align="center" valign="middle"><a href="https://crawljobs.com" target="_blank"><img src="https://nestjs.com/img/logos/crawljobs-logo.svg" width="130" valign="middle" /></a></td>
 </tr><tr>
 <td align="center" valign="middle"><a href="https://pandektes.com" target="_blank"><img src="https://nestjs.com/img/logos/pandektes-logo.png" width="65" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://www.fintechcrafts.com/" target="_blank"><img src="https://nestjs.com/img/logos/fintechcrafts-logo.svg" width="65" valign="middle" /></a></td>
 </tr>
 </table>
 

package/errors/messages.js

@@ -96,9 +96,12 @@ For more common dependency resolution issues, see: https://docs.nestjs.com/faq/c
     }
     const dependenciesName = (dependencies || []).map(dependencyName => getDependencyName(dependencyName, '+', false));
     dependenciesName[index] = '?';
+    const tokenFragment = !isImportTypeIssue && name !== undefined ? ` ${dependencyName}` : '';
+    const contextLabel = isImportTypeIssue ? 'current' : moduleName;
     message += ` (`;
     message += dependenciesName.join(', ');
-    message += `). Please make sure that the argument ${isImportTypeIssue ? 'dependency' : dependencyName} at index [${index}] is available in the ${isImportTypeIssue ? 'current' : moduleName} context.`;
+    message += `). Please make sure that the argument${tokenFragment} at index [${index}]`;
+    message += ` is available in the ${contextLabel} module.`;
     message += potentialSolutions;
     return message;
 };

package/index.d.ts

@@ -11,7 +11,7 @@ export * from './metadata-scanner.js';
 export * from './middleware/index.js';
 export * from './nest-application.js';
 export * from './nest-application-context.js';
-export { NestFactory } from './nest-factory.js';
+export { IEntryNestModule, NestFactory } from './nest-factory.js';
 export * from './repl/index.js';
 export * from './router/index.js';
 export * from './services/index.js';

package/injector/injector.d.ts

@@ -40,6 +40,11 @@ export interface InjectorDependencyContext {
      */
     dependencies?: InjectorDependency[];
 }
+interface ResolutionContext {
+    contextId: ContextId;
+    inquirer?: InstanceWrapper;
+    effectiveInquirerId?: string;
+}
 export declare class Injector {
     private readonly options?;
     private logger;
@@ -49,40 +54,48 @@ export declare class Injector {
          * Whether to enable preview mode.
          */
         preview: boolean;
+        /**
+         * Whether to enable deterministic graph snapshot generation.
+         */
+        snapshot?: boolean;
         /**
          * Function to decorate a freshly created instance.
          */
         instanceDecorator?: (target: unknown) => unknown;
     } | undefined);
     loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
-    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, resolutionContext?: ResolutionContext): Promise<void>;
     loadMiddleware(wrapper: InstanceWrapper, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     loadController(wrapper: InstanceWrapper<Controller>, moduleRef: Module, contextId?: ContextId): Promise<void>;
     loadInjectable<T = any>(wrapper: InstanceWrapper<T>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
-    loadProvider(wrapper: InstanceWrapper<Injectable>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadProvider(wrapper: InstanceWrapper<Injectable>, moduleRef: Module, resolutionContext?: ResolutionContext): Promise<void>;
     applySettlementSignal<T>(instancePerContext: InstancePerContext<T>, host: InstanceWrapper<T>): SettlementSignal;
-    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[] | undefined, callback: (args: unknown[], depth?: number) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[] | undefined, callback: (args: unknown[], depth?: number) => void | Promise<void>, resolutionContext?: ResolutionContext, parentInquirer?: InstanceWrapper): Promise<void>;
     getClassDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
     getFactoryProviderDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
     reflectConstructorParams<T>(type: Type<T>): any[];
     reflectOptionalParams<T>(type: Type<T>): any[];
     reflectSelfParams<T>(type: Type<T>): any[];
-    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol, dependencyContext: InjectorDependencyContext, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
+    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol, dependencyContext: InjectorDependencyContext, moduleRef: Module, resolutionContext?: ResolutionContext, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
     resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | ForwardReference): any;
-    resolveComponentWrapper<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
-    resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
-    lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
-    lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<any>;
-    lookupComponentInImports(moduleRef: Module, name: InjectionToken, wrapper: InstanceWrapper, moduleRegistry?: Set<string>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number, isTraversing?: boolean): Promise<any>;
-    resolveProperties<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject?: InjectorDependency[], contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    resolveComponentWrapper<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, resolutionContext?: ResolutionContext, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, resolutionContext?: ResolutionContext): Promise<InstanceWrapper>;
+    lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, resolutionContext?: ResolutionContext, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
+    lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module, wrapper: InstanceWrapper<T>, resolutionContext?: ResolutionContext, keyOrIndex?: symbol | string | number): Promise<any>;
+    lookupComponentInImports(moduleRef: Module, name: InjectionToken, wrapper: InstanceWrapper, moduleRegistry?: Set<string>, resolutionContext?: ResolutionContext, keyOrIndex?: symbol | string | number, isTraversing?: boolean): Promise<any>;
+    resolveProperties<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject?: InjectorDependency[], resolutionContext?: ResolutionContext, parentInquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
     reflectProperties<T>(type: Type<T>): PropertyDependency[];
     applyProperties<T = any>(instance: T, properties: PropertyDependency[]): void;
-    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper, targetMetatype: InstanceWrapper, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<T>;
+    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper, targetMetatype: InstanceWrapper, resolutionContext?: ResolutionContext): Promise<T>;
     loadPerContext<T = any>(instance: T, moduleRef: Module, collection: Map<InjectionToken, InstanceWrapper>, ctx: ContextId, wrapper?: InstanceWrapper): Promise<T>;
     loadEnhancersPerContext(wrapper: InstanceWrapper, ctx: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     loadCtorMetadata(metadata: InstanceWrapper<any>[], contextId: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<any[]>;
     loadPropertiesMetadata(metadata: PropertyMetadata[], contextId: ContextId, inquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
     private getInquirerId;
+    private createResolutionContext;
+    private getContextInquirerId;
+    private isInContext;
+    private shouldSkipProviderLoading;
     /**
      * For nested TRANSIENT dependencies (TRANSIENT -> TRANSIENT) in non-static contexts,
      * returns parentInquirer to ensure each parent TRANSIENT gets its own instance.
@@ -91,6 +104,9 @@ export declare class Injector {
      * For non-TRANSIENT -> TRANSIENT, returns inquirer (current wrapper being created).
      */
     private getEffectiveInquirer;
+    private getEffectiveInquirerId;
+    private getStaticTransientResolutionContext;
+    private getEffectiveResolutionContext;
     private resolveScopedComponentHost;
     private isInquirerRequest;
     private isInquirer;
@@ -103,3 +119,4 @@ export declare class Injector {
     private getContextId;
     private getNowTimestamp;
 }
+export {};

package/injector/injector.js

@@ -1,4 +1,4 @@
-import { Logger, } from '@nestjs/common';
+import { Logger, Scope, } from '@nestjs/common';
 import { OPTIONAL_DEPS_METADATA, OPTIONAL_PROPERTY_DEPS_METADATA, PARAMTYPES_METADATA, PROPERTY_DEPS_METADATA, SELF_DECLARED_DEPS_METADATA, clc, isFunction, isNil, isObject, isString, isSymbol, isUndefined, } from '@nestjs/common/internal';
 import { iterate } from 'iterare';
 import { performance } from 'perf_hooks';
@@ -35,12 +35,13 @@ export class Injector {
             collection.set(token, wrapper);
         }
     }
-    async loadInstance(wrapper, collection, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
-        const inquirerId = this.getInquirerId(inquirer);
-        const instanceHost = wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
+    async loadInstance(wrapper, collection, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }) {
+        const inquirerId = this.getContextInquirerId(resolutionContext);
+        const instanceHost = wrapper.getInstanceByContextId(this.getContextId(resolutionContext.contextId, wrapper), inquirerId);
         if (instanceHost.isPending) {
             const settlementSignal = wrapper.settlementSignal;
-            if (inquirer && settlementSignal?.isCycle(inquirer.id)) {
+            if (resolutionContext.inquirer &&
+                settlementSignal?.isCycle(resolutionContext.inquirer.id)) {
                 throw new CircularDependencyException(`"${wrapper.name}"`);
             }
             return instanceHost.donePromise.then((err) => {
@@ -61,18 +62,19 @@ export class Injector {
         }
         try {
             const t0 = this.getNowTimestamp();
+            const localResolutionContext = this.createResolutionContext(resolutionContext.contextId, wrapper, inquirerId);
             const callback = async (instances, depth = 0) => {
-                const properties = await this.resolveProperties(wrapper, moduleRef, inject, contextId, wrapper, inquirer);
-                const instance = await this.instantiateClass(instances, wrapper, targetWrapper, contextId, inquirer);
+                const properties = await this.resolveProperties(wrapper, moduleRef, inject, localResolutionContext, resolutionContext.inquirer);
+                const instance = await this.instantiateClass(instances, wrapper, targetWrapper, wrapper.isTransient ? localResolutionContext : resolutionContext);
                 this.applyProperties(instance, properties);
                 wrapper.hierarchyLevel = depth + 1;
                 wrapper.initTime = this.getNowTimestamp() - t0;
                 settlementSignal.complete();
             };
-            await this.resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId, wrapper, inquirer);
+            await this.resolveConstructorParams(wrapper, moduleRef, inject, callback, localResolutionContext, resolutionContext.inquirer);
         }
         catch (err) {
-            wrapper.removeInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
+            wrapper.removeInstanceByContextId(this.getContextId(resolutionContext.contextId, wrapper), inquirerId);
             settlementSignal.error(err);
             throw err;
         }
@@ -84,21 +86,24 @@ export class Injector {
             return;
         }
         targetWrapper.instance = Object.create(metatype.prototype);
-        await this.loadInstance(wrapper, collection, moduleRef, contextId, inquirer || wrapper);
+        await this.loadInstance(wrapper, collection, moduleRef, this.createResolutionContext(contextId, inquirer || wrapper));
     }
     async loadController(wrapper, moduleRef, contextId = STATIC_CONTEXT) {
         const controllers = moduleRef.controllers;
-        await this.loadInstance(wrapper, controllers, moduleRef, contextId, wrapper);
+        await this.loadInstance(wrapper, controllers, moduleRef, this.createResolutionContext(contextId, wrapper));
         await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
     }
     async loadInjectable(wrapper, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
         const injectables = moduleRef.injectables;
-        await this.loadInstance(wrapper, injectables, moduleRef, contextId, inquirer);
+        await this.loadInstance(wrapper, injectables, moduleRef, this.createResolutionContext(contextId, inquirer));
     }
-    async loadProvider(wrapper, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
+    async loadProvider(wrapper, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }) {
+        if (this.shouldSkipProviderLoading(wrapper, resolutionContext)) {
+            return;
+        }
         const providers = moduleRef.providers;
-        await this.loadInstance(wrapper, providers, moduleRef, contextId, inquirer);
-        await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
+        await this.loadInstance(wrapper, providers, moduleRef, resolutionContext);
+        await this.loadEnhancersPerContext(wrapper, resolutionContext.contextId, wrapper);
     }
     applySettlementSignal(instancePerContext, host) {
         const settlementSignal = new SettlementSignal();
@@ -107,10 +112,10 @@ export class Injector {
         host.settlementSignal = settlementSignal;
         return settlementSignal;
     }
-    async resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
+    async resolveConstructorParams(wrapper, moduleRef, inject, callback, resolutionContext = { contextId: STATIC_CONTEXT }, parentInquirer) {
         const metadata = wrapper.getCtorMetadata();
-        if (metadata && contextId !== STATIC_CONTEXT) {
-            const deps = await this.loadCtorMetadata(metadata, contextId, inquirer, parentInquirer);
+        if (metadata && resolutionContext.contextId !== STATIC_CONTEXT) {
+            const deps = await this.loadCtorMetadata(metadata, resolutionContext.contextId, resolutionContext.inquirer, parentInquirer);
             return callback(deps);
         }
         const isFactoryProvider = !isNil(inject);
@@ -129,25 +134,26 @@ export class Injector {
                     paramBarrier.signal();
                     return parentInquirer && parentInquirer.instance;
                 }
-                if (inquirer?.isTransient && parentInquirer) {
+                if (resolutionContext.inquirer?.isTransient && parentInquirer) {
                     // When `inquirer` is transient too, inherit the parent inquirer
                     // This is required to ensure that transient providers are only resolved
                     // when requested
-                    inquirer.attachRootInquirer(parentInquirer);
+                    resolutionContext.inquirer.attachRootInquirer(parentInquirer);
                 }
-                const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, moduleRef, contextId, inquirer, index);
+                const nestedResolutionContext = this.getStaticTransientResolutionContext(resolutionContext, parentInquirer);
+                const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, moduleRef, nestedResolutionContext, index);
                 /*
                  * Ensure that all instance wrappers are resolved at this point before we continue.
                  * Otherwise the staticity of `wrapper`'s dependency tree may be evaluated incorrectly
                  * and result in undefined / null injection.
                  */
                 await paramBarrier.signalAndWait();
-                const effectiveInquirer = this.getEffectiveInquirer(paramWrapper, inquirer, parentInquirer, contextId);
-                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, effectiveInquirer);
+                const effectiveResolutionContext = this.getEffectiveResolutionContext(paramWrapper, resolutionContext, parentInquirer);
+                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, effectiveResolutionContext);
                 if (paramWrapperWithInstance.hierarchyLevel > depth) {
                     depth = paramWrapperWithInstance.hierarchyLevel;
                 }
-                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), this.getInquirerId(effectiveInquirer));
+                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(effectiveResolutionContext.contextId, paramWrapperWithInstance), effectiveResolutionContext.effectiveInquirerId);
                 if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
                     isResolved = false;
                 }
@@ -211,7 +217,7 @@ export class Injector {
         ];
         const selfParams = this.reflectSelfParams(type);
         selfParams.forEach(({ index, param }) => (paramtypes[index] = param));
-        return paramtypes;
+        return Array.from(paramtypes);
     }
     reflectOptionalParams(type) {
         return Reflect.getOwnMetadata(OPTIONAL_DEPS_METADATA, type) || [];
@@ -219,13 +225,13 @@ export class Injector {
     reflectSelfParams(type) {
         return Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, type) || [];
     }
-    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
         if (isUndefined(param)) {
             this.logger.log('Nest encountered an undefined dependency. This may be due to a circular import or a missing dependency declaration.');
             throw new UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
         }
         const token = this.resolveParamToken(wrapper, param);
-        return this.resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
+        return this.resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, resolutionContext, keyOrIndex);
     }
     resolveParamToken(wrapper, param) {
         if (typeof param === 'object' && 'forwardRef' in param) {
@@ -234,22 +240,22 @@ export class Injector {
         }
         return param;
     }
-    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
-        this.printResolvingDependenciesLog(token, inquirer);
+    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
+        this.printResolvingDependenciesLog(token, resolutionContext.inquirer);
         this.printLookingForProviderLog(token, moduleRef);
         const providers = moduleRef.providers;
-        return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
+        return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, resolutionContext, keyOrIndex);
     }
-    async resolveComponentHost(moduleRef, instanceWrapper, contextId = STATIC_CONTEXT, inquirer) {
-        const inquirerId = this.getInquirerId(inquirer);
-        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+    async resolveComponentHost(moduleRef, instanceWrapper, resolutionContext = { contextId: STATIC_CONTEXT }) {
+        const inquirerId = this.getContextInquirerId(resolutionContext);
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(resolutionContext.contextId, instanceWrapper), inquirerId);
         if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
-            inquirer?.settlementSignal?.insertRef(instanceWrapper.id);
-            await this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, contextId, inquirer);
+            resolutionContext.inquirer?.settlementSignal?.insertRef(instanceWrapper.id);
+            await this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, resolutionContext);
         }
         else if (!instanceHost.isResolved &&
             instanceWrapper.forwardRef &&
-            (contextId !== STATIC_CONTEXT || !!inquirerId)) {
+            (resolutionContext.contextId !== STATIC_CONTEXT || !!inquirerId)) {
             /**
              * When circular dependency has been detected between
              * either request/transient providers, we have to asynchronously
@@ -259,19 +265,19 @@ export class Injector {
              */
             instanceHost.donePromise &&
                 void instanceHost.donePromise
-                    .then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer))
+                    .then(() => this.loadProvider(instanceWrapper, moduleRef, resolutionContext))
                     .catch(err => {
                     instanceWrapper.settlementSignal?.error(err);
                 });
         }
         if (instanceWrapper.async) {
-            const host = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+            const host = instanceWrapper.getInstanceByContextId(this.getContextId(resolutionContext.contextId, instanceWrapper), inquirerId);
             host.instance = await host.instance;
-            instanceWrapper.setInstanceByContextId(contextId, host, inquirerId);
+            instanceWrapper.setInstanceByContextId(resolutionContext.contextId, host, inquirerId);
         }
         return instanceWrapper;
     }
-    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
         const token = wrapper.token || wrapper.name;
         const { name } = dependencyContext;
         if (wrapper && token === name) {
@@ -283,16 +289,16 @@ export class Injector {
             this.addDependencyMetadata(keyOrIndex, wrapper, instanceWrapper);
             return instanceWrapper;
         }
-        return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId, inquirer, keyOrIndex);
+        return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, resolutionContext, keyOrIndex);
     }
-    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
-        const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, new Set(), contextId, inquirer, keyOrIndex);
+    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
+        const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, new Set(), resolutionContext, keyOrIndex);
         if (isNil(instanceWrapper)) {
             throw new UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
         }
         return instanceWrapper;
     }
-    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = new Set(), contextId = STATIC_CONTEXT, inquirer, keyOrIndex, isTraversing) {
+    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = new Set(), resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex, isTraversing) {
         let instanceWrapperRef = null;
         const imports = moduleRef.imports || new Set();
         const identity = (item) => item;
@@ -309,7 +315,7 @@ export class Injector {
             moduleRegistry.add(relatedModule.id);
             const { providers, exports } = relatedModule;
             if (!exports.has(name) || !providers.has(name)) {
-                const instanceRef = await this.lookupComponentInImports(relatedModule, name, wrapper, moduleRegistry, contextId, inquirer, keyOrIndex, true);
+                const instanceRef = await this.lookupComponentInImports(relatedModule, name, wrapper, moduleRegistry, resolutionContext, keyOrIndex, true);
                 if (instanceRef) {
                     this.addDependencyMetadata(keyOrIndex, wrapper, instanceRef);
                     return instanceRef;
@@ -319,8 +325,8 @@ export class Injector {
             this.printFoundInModuleLog(name, relatedModule);
             instanceWrapperRef = providers.get(name);
             this.addDependencyMetadata(keyOrIndex, wrapper, instanceWrapperRef);
-            const inquirerId = this.getInquirerId(inquirer);
-            const instanceHost = instanceWrapperRef.getInstanceByContextId(this.getContextId(contextId, instanceWrapperRef), inquirerId);
+            const inquirerId = this.getContextInquirerId(resolutionContext);
+            const instanceHost = instanceWrapperRef.getInstanceByContextId(this.getContextId(resolutionContext.contextId, instanceWrapperRef), inquirerId);
             if (!instanceHost.isResolved && !instanceWrapperRef.forwardRef) {
                 /*
                  * Provider will be loaded shortly in resolveComponentHost() once we pass the current
@@ -332,13 +338,13 @@ export class Injector {
         }
         return instanceWrapperRef;
     }
-    async resolveProperties(wrapper, moduleRef, inject, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
+    async resolveProperties(wrapper, moduleRef, inject, resolutionContext = { contextId: STATIC_CONTEXT }, parentInquirer) {
         if (!isNil(inject)) {
             return [];
         }
         const metadata = wrapper.getPropertiesMetadata();
-        if (metadata && contextId !== STATIC_CONTEXT) {
-            return this.loadPropertiesMetadata(metadata, contextId, inquirer);
+        if (metadata && resolutionContext.contextId !== STATIC_CONTEXT) {
+            return this.loadPropertiesMetadata(metadata, resolutionContext.contextId, resolutionContext.inquirer);
         }
         const properties = this.reflectProperties(wrapper.metatype);
         const propertyBarrier = new Barrier(properties.length);
@@ -355,19 +361,20 @@ export class Injector {
                     propertyBarrier.signal();
                     return parentInquirer && parentInquirer.instance;
                 }
-                const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, moduleRef, contextId, inquirer, item.key);
+                const nestedResolutionContext = this.getStaticTransientResolutionContext(resolutionContext, parentInquirer);
+                const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, moduleRef, nestedResolutionContext, item.key);
                 /*
                  * Ensure that all instance wrappers are resolved at this point before we continue.
                  * Otherwise the staticity of `wrapper`'s dependency tree may be evaluated incorrectly
                  * and result in undefined / null injection.
                  */
                 await propertyBarrier.signalAndWait();
-                const effectivePropertyInquirer = this.getEffectiveInquirer(paramWrapper, inquirer, parentInquirer, contextId);
-                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, effectivePropertyInquirer);
+                const effectivePropertyResolutionContext = this.getEffectiveResolutionContext(paramWrapper, resolutionContext, parentInquirer);
+                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, effectivePropertyResolutionContext);
                 if (!paramWrapperWithInstance) {
                     return undefined;
                 }
-                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), this.getInquirerId(effectivePropertyInquirer));
+                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(effectivePropertyResolutionContext.contextId, paramWrapperWithInstance), effectivePropertyResolutionContext.effectiveInquirerId);
                 return instanceHost.instance;
             }
             catch (err) {
@@ -405,14 +412,11 @@ export class Injector {
             .filter(item => !isNil(item.instance))
             .forEach(item => (instance[item.key] = item.instance));
     }
-    async instantiateClass(instances, wrapper, targetMetatype, contextId = STATIC_CONTEXT, inquirer) {
+    async instantiateClass(instances, wrapper, targetMetatype, resolutionContext = { contextId: STATIC_CONTEXT }) {
         const { metatype, inject } = wrapper;
-        const inquirerId = this.getInquirerId(inquirer);
-        const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(contextId, targetMetatype), inquirerId);
-        const isInContext = wrapper.isStatic(contextId, inquirer) ||
-            wrapper.isInRequestScope(contextId, inquirer) ||
-            wrapper.isLazyTransient(contextId, inquirer) ||
-            wrapper.isExplicitlyRequested(contextId, inquirer);
+        const inquirerId = this.getContextInquirerId(resolutionContext);
+        const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(resolutionContext.contextId, targetMetatype), inquirerId);
+        const isInContext = this.isInContext(wrapper, resolutionContext);
         if (this.options?.preview && !wrapper.host?.initOnPreview) {
             instanceHost.isResolved = true;
             return instanceHost.instance;
@@ -438,16 +442,22 @@ export class Injector {
             const injectionToken = instance.constructor;
             wrapper = collection.get(injectionToken);
         }
-        await this.loadInstance(wrapper, collection, moduleRef, ctx, wrapper);
+        else {
+            wrapper = collection.get(wrapper.token) ?? wrapper;
+        }
+        await this.loadInstance(wrapper, collection, moduleRef, this.createResolutionContext(ctx, wrapper));
         await this.loadEnhancersPerContext(wrapper, ctx, wrapper);
         const host = wrapper.getInstanceByContextId(this.getContextId(ctx, wrapper), wrapper.id);
         return host && host.instance;
     }
     async loadEnhancersPerContext(wrapper, ctx, inquirer) {
+        if (ctx === STATIC_CONTEXT) {
+            return;
+        }
         const enhancers = wrapper.getEnhancersMetadata() || [];
         const loadEnhancer = (item) => {
             const hostModule = item.host;
-            return this.loadInstance(item, hostModule.injectables, hostModule, ctx, inquirer);
+            return this.loadInstance(item, hostModule.injectables, hostModule, this.createResolutionContext(ctx, inquirer));
         };
         await Promise.all(enhancers.map(loadEnhancer));
     }
@@ -455,14 +465,14 @@ export class Injector {
         const hosts = await Promise.all(metadata.map(async (item) => this.resolveScopedComponentHost(item, contextId, inquirer, parentInquirer)));
         return hosts.map((item, index) => {
             const dependency = metadata[index];
-            const effectiveInquirer = this.getEffectiveInquirer(dependency, inquirer, parentInquirer, contextId);
-            return item?.getInstanceByContextId(this.getContextId(contextId, item), this.getInquirerId(effectiveInquirer)).instance;
+            const effectiveInquirerId = this.getEffectiveInquirerId(dependency, this.createResolutionContext(contextId, inquirer), parentInquirer);
+            return item?.getInstanceByContextId(this.getContextId(contextId, item), effectiveInquirerId).instance;
         });
     }
     async loadPropertiesMetadata(metadata, contextId, inquirer) {
         const dependenciesHosts = await Promise.all(metadata.map(async ({ wrapper: item, key }) => ({
             key,
-            host: await this.resolveComponentHost(item.host, item, contextId, inquirer),
+            host: await this.resolveComponentHost(item.host, item, this.createResolutionContext(contextId, inquirer)),
         })));
         const inquirerId = this.getInquirerId(inquirer);
         return dependenciesHosts.map(({ key, host }) => ({
@@ -474,6 +484,34 @@ export class Injector {
     getInquirerId(inquirer) {
         return inquirer ? inquirer.id : undefined;
     }
+    createResolutionContext(contextId, inquirer, effectiveInquirerId) {
+        return {
+            contextId,
+            inquirer,
+            effectiveInquirerId,
+        };
+    }
+    getContextInquirerId({ inquirer, effectiveInquirerId, }) {
+        return effectiveInquirerId ?? this.getInquirerId(inquirer);
+    }
+    isInContext(wrapper, resolutionContext) {
+        return (wrapper.isStatic(resolutionContext.contextId, resolutionContext.inquirer) ||
+            wrapper.isInRequestScope(resolutionContext.contextId, resolutionContext.inquirer) ||
+            wrapper.isLazyTransient(resolutionContext.contextId, resolutionContext.inquirer) ||
+            wrapper.isExplicitlyRequested(resolutionContext.contextId, resolutionContext.inquirer));
+    }
+    shouldSkipProviderLoading(wrapper, resolutionContext) {
+        const isSnapshotGraphCompilation = !!this.options?.snapshot;
+        const isStaticContext = resolutionContext.contextId === STATIC_CONTEXT;
+        const hasNoInquirer = !resolutionContext.inquirer;
+        const isTopLevelStaticTransientOrRequestProvider = hasNoInquirer && (wrapper.isTransient || wrapper.scope === Scope.REQUEST);
+        const isStaticInquirerOutsideResolutionContext = !!resolutionContext.inquirer &&
+            !this.isInContext(resolutionContext.inquirer, this.createResolutionContext(resolutionContext.contextId, resolutionContext.inquirer));
+        const shouldSkipForStaticBootstrap = isStaticContext &&
+            (isTopLevelStaticTransientOrRequestProvider ||
+                isStaticInquirerOutsideResolutionContext);
+        return !isSnapshotGraphCompilation && shouldSkipForStaticBootstrap;
+    }
     /**
      * For nested TRANSIENT dependencies (TRANSIENT -> TRANSIENT) in non-static contexts,
      * returns parentInquirer to ensure each parent TRANSIENT gets its own instance.
@@ -481,18 +519,45 @@ export class Injector {
      * can be used by multiple parents, causing nested TRANSIENTs to be shared incorrectly.
      * For non-TRANSIENT -> TRANSIENT, returns inquirer (current wrapper being created).
      */
-    getEffectiveInquirer(dependency, inquirer, parentInquirer, contextId) {
-        return dependency?.isTransient &&
+    getEffectiveInquirer(dependency, resolutionContext, parentInquirer) {
+        const { inquirer, contextId } = resolutionContext;
+        if (dependency?.isTransient && inquirer?.isTransient && parentInquirer) {
+            if (contextId === STATIC_CONTEXT) {
+                return inquirer.getRootInquirer() ?? parentInquirer;
+            }
+            return parentInquirer;
+        }
+        return inquirer;
+    }
+    getEffectiveInquirerId(dependency, resolutionContext, parentInquirer) {
+        const { contextId, inquirer, effectiveInquirerId } = resolutionContext;
+        if (contextId === STATIC_CONTEXT &&
+            dependency?.isTransient &&
             inquirer?.isTransient &&
-            parentInquirer &&
-            contextId !== STATIC_CONTEXT
-            ? parentInquirer
-            : inquirer;
+            parentInquirer) {
+            const baseInquirerId = effectiveInquirerId ?? this.getInquirerId(parentInquirer);
+            return `${baseInquirerId}:${inquirer.id}`;
+        }
+        const effectiveInquirer = this.getEffectiveInquirer(dependency, resolutionContext, parentInquirer);
+        return this.getInquirerId(effectiveInquirer);
+    }
+    getStaticTransientResolutionContext(resolutionContext, parentInquirer) {
+        const { contextId, inquirer, effectiveInquirerId } = resolutionContext;
+        if (contextId === STATIC_CONTEXT &&
+            inquirer?.isTransient &&
+            parentInquirer) {
+            const baseInquirerId = effectiveInquirerId ?? this.getInquirerId(parentInquirer);
+            return this.createResolutionContext(contextId, inquirer, `${baseInquirerId}:${inquirer.id}`);
+        }
+        return resolutionContext;
+    }
+    getEffectiveResolutionContext(dependency, resolutionContext, parentInquirer) {
+        return this.createResolutionContext(resolutionContext.contextId, this.getEffectiveInquirer(dependency, resolutionContext, parentInquirer), this.getEffectiveInquirerId(dependency, resolutionContext, parentInquirer));
     }
     resolveScopedComponentHost(item, contextId, inquirer, parentInquirer) {
         return this.isInquirerRequest(item, parentInquirer)
             ? parentInquirer
-            : this.resolveComponentHost(item.host, item, contextId, this.getEffectiveInquirer(item, inquirer, parentInquirer, contextId));
+            : this.resolveComponentHost(item.host, item, this.getEffectiveResolutionContext(item, this.createResolutionContext(contextId, inquirer), parentInquirer));
     }
     isInquirerRequest(item, parentInquirer) {
         return item.isTransient && item.name === INQUIRER && parentInquirer;

package/injector/module-ref.js

@@ -2,6 +2,7 @@ import { Scope } from '@nestjs/common';
 import { getClassScope } from '../helpers/get-class-scope.js';
 import { isDurable } from '../helpers/is-durable.js';
 import { AbstractInstanceResolver } from './abstract-instance-resolver.js';
+import { STATIC_CONTEXT } from './constants.js';
 import { Injector } from './injector.js';
 import { InstanceLinksHost } from './instance-links-host.js';
 import { InstanceWrapper } from './instance-wrapper.js';
@@ -18,9 +19,11 @@ export class ModuleRef extends AbstractInstanceResolver {
     constructor(container) {
         super();
         this.container = container;
+        const contextOptions = container.contextOptions;
         this.injector = new Injector({
-            preview: container.contextOptions?.preview,
-            instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+            preview: contextOptions?.preview ?? false,
+            snapshot: contextOptions?.snapshot,
+            instanceDecorator: contextOptions?.instrument?.instanceDecorator,
         });
     }
     introspect(token) {
@@ -46,20 +49,30 @@ export class ModuleRef extends AbstractInstanceResolver {
             durable: isDurable(type),
             host: moduleRef,
         });
-        /* eslint-disable-next-line no-async-promise-executor */
-        return new Promise(async (resolve, reject) => {
-            try {
+        if (type?.prototype) {
+            wrapper.setInstanceByContextId(contextId ?? STATIC_CONTEXT, {
+                instance: Object.create(type.prototype),
+                isResolved: false,
+                isPending: false,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const loadInstance = async () => {
                 const callback = async (instances) => {
-                    const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, contextId);
+                    const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, {
+                        contextId: contextId ?? STATIC_CONTEXT,
+                        inquirer: wrapper,
+                    });
                     const instance = new type(...instances);
                     this.injector.applyProperties(instance, properties);
                     resolve(instance);
                 };
-                await this.injector.resolveConstructorParams(wrapper, moduleRef, undefined, callback, contextId);
-            }
-            catch (err) {
-                reject(err);
-            }
+                await this.injector.resolveConstructorParams(wrapper, moduleRef, undefined, callback, {
+                    contextId: contextId ?? STATIC_CONTEXT,
+                    inquirer: wrapper,
+                });
+            };
+            void loadInstance().catch(reject);
         });
     }
 }

package/middleware/middleware-module.js

@@ -178,7 +178,10 @@ export class MiddlewareModule {
         const middlewareFunction = isMethodAll
             ? proxy
             : (req, res, next) => {
-                if (applicationRef.getRequestMethod?.(req) === requestMethod) {
+                const actualRequestMethod = applicationRef.getRequestMethod?.(req);
+                if (actualRequestMethod === requestMethod ||
+                    (actualRequestMethod === RequestMethod[RequestMethod.HEAD] &&
+                        requestMethod === RequestMethod[RequestMethod.GET])) {
                     return proxy(req, res, next);
                 }
                 return next();

package/nest-factory.d.ts

@@ -2,7 +2,12 @@ import type { DynamicModule, ForwardReference, INestApplication, INestApplicatio
 import { AbstractHttpAdapter } from './adapters/http-adapter.js';
 import { type NestMicroserviceOptions, type NestApplicationContextOptions } from '@nestjs/common/internal';
 import { type NestApplicationOptions } from '@nestjs/common';
-type IEntryNestModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryNestModule>;
+/**
+ * Represents the entry (root) module type accepted by the NestFactory methods.
+ *
+ * @publicApi
+ */
+export type IEntryNestModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryNestModule>;
 /**
  * @publicApi
  */
@@ -79,4 +84,3 @@ export declare class NestFactoryStatic {
  * @publicApi
  */
 export declare const NestFactory: NestFactoryStatic;
-export {};

package/nest-factory.js

@@ -91,6 +91,7 @@ export class NestFactoryStatic {
             : UuidFactoryMode.Random;
         const injector = new Injector({
             preview: options.preview,
+            snapshot: options.snapshot,
             instanceDecorator: options.instrument?.instanceDecorator,
         });
         const instanceLoader = new InstanceLoader(container, injector, graphInspector);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "12.0.0-alpha.2",
+  "version": "12.0.0-alpha.4",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -42,12 +42,12 @@
     "@nuxt/opencollective": "0.4.1",
     "fast-safe-stringify": "2.1.1",
     "iterare": "1.2.1",
-    "path-to-regexp": "8.3.0",
+    "path-to-regexp": "8.4.2",
     "tslib": "2.8.1",
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "^12.0.0-alpha.2"
+    "@nestjs/common": "^12.0.0-alpha.4"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -68,5 +68,5 @@
       "optional": true
     }
   },
-  "gitHead": "011bff66014e24e82b25f7acf9302b9efb70b02b"
+  "gitHead": "415e4d33707e74998d8456be7bd305cedb6508e3"
 }

package/router/router-execution-context.js

@@ -176,7 +176,12 @@ export class RouterExecutionContext {
         const isSseHandler = !!this.reflectSse(callback);
         if (isSseHandler) {
             return async (result, res, req) => {
-                await this.responseController.sse(result, res.raw || res, req.raw || req, { additionalHeaders: res.getHeaders?.() });
+                const rawResponse = res.raw ?? res;
+                await this.responseController.sse(result, rawResponse, req.raw || req, {
+                    additionalHeaders: res.getHeaders?.(),
+                    statusCode: res.statusCode ??
+                        rawResponse.statusCode,
+                });
             };
         }
         return async (result, res) => {

package/router/router-response-controller.d.ts

@@ -22,7 +22,8 @@ export declare class RouterResponseController {
     setHeaders<TResponse = unknown>(response: TResponse, headers: CustomHeader[]): void;
     setStatus<TResponse = unknown>(response: TResponse, statusCode: number): void;
     sse<TInput extends Observable<unknown> = any, TResponse extends WritableHeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput | Promise<TInput>, response: TResponse, request: TRequest, options?: {
-        additionalHeaders: AdditionalHeaders;
+        additionalHeaders?: AdditionalHeaders;
+        statusCode?: number;
     }): Promise<void>;
     private assertObservable;
 }

package/router/router-response-controller.js

@@ -54,37 +54,71 @@ export class RouterResponseController {
         const observableResult = await Promise.resolve(result);
         this.assertObservable(observableResult);
         const stream = new SseStream(request);
-        // Extract custom status code from response if it was set
-        const customStatusCode = response.statusCode;
-        const pipeOptions = typeof customStatusCode !== 'undefined'
-            ? { ...options, statusCode: customStatusCode }
-            : options;
-        stream.pipe(response, pipeOptions);
-        const subscription = observableResult
-            .pipe(map((message) => {
-            if (isObject(message)) {
-                return message;
-            }
-            return { data: message };
-        }), 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);
+        const statusCode = options?.statusCode ??
+            response.statusCode ??
+            200;
+        stream.pipe(response, {
+            additionalHeaders: options?.additionalHeaders,
+            statusCode,
+        });
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const onClose = () => {
+                settled = true;
+                subscription.unsubscribe();
+                if (!stream.writableEnded) {
+                    stream.end();
                 }
-            });
-            return EMPTY;
-        }))
-            .subscribe({
-            complete: () => {
                 response.end();
-            },
-        });
-        request.on('close', () => {
-            subscription.unsubscribe();
-            if (!stream.writableEnded) {
-                stream.end();
-            }
+                resolve();
+            };
+            const subscription = observableResult
+                .pipe(map((message) => {
+                if (isObject(message)) {
+                    return message;
+                }
+                return { data: message };
+            }), concatMap(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), catchError(err => {
+                if (!stream.headersCommitted) {
+                    throw err;
+                }
+                const data = err instanceof Error ? err.message : err;
+                stream.writeMessage({ type: 'error', data }, writeError => {
+                    if (writeError) {
+                        this.logger.error(writeError);
+                    }
+                });
+                return EMPTY;
+            }))
+                .subscribe({
+                error: err => {
+                    settled = true;
+                    request.removeListener('close', onClose);
+                    if (!stream.writableEnded) {
+                        stream.end();
+                    }
+                    reject(err);
+                },
+                complete: () => {
+                    settled = true;
+                    request.removeListener('close', onClose);
+                    if (!stream.writableEnded) {
+                        stream.end();
+                    }
+                    resolve();
+                },
+            });
+            // Commit SSE headers on the next macrotask. Pipe validation errors
+            // propagate through microtasks (which complete before macrotasks),
+            // so if the lifecycle errored, `settled` is already true and we
+            // skip the write. Otherwise headers are sent immediately rather
+            // than waiting for the first Observable emission.
+            setTimeout(() => {
+                if (!settled) {
+                    stream.commitHeaders();
+                }
+            }, 0);
+            request.on('close', onClose);
         });
     }
     assertObservable(value) {

package/router/sse-stream.d.ts

@@ -28,12 +28,24 @@ export type HeaderStream = WritableHeaderStream & ReadHeaders;
  */
 export declare class SseStream extends Transform {
     private lastEventId;
+    private _headersCommitted;
+    private _destination;
+    private _statusCode;
+    private _additionalHeaders;
     constructor(req?: IncomingMessage);
+    get headersCommitted(): boolean;
     pipe<T extends WritableHeaderStream>(destination: T, options?: {
         additionalHeaders?: AdditionalHeaders;
         statusCode?: number;
         end?: boolean;
     }): T;
+    /**
+     * Writes SSE headers to the destination if they have not been sent yet.
+     * Headers are deferred until the first message so that, if the observable
+     * errors before any data is emitted, the HTTP status code can still be
+     * changed by an exception filter.
+     */
+    commitHeaders(): void;
     _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
     /**
      * Calls `.write` but handles the drain if needed

package/router/sse-stream.js

@@ -24,6 +24,10 @@ function toDataString(data) {
  */
 export class SseStream extends Transform {
     lastEventId = null;
+    _headersCommitted = false;
+    _destination = null;
+    _statusCode = 200;
+    _additionalHeaders;
     constructor(req) {
         super({ objectMode: true });
         if (req && req.socket) {
@@ -32,11 +36,34 @@ export class SseStream extends Transform {
             req.socket.setTimeout(0);
         }
     }
+    get headersCommitted() {
+        return this._headersCommitted;
+    }
     pipe(destination, options) {
-        if (destination.writeHead) {
-            const statusCode = options?.statusCode ?? 200;
-            destination.writeHead(statusCode, {
-                ...options?.additionalHeaders,
+        this._destination = destination;
+        this._statusCode = options?.statusCode ?? 200;
+        this._additionalHeaders = options?.additionalHeaders;
+        return super.pipe(destination, options);
+    }
+    /**
+     * Writes SSE headers to the destination if they have not been sent yet.
+     * Headers are deferred until the first message so that, if the observable
+     * errors before any data is emitted, the HTTP status code can still be
+     * changed by an exception filter.
+     */
+    commitHeaders() {
+        if (this._headersCommitted || !this._destination) {
+            return;
+        }
+        if (this._destination.writableEnded) {
+            return;
+        }
+        this._headersCommitted = true;
+        const statusCode = this._statusCode ?? 200;
+        const additionalHeaders = this._additionalHeaders;
+        if (this._destination.writeHead) {
+            this._destination.writeHead(statusCode, {
+                ...additionalHeaders,
                 // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
                 'Content-Type': 'text/event-stream',
                 Connection: 'keep-alive',
@@ -47,15 +74,19 @@ export class SseStream extends Transform {
                 // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
                 'X-Accel-Buffering': 'no',
             });
-            destination.flushHeaders?.();
+            this._destination.flushHeaders?.();
         }
-        destination.write('\n');
-        return super.pipe(destination, options);
+        this._destination.write('\n');
     }
     _transform(message, encoding, callback) {
-        let data = message.type ? `event: ${message.type}\n` : '';
-        data += message.id ? `id: ${message.id}\n` : '';
-        data += message.retry ? `retry: ${message.retry}\n` : '';
+        this.commitHeaders();
+        const sanitize = (val) => String(val).replace(/[\r\n]/g, '');
+        let data = message.type ? `event: ${sanitize(message.type)}\n` : '';
+        data +=
+            message.id !== undefined && message.id !== null
+                ? `id: ${sanitize(message.id)}\n`
+                : '';
+        data += message.retry ? `retry: ${sanitize(message.retry)}\n` : '';
         data += message.data ? toDataString(message.data) : '';
         data += '\n';
         this.push(data);
@@ -65,7 +96,7 @@ export class SseStream extends Transform {
      * Calls `.write` but handles the drain if needed
      */
     writeMessage(message, cb) {
-        if (!message.id) {
+        if (message.id === undefined || message.id === null) {
             this.lastEventId++;
             message.id = this.lastEventId.toString();
         }

package/injector/helpers/transient-instances.d.ts

@@ -1,12 +0,0 @@
-import { InjectionToken } from '@nestjs/common';
-import { InstanceWrapper } from '../instance-wrapper';
-/**
- * Returns the instances which are transient
- * @param instances The instances which should be checked whether they are transient
- */
-export declare function getTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
-/**
- * Returns the instances which are not transient
- * @param instances The instances which should be checked whether they are transient
- */
-export declare function getNonTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];

package/injector/helpers/transient-instances.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransientInstances = getTransientInstances;
-exports.getNonTransientInstances = getNonTransientInstances;
-const iterare_1 = require("iterare");
-/**
- * Returns the instances which are transient
- * @param instances The instances which should be checked whether they are transient
- */
-function getTransientInstances(instances) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(([_, wrapper]) => wrapper.isDependencyTreeStatic())
-        .map(([_, wrapper]) => wrapper.getStaticTransientInstances())
-        .flatten()
-        .filter(item => !!item)
-        .map(({ instance }) => instance)
-        .toArray();
-}
-/**
- * Returns the instances which are not transient
- * @param instances The instances which should be checked whether they are transient
- */
-function getNonTransientInstances(instances) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(([key, wrapper]) => wrapper.isDependencyTreeStatic() && !wrapper.isTransient)
-        .map(([key, { instance }]) => instance)
-        .toArray();
-}