@nestjs/core 11.1.28 → 11.2.0

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/barrier.js

@@ -11,6 +11,9 @@ class Barrier {
         this.promise = new Promise(resolve => {
             this.resolve = resolve;
         });
+        if (targetCount === 0) {
+            this.resolve();
+        }
     }
     /**
      * Signal that a participant has reached the barrier.
@@ -19,7 +22,7 @@ class Barrier {
      */
     signal() {
         this.currentCount += 1;
-        if (this.currentCount === this.targetCount) {
+        if (this.currentCount >= this.targetCount) {
             this.resolve();
         }
     }

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/injector.js

@@ -328,16 +328,12 @@ class Injector {
             this.printFoundInModuleLog(name, relatedModule);
             instanceWrapperRef = providers.get(name);
             this.addDependencyMetadata(keyOrIndex, wrapper, instanceWrapperRef);
-            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
-                 * Barrier. We cannot load it here because doing so could incorrectly evaluate the
-                 * staticity of the dependency tree and lead to undefined / null injection.
-                 */
-                break;
-            }
+            /*
+             * Stop at the first direct export match. Continuing when the provider is
+             * already resolved would let a later import (e.g. a global forRoot module)
+             * override an explicit forFeature import for the same token.
+             */
+            break;
         }
         return instanceWrapperRef;
     }

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-ref.js

@@ -56,9 +56,9 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
                 isPending: false,
             });
         }
-        return new Promise(async (resolve, reject) => {
-            try {
-                const callback = async (instances) => {
+        return new Promise((resolve, reject) => {
+            const callback = async (instances) => {
+                try {
                     const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, {
                         contextId: contextId ?? constants_1.STATIC_CONTEXT,
                         inquirer: wrapper,
@@ -66,15 +66,17 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
                     const instance = new type(...instances);
                     this.injector.applyProperties(instance, properties);
                     resolve(instance);
-                };
-                await this.injector.resolveConstructorParams(wrapper, moduleRef, undefined, callback, {
-                    contextId: contextId ?? constants_1.STATIC_CONTEXT,
-                    inquirer: wrapper,
-                });
-            }
-            catch (err) {
-                reject(err);
-            }
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            this.injector
+                .resolveConstructorParams(wrapper, moduleRef, undefined, callback, {
+                contextId: contextId ?? constants_1.STATIC_CONTEXT,
+                inquirer: wrapper,
+            })
+                .catch(reject);
         });
     }
 }

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/middleware/builder.js

@@ -73,7 +73,11 @@ MiddlewareBuilder.ConfigProxy = class {
             .map(route => ({
             method: route.method,
             path: route.path,
-            regex: new RegExp('^(' + route.path.replace(regexMatchParams, wildcard) + ')$', 'g'),
+            // No `g` flag: each regex is reused across every route below, and a
+            // global regex advances `lastIndex` on a match, so the next `test()`
+            // would resume mid-string and fail the `^` anchor. The pattern is
+            // anchored and only used with `test()`, so `g` buys nothing anyway.
+            regex: new RegExp('^(' + route.path.replace(regexMatchParams, wildcard) + ')$'),
         }));
         return routes.filter(route => {
             const isOverlapped = (item) => {

package/nest-application-context.js

@@ -104,17 +104,10 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
         if (this.isInitialized) {
             return this;
         }
-        /* eslint-disable-next-line no-async-promise-executor */
-        this.initializationPromise = new Promise(async (resolve, reject) => {
-            try {
-                await this.callInitHook();
-                await this.callBootstrapHook();
-                resolve();
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
+        this.initializationPromise = (async () => {
+            await this.callInitHook();
+            await this.callBootstrapHook();
+        })();
         await this.initializationPromise;
         this.isInitialized = true;
         return this;

package/nest-application.d.ts

@@ -62,4 +62,5 @@ export declare class NestApplication extends NestApplicationContext<NestApplicat
     private getProtocol;
     private registerMiddleware;
     private applyInstanceDecoratorIfRegistered;
+    private applyFunctionDecoratorIfRegistered;
 }

package/nest-application.js

@@ -151,7 +151,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         return this;
     }
     use(...args) {
-        this.httpAdapter.use(...args);
+        this.httpAdapter.use(...this.applyFunctionDecoratorIfRegistered(args));
         return this;
     }
     useBodyParser(...args) {
@@ -329,5 +329,19 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         }
         return instances;
     }
+    applyFunctionDecoratorIfRegistered(args) {
+        if (!this.appOptions.instrument?.instanceDecorator) {
+            return args;
+        }
+        const [firstArg, secondArg] = args;
+        return [
+            (0, shared_utils_1.isFunction)(firstArg)
+                ? this.appOptions.instrument.instanceDecorator(firstArg)
+                : firstArg,
+            (0, shared_utils_1.isFunction)(secondArg)
+                ? this.appOptions.instrument.instanceDecorator(secondArg)
+                : secondArg,
+        ];
+    }
 }
 exports.NestApplication = NestApplication;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "11.1.28",
+  "version": "11.2.0",
   "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.28"
+    "@nestjs/common": "11.2.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -49,5 +49,5 @@
       "optional": true
     }
   },
-  "gitHead": "dfaa376170168d12d9d28bcfe137a9bacce579a3"
+  "gitHead": "f2a7e4b1f57193cbbfe34e988276fc0eaf0b6eb5"
 }

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");
@@ -57,12 +58,27 @@ class RouterResponseController {
         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 +90,11 @@ class RouterResponseController {
                 }
                 closeRequested = true;
                 if (!subscription) {
-                    cleanup();
+                    finalize();
                     return;
                 }
                 settled = true;
-                cleanup();
+                finalize();
                 subscription?.unsubscribe();
                 endStream();
                 response.end();
@@ -92,10 +108,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 +146,7 @@ class RouterResponseController {
                             return;
                         }
                         settled = true;
-                        cleanup();
+                        finalize();
                         endStream();
                         reject(err);
                     },
@@ -139,7 +155,7 @@ class RouterResponseController {
                             return;
                         }
                         settled = true;
-                        cleanup();
+                        finalize();
                         endStream();
                         resolve();
                     },
@@ -167,7 +183,7 @@ class RouterResponseController {
                     return;
                 }
                 settled = true;
-                cleanup();
+                finalize();
                 endStream();
                 reject(err);
             });
