@nestjs/core 11.1.29 → 11.2.1

package/adapters/http-adapter.d.ts

@@ -41,6 +41,8 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     all(path: any, handler: RequestHandler): any;
     search(handler: RequestHandler): any;
     search(path: any, handler: RequestHandler): any;
+    query(handler: RequestHandler): any;
+    query(path: any, handler: RequestHandler): any;
     options(handler: RequestHandler): any;
     options(path: any, handler: RequestHandler): any;
     listen(port: string | number, callback?: () => void): any;

package/adapters/http-adapter.js

@@ -57,6 +57,9 @@ class AbstractHttpAdapter {
     search(...args) {
         return this.instance.search(...args);
     }
+    query(...args) {
+        return this.instance.query(...args);
+    }
     options(...args) {
         return this.instance.options(...args);
     }

package/helpers/router-method-factory.d.ts

@@ -17,6 +17,7 @@ export declare const REQUEST_METHOD_MAP: {
     readonly 13: "move";
     readonly 14: "lock";
     readonly 15: "unlock";
+    readonly 16: "query";
 };
 export declare class RouterMethodFactory {
     get(target: HttpServer, requestMethod: RequestMethod): Function;

package/helpers/router-method-factory.js

@@ -19,6 +19,7 @@ exports.REQUEST_METHOD_MAP = {
     [request_method_enum_1.RequestMethod.MOVE]: 'move',
     [request_method_enum_1.RequestMethod.LOCK]: 'lock',
     [request_method_enum_1.RequestMethod.UNLOCK]: 'unlock',
+    [request_method_enum_1.RequestMethod.QUERY]: 'query',
 };
 class RouterMethodFactory {
     get(target, requestMethod) {

package/injector/container.js

@@ -65,7 +65,7 @@ class NestContainer {
         if (this.modules.has(token)) {
             return {
                 moduleRef: this.modules.get(token),
-                inserted: true,
+                inserted: false,
             };
         }
         return {
@@ -91,7 +91,7 @@ class NestContainer {
                 type,
                 dynamicMetadata,
             }, scope),
-            inserted: false,
+            inserted: true,
         };
     }
     async setModule({ token, dynamicMetadata, type }, scope) {

package/injector/internal-core-module/internal-core-module-factory.js

@@ -18,7 +18,7 @@ class InternalCoreModuleFactory {
                 timestamp: false,
             });
             const injector = new injector_1.Injector({
-                preview: container.contextOptions?.preview,
+                preview: container.contextOptions?.preview ?? false,
                 instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
             });
             const instanceLoader = new instance_loader_1.InstanceLoader(container, injector, graphInspector, logger);

package/injector/module.d.ts

@@ -35,6 +35,12 @@ export declare class Module {
     get entryProviders(): Array<InstanceWrapper<Injectable>>;
     get exports(): Set<InjectionToken>;
     get instance(): NestModule;
+    /**
+     * Modules are registered in the container before they are scanned (dynamic
+     * `imports` are pre-registered by `NestContainer#addDynamicMetadata`), so
+     * registration alone does not imply the module was ever instantiated.
+     */
+    get isInstantiated(): boolean;
     get metatype(): Type<any>;
     get distance(): number;
     set distance(value: number);

package/injector/module.js

@@ -84,6 +84,14 @@ class Module {
         const moduleRef = this._providers.get(this._metatype);
         return moduleRef.instance;
     }
+    /**
+     * Modules are registered in the container before they are scanned (dynamic
+     * `imports` are pre-registered by `NestContainer#addDynamicMetadata`), so
+     * registration alone does not imply the module was ever instantiated.
+     */
+    get isInstantiated() {
+        return !(0, shared_utils_1.isNil)(this._providers.get(this._metatype)?.instance);
+    }
     get metatype() {
         return this._metatype;
     }

package/interceptors/interceptors-consumer.js

@@ -39,12 +39,10 @@ class InterceptorsConsumer {
                 .then(res => {
                 if (subscriber.closed) {
                     // The outer subscription was torn down (e.g. an SSE client disconnect)
-                    // before the async handler resolved. Subscribe-and-immediately-unsubscribe
-                    // so the producer Observable's teardown/cleanup logic still runs.
-                    if (res instanceof rxjs_1.Observable) {
-                        const sub = res.subscribe({ error: () => { } });
-                        sub.unsubscribe();
-                    }
+                    // before the async handler resolved. Do not subscribe the producer
+                    // Observable after the consumer has already gone away — subscribing
+                    // only to unsubscribe in the same tick would start producer side
+                    // effects just to immediately abort them.
                     return;
                 }
                 const isDeferred = res instanceof Promise || res instanceof rxjs_1.Observable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "11.1.29",
+  "version": "11.2.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "11.1.29"
+    "@nestjs/common": "11.2.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -49,5 +49,5 @@
       "optional": true
     }
   },
-  "gitHead": "03587a112ebbbb53a6bc3875afb5a9205aa5a5f1"
+  "gitHead": "4535f43b4890c9c69c57c5a5a8b49f62c83d1ed6"
 }

package/router/legacy-route-converter.js

@@ -45,10 +45,12 @@ class LegacyRouteConverter {
         }
         // When route includes any wildcard segments in the middle.
         if (normalizedRoute.includes('/*/')) {
-            // Replace each /*/ segment with a named parameter using different name for each segment.
-            const convertedRoute = route.replaceAll('/*/', (match, offset) => {
-                return `/*path${offset}/`;
-            });
+            // Replace each "*" segment with a named parameter, using a different name
+            // for each. Match "/*" with a lookahead for the following "/" so the
+            // trailing slash is not consumed. Consuming it made two adjacent "/*/*/"
+            // segments share a slash, so only the first one got converted and the
+            // second was left as an unnamed "*" that path-to-regexp still rejects.
+            const convertedRoute = route.replaceAll(/\/\*(?=\/)/g, (match, offset) => `/*path${offset}`);
             printWarning(route, convertedRoute);
             return convertedRoute;
         }

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

@@ -51,4 +51,5 @@ export declare class RouterExecutionContext {
     })[]): (<TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>) | null;
     createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
     private isResponseHandled;
+    private attachSseAbortSignal;
 }

package/router/router-execution-context.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterExecutionContext = void 0;
 const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
+const sse_signal_decorator_1 = require("@nestjs/common/decorators/http/sse-signal.decorator");
 const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const guards_1 = require("../guards");
@@ -43,6 +44,13 @@ class RouterExecutionContext {
             this.responseController.setStatus(res, httpStatusCode);
             hasCustomHeaders &&
                 this.responseController.setHeaders(res, responseHeaders);
+            if (isSseHandler) {
+                // Attach a per-request AbortController before the handler runs so async
+                // @Sse() handlers can observe client disconnects via @SseSignal() during
+                // their setup. The controller is aborted in RouterResponseController.sse()
+                // when the underlying connection closes.
+                this.attachSseAbortSignal(req);
+            }
             const resultOrDeferred = this.interceptorsConsumer.intercept(interceptors, [req, res, next], instance, callback, handler(args, req, res, next), contextType);
             const result = isSseHandler ? resultOrDeferred : await resultOrDeferred;
             await fnHandleResponse(result, res, req);
@@ -190,5 +198,18 @@ class RouterExecutionContext {
         const isPassthroughEnabled = this.contextUtils.reflectPassthrough(instance, methodName);
         return hasResponseOrNextDecorator && !isPassthroughEnabled;
     }
+    attachSseAbortSignal(req) {
+        const carrier = req;
+        // Attach to both the framework request and its raw form (when present), since
+        // @SseSignal() reads from the execution-context request while
+        // RouterResponseController.sse() operates on the raw request.
+        if (!carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER]) {
+            carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER] = new AbortController();
+        }
+        if (carrier.raw && !carrier.raw[sse_signal_decorator_1.SSE_ABORT_CONTROLLER]) {
+            carrier.raw[sse_signal_decorator_1.SSE_ABORT_CONTROLLER] =
+                carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER];
+        }
+    }
 }
 exports.RouterExecutionContext = RouterExecutionContext;

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

