@morojs/moro 1.8.8 → 1.8.9

package/dist/core/http/uws-http-server.d.ts

@@ -127,6 +127,7 @@ export declare class UWebSocketsHttpServer {
     private createMoroResponse;
     private readBody;
     private executeMiddleware;
+    private dispatchMiddleware;
     use(middleware: Middleware): void;
     setRequestTracking(enabled: boolean): void;
     setHookManager(hookManager: any): void;

package/dist/core/http/uws-http-server.js

@@ -673,10 +673,14 @@ export class UWebSocketsHttpServer {
             // rejection). Registration of the response hooks above still stands.
             if (httpRes.headersSent)
                 return;
-            // Execute global middleware chain
+            // Execute global middleware chain. executeMiddleware returns undefined
+            // when the whole chain completed synchronously, so a sync chain costs
+            // zero promise allocations.
             if (this.globalMiddleware.length > 0) {
                 httpReq.materialize();
-                await this.executeMiddleware(this.globalMiddleware, httpReq, httpRes);
+                const mwResult = this.executeMiddleware(this.globalMiddleware, httpReq, httpRes);
+                if (mwResult)
+                    await mwResult;
                 if (httpRes.headersSent)
                     return;
             }
@@ -1586,27 +1590,105 @@ export class UWebSocketsHttpServer {
             }
         });
     }
-    async executeMiddleware(middleware, req, res) {
-        for (const mw of middleware) {
+    // Middleware execution with Express-compatible error propagation - identical
+    // semantics to MoroHttpServer/MoroEngineServer so a route behaves the same on
+    // every backend. Supports 3-arg (req, res, next), 4-arg error middleware
+    // (err, req, res, next), and next(err) to skip forward to the next error
+    // middleware. Previously this adapter called EVERY middleware with three
+    // arguments, so registering a 4-arg error handler passed `req` as `err` and
+    // broke every ordinary request; with no 4-arg middleware registered the
+    // behaviour here is unchanged (next(err) aborts the chain and propagates to
+    // the request handler's catch).
+    //
+    // Sync-aware dispatch: middleware that calls next() synchronously (or throws
+    // synchronously) advances the chain in a plain loop with ZERO promise
+    // allocations; a promise is only created when a middleware actually completes
+    // asynchronously. Returns undefined when the whole chain ran synchronously so
+    // the caller can skip its await.
+    executeMiddleware(middleware, req, res) {
+        return this.dispatchMiddleware(middleware, req, res, 0, undefined);
+    }
+    dispatchMiddleware(middleware, req, res, startIndex, initialError) {
+        const len = middleware.length;
+        let activeError = initialError;
+        let i = startIndex;
+        while (i < len) {
             if (res.headersSent)
-                break;
-            await new Promise((resolve, reject) => {
-                try {
-                    const result = mw(req, res, (err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                    // Handle async middleware
-                    if (result && typeof result.then === 'function') {
-                        result.then(() => resolve()).catch(reject);
-                    }
+                return;
+            const mw = middleware[i];
+            i++;
+            const isErrorHandler = mw.length >= 4;
+            // Non-error middleware is skipped while an error is active; error middleware
+            // is skipped while no error is active. Matches Express semantics.
+            if (activeError !== undefined && !isErrorHandler)
+                continue;
+            if (activeError === undefined && isErrorHandler)
+                continue;
+            let settled = false;
+            let settledError = undefined;
+            let asyncResolve;
+            const next = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                settledError = err;
+                if (asyncResolve)
+                    asyncResolve(err);
+            };
+            let result;
+            try {
+                result = isErrorHandler ? mw(activeError, req, res, next) : mw(req, res, next);
+            }
+            catch (err) {
+                if (!settled) {
+                    settled = true;
+                    settledError = err;
                 }
-                catch (error) {
-                    reject(error);
+            }
+            const isThenable = result && typeof result.then === 'function';
+            if (settled) {
+                // Completed synchronously (next() called sync, or threw sync). A still
+                // pending returned promise no longer gates the chain once next() has
+                // been called; swallow late rejections so they never go unhandled.
+                if (isThenable) {
+                    result.then(undefined, () => { });
                 }
-            });
+                activeError = settledError;
+                continue;
+            }
+            if (!isThenable && res.headersSent) {
+                // Terminal middleware (Express style): it answered the request and
+                // deliberately never calls next(). The chain is finished - skip
+                // allocating a promise that nothing would ever settle.
+                return;
+            }
+            if (!isThenable) {
+                // Sync-looking middleware that neither called next() nor returned a
+                // promise: it will call next() later (e.g. from an event callback).
+                // Fall back to a promise for the remainder of the chain.
+                const resumeIndex = i;
+                return new Promise(resolve => {
+                    asyncResolve = resolve;
+                }).then(err => this.dispatchMiddleware(middleware, req, res, resumeIndex, err));
+            }
+            // Async middleware: completion is next() OR promise settle, whichever
+            // happens first (same semantics as the previous implementation).
+            const resumeIndex = i;
+            return new Promise(resolve => {
+                asyncResolve = resolve;
+                result.then(() => {
+                    if (!settled)
+                        next();
+                }, (err) => {
+                    if (!settled)
+                        next(err);
+                });
+            }).then(err => this.dispatchMiddleware(middleware, req, res, resumeIndex, err));
+        }
+        // If an error is still unhandled after the chain, re-throw so the request
+        // handler's catch can invoke the registered errorHandler / default 500.
+        if (activeError !== undefined) {
+            throw activeError;
         }
     }
     // Public API - matches MoroHttpServer interface