@nestjs/core 11.1.9 → 11.1.11

package/injector/abstract-instance-resolver.js

@@ -31,7 +31,7 @@ class AbstractInstanceResolver {
         const pluckInstance = async (instanceLink) => {
             const { wrapperRef, collection } = instanceLink;
             if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient) {
-                return this.get(typeOrToken, { strict: options?.strict });
+                return wrapperRef.instance;
             }
             const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
             const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);

package/injector/injector.js

@@ -257,7 +257,11 @@ class Injector {
              * instantiated beforehand.
              */
             instanceHost.donePromise &&
-                void instanceHost.donePromise.then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer));
+                void instanceHost.donePromise
+                    .then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer))
+                    .catch(err => {
+                    instanceWrapper.settlementSignal?.error(err);
+                });
         }
         if (instanceWrapper.async) {
             const host = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);

package/injector/instance-wrapper.js

@@ -240,14 +240,29 @@ class InstanceWrapper {
             (isSelfRequested || !!(inquirer && inquirer.scope === common_1.Scope.TRANSIENT)));
     }
     isStatic(contextId, inquirer) {
+        if (!this.isDependencyTreeStatic() || contextId !== constants_1.STATIC_CONTEXT) {
+            return false;
+        }
+        // Non-transient provider in static context
+        if (!this.isTransient) {
+            return true;
+        }
         const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
         const isStaticTransient = this.isTransient && !isInquirerRequestScoped;
         const rootInquirer = inquirer?.getRootInquirer();
-        return (this.isDependencyTreeStatic() &&
-            contextId === constants_1.STATIC_CONTEXT &&
-            (!this.isTransient ||
-                (isStaticTransient && !!inquirer && !inquirer.isTransient) ||
-                (isStaticTransient && !!rootInquirer && !rootInquirer.isTransient)));
+        // Transient provider inquired by non-transient (e.g., DEFAULT -> TRANSIENT)
+        if (isStaticTransient && inquirer && !inquirer.isTransient) {
+            return true;
+        }
+        // Nested transient with non-transient root (e.g., DEFAULT -> TRANSIENT -> TRANSIENT)
+        if (isStaticTransient && rootInquirer && !rootInquirer.isTransient) {
+            return true;
+        }
+        // Nested transient during initial instantiation (rootInquirer not yet set)
+        if (isStaticTransient && inquirer?.isTransient && !rootInquirer) {
+            return true;
+        }
+        return false;
     }
     attachRootInquirer(inquirer) {
         if (!this.isTransient) {

package/nest-application-context.d.ts

@@ -1,5 +1,5 @@
 import { INestApplicationContext, Logger, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
-import { DynamicModule, SelectOptions, Type } from '@nestjs/common/interfaces';
+import { DynamicModule, SelectOptions, ShutdownHooksOptions, Type } from '@nestjs/common/interfaces';
 import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
 import { AbstractInstanceResolver } from './injector/abstract-instance-resolver';
 import { NestContainer } from './injector/container';
@@ -124,18 +124,20 @@ export declare class NestApplicationContext<TOptions extends NestApplicationCont
      * process receives a shutdown signal.
      *
      * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     * @param {ShutdownHooksOptions} [options={}] Options for configuring shutdown hooks behavior
      *
      * @returns {this} The Nest application context instance
      */
-    enableShutdownHooks(signals?: (ShutdownSignal | string)[]): this;
+    enableShutdownHooks(signals?: (ShutdownSignal | string)[], options?: ShutdownHooksOptions): this;
     protected dispose(): Promise<void>;
     /**
      * Listens to shutdown signals by listening to
      * process events
      *
      * @param {string[]} signals The system signals it should listen to
+     * @param {ShutdownHooksOptions} options Options for configuring shutdown hooks behavior
      */
-    protected listenToShutdownSignals(signals: string[]): void;
+    protected listenToShutdownSignals(signals: string[], options?: ShutdownHooksOptions): void;
     /**
      * Unsubscribes from shutdown signals (process events)
      */

package/nest-application-context.js

@@ -161,10 +161,11 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * process receives a shutdown signal.
      *
      * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     * @param {ShutdownHooksOptions} [options={}] Options for configuring shutdown hooks behavior
      *
      * @returns {this} The Nest application context instance
      */
-    enableShutdownHooks(signals = []) {
+    enableShutdownHooks(signals = [], options = {}) {
         if ((0, shared_utils_1.isEmpty)(signals)) {
             signals = Object.keys(common_1.ShutdownSignal).map((key) => common_1.ShutdownSignal[key]);
         }
@@ -178,7 +179,7 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
             // filter out the signals which is already listening to
             .filter(signal => !this.activeShutdownSignals.includes(signal))
             .toArray();
-        this.listenToShutdownSignals(signals);
+        this.listenToShutdownSignals(signals, options);
         return this;
     }
     async dispose() {
@@ -191,8 +192,9 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * process events
      *
      * @param {string[]} signals The system signals it should listen to
+     * @param {ShutdownHooksOptions} options Options for configuring shutdown hooks behavior
      */
-    listenToShutdownSignals(signals) {
+    listenToShutdownSignals(signals, options = {}) {
         let receivedSignal = false;
         const cleanup = async (signal) => {
             try {
@@ -208,7 +210,15 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
                 await this.dispose();
                 await this.callShutdownHook(signal);
                 signals.forEach(sig => process.removeListener(sig, cleanup));
-                process.kill(process.pid, signal);
+                if (options.useProcessExit) {
+                    // Use process.exit() to ensure the 'exit' event is properly triggered.
+                    // This is required for async loggers (like Pino with transports)
+                    // to flush their buffers before the process terminates.
+                    process.exit(0);
+                }
+                else {
+                    process.kill(process.pid, signal);
+                }
             }
             catch (err) {
                 common_1.Logger.error(constants_1.MESSAGES.ERROR_DURING_SHUTDOWN, err?.stack, NestApplicationContext.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "11.1.9",
+  "version": "11.1.11",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "11.1.9"
+    "@nestjs/common": "11.1.11"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -59,5 +59,6 @@
     "@nestjs/platform-express": {
       "optional": true
     }
-  }
+  },
+  "gitHead": "20529c07e3cc6647fa7611ef6eb776ad5507a325"
 }

package/router/router-execution-context.js

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

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

@@ -21,8 +21,8 @@ export declare class RouterResponseController {
     getStatusByMethod(requestMethod: RequestMethod): number;
     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, response: TResponse, request: TRequest, options?: {
+    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;
-    }): void;
+    }): Promise<void>;
     private assertObservable;
 }

package/router/router-response-controller.js

@@ -48,15 +48,21 @@ class RouterResponseController {
     setStatus(response, statusCode) {
         this.applicationRef.status(response, statusCode);
     }
-    sse(result, response, request, options) {
+    async sse(result, response, request, options) {
         // It's possible that we sent headers already so don't use a stream
         if (response.writableEnded) {
             return;
         }
-        this.assertObservable(result);
+        const observableResult = await Promise.resolve(result);
+        this.assertObservable(observableResult);
         const stream = new sse_stream_1.SseStream(request);
-        stream.pipe(response, options);
-        const subscription = result
+        // 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((0, operators_1.map)((message) => {
             if ((0, shared_utils_1.isObject)(message)) {
                 return message;

package/router/sse-stream.d.ts

@@ -31,6 +31,7 @@ export declare class SseStream extends Transform {
     constructor(req?: IncomingMessage);
     pipe<T extends WritableHeaderStream>(destination: T, options?: {
         additionalHeaders?: AdditionalHeaders;
+        statusCode?: number;
         end?: boolean;
     }): T;
     _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;

package/router/sse-stream.js

@@ -37,7 +37,8 @@ class SseStream extends stream_1.Transform {
     }
     pipe(destination, options) {
         if (destination.writeHead) {
-            destination.writeHead(200, {
+            const statusCode = options?.statusCode ?? 200;
+            destination.writeHead(statusCode, {
                 ...options?.additionalHeaders,
                 // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
                 'Content-Type': 'text/event-stream',