@@ -26,4 +26,5 @@ export declare class RouterResponseController {
         statusCode?: number;
     }): Promise<void>;
     private assertObservable;
+    private getOrCreateAbortController;
 }

package/router/router-response-controller.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterResponseController = void 0;
 const common_1 = require("@nestjs/common");
+const sse_signal_decorator_1 = require("@nestjs/common/decorators/http/sse-signal.decorator");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
@@ -51,18 +52,38 @@ class RouterResponseController {
     async sse(result, response, request, options) {
         // It's possible that we sent headers already so don't use a stream
         if (response.writableEnded) {
+            // The response is already gone: abort the request-scoped signal so
+            // handler cleanup wired to @SseSignal() still runs, and swallow late
+            // handler rejections that can no longer be delivered to the client.
+            this.getOrCreateAbortController(request).abort();
+            Promise.resolve(result).catch((err) => this.logger.error(err));
             return;
         }
         const stream = new sse_stream_1.SseStream(request);
         const statusCode = options?.statusCode ??
             response.statusCode ??
             200;
+        // Create a per-request AbortController and expose its signal on the request
+        // object so async @Sse() handlers can observe client disconnects (via the
+        // @SseSignal() parameter decorator) and stop/clean up in-flight setup work.
+        // The controller is reused if one was already attached upstream (e.g. when the
+        // handler is wrapped by interceptors and the signal was created earlier).
+        const abortController = this.getOrCreateAbortController(request);
         return new Promise((resolve, reject) => {
             let settled = false;
             let closeRequested = false;
             let subscription;
             const disconnectSource = request.socket ?? response;
-            const cleanup = () => disconnectSource.removeListener('close', onClose);
+            // Ends the request-scoped lifetime: stops listening for disconnects and
+            // aborts the signal handed to the route handler. Every terminal path of
+            // the SSE lifecycle (disconnect, completion, error) funnels through here,
+            // so a handler that ties its resources to the signal releases them once,
+            // regardless of how the stream ended. `abort()` is idempotent, so paths
+            // that already aborted on disconnect are unaffected.
+            const finalize = () => {
+                disconnectSource.removeListener('close', onClose);
+                abortController.abort();
+            };
             const endStream = () => {
                 if (!stream.writableEnded) {
                     stream.end();
@@ -74,11 +95,11 @@ class RouterResponseController {
                 }
                 closeRequested = true;
                 if (!subscription) {
-                    cleanup();
+                    finalize();
                     return;
                 }
                 settled = true;
-                cleanup();
+                finalize();
                 subscription?.unsubscribe();
                 endStream();
                 response.end();
@@ -92,10 +113,10 @@ class RouterResponseController {
                 }
                 this.assertObservable(observableResult);
                 if (closeRequested) {
-                    const cleanupSubscription = observableResult.subscribe({
-                        error: () => undefined,
-                    });
-                    cleanupSubscription.unsubscribe();
+                    // The client disconnected while the async handler was resolving.
+                    // Do not subscribe the producer Observable after the consumer has
+                    // already gone away — subscribing only to abort it in the same tick
+                    // would start producer side effects just to immediately cancel them.
                     settled = true;
                     endStream();
                     response.end();
@@ -130,7 +151,7 @@ class RouterResponseController {
                             return;
                         }
                         settled = true;
-                        cleanup();
+                        finalize();
                         endStream();
                         reject(err);
                     },
@@ -139,7 +160,7 @@ class RouterResponseController {
                             return;
                         }
                         settled = true;
-                        cleanup();
+                        finalize();
                         endStream();
                         resolve();
                     },
@@ -167,7 +188,7 @@ class RouterResponseController {
                     return;
                 }
                 settled = true;
-                cleanup();
+                finalize();
                 endStream();
                 reject(err);
             });
@@ -178,5 +199,12 @@ class RouterResponseController {
             throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
         }
     }
+    getOrCreateAbortController(request) {
+        const carrier = request;
+        if (!carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER]) {
+            carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER] = new AbortController();
+        }
+        return carrier[sse_signal_decorator_1.SSE_ABORT_CONTROLLER];
+    }
 }
 exports.RouterResponseController = RouterResponseController;

package/scanner.js

@@ -40,6 +40,9 @@ class DependenciesScanner {
     async scanForModules({ moduleDefinition, lazy, scope = [], ctxRegistry = [], overrides = [], }) {
         const { moduleRef: moduleInstance, inserted: moduleInserted } = (await this.insertOrOverrideModule(moduleDefinition, overrides, scope)) ??
             {};
+        if (lazy && !moduleInserted && moduleInstance?.isInstantiated) {
+            return [];
+        }
         moduleDefinition =
             this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ??
                 moduleDefinition;
@@ -81,7 +84,7 @@ class DependenciesScanner {
         if (!moduleInstance) {
             return registeredModuleRefs;
         }
-        if (lazy && moduleInserted) {
+        if (lazy) {
             this.container.bindGlobalsToImports(moduleInstance);
         }
         return [moduleInstance].concat(registeredModuleRefs);