@@ -178,5 +194,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/router/sse-stream.d.ts

@@ -22,6 +22,7 @@ export type HeaderStream = WritableHeaderStream & ReadHeaders;
  * - type
  * - id
  * - retry
+ * - comment
  *
  * If constructed with a HTTP Request, it will optimise the socket for streaming.
  * If this stream is piped to an HTTP Response, it will set appropriate headers.

package/router/sse-stream.js

@@ -3,14 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SseStream = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const stream_1 = require("stream");
+function serializeSseLines(value, prefix) {
+    return value
+        .split(/\r\n|\r|\n/)
+        .map(line => `${prefix}${line}\n`)
+        .join('');
+}
 function toDataString(data) {
     if ((0, shared_utils_1.isObject)(data)) {
         return toDataString(JSON.stringify(data));
     }
-    return data
-        .split(/\r\n|\r|\n/)
-        .map(line => `data: ${line}\n`)
-        .join('');
+    return serializeSseLines(data, 'data: ');
+}
+function toCommentString(comment) {
+    return serializeSseLines(comment, ': ');
+}
+function isCommentOnly(message) {
+    return (!(0, shared_utils_1.isNil)(message.comment) &&
+        (0, shared_utils_1.isUndefined)(message.data) &&
+        (0, shared_utils_1.isUndefined)(message.type) &&
+        (0, shared_utils_1.isUndefined)(message.retry));
 }
 /**
  * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
@@ -21,6 +33,7 @@ function toDataString(data) {
  * - type
  * - id
  * - retry
+ * - comment
  *
  * If constructed with a HTTP Request, it will optimise the socket for streaming.
  * If this stream is piped to an HTTP Response, it will set appropriate headers.
@@ -84,12 +97,10 @@ class SseStream extends stream_1.Transform {
         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 += !(0, shared_utils_1.isNil)(message.id) ? `id: ${sanitize(message.id)}\n` : '';
+        data += !(0, shared_utils_1.isNil)(message.retry) ? `retry: ${sanitize(message.retry)}\n` : '';
+        data += !(0, shared_utils_1.isNil)(message.comment) ? toCommentString(message.comment) : '';
+        data += !(0, shared_utils_1.isNil)(message.data) ? toDataString(message.data) : '';
         data += '\n';
         this.push(data);
         callback();
@@ -98,7 +109,7 @@ class SseStream extends stream_1.Transform {
      * Calls `.write` but handles the drain if needed
      */
     writeMessage(message, cb) {
-        if (message.id === undefined || message.id === null) {
+        if ((0, shared_utils_1.isNil)(message.id) && !isCommentOnly(message)) {
             this.lastEventId++;
             message.id = this.lastEventId.toString();
         }

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);