@morojs/moro 1.8.5 → 1.8.7

package/dist/core/http/moro-engine-server.js

@@ -76,6 +76,10 @@ function addCharsetIfNeeded(mimeType) {
 // Files up to this size are sent with a single respond(); larger ones stream
 // through writeHead/write/end with backpressure respected via 'drain'
 const SENDFILE_BUFFER_LIMIT = 1024 * 1024;
+// Shared flat header pair for the json() fast path - passed to respond() when
+// the response has no user-set headers, so no header object or flat array is
+// allocated. The engine only reads it; never mutate.
+const JSON_HEADER_PAIR = ['content-type', 'application/json'];
 /**
  * Prototype-based request object for the engine adapter.
  *
@@ -87,10 +91,10 @@ const SENDFILE_BUFFER_LIMIT = 1024 * 1024;
 export class EngineRequest extends LazyEventEmitter {
     method;
     path;
-    params = {};
     body = null;
     _server;
     _reqId;
+    _params = undefined;
     _url = undefined;
     _queryString = undefined;
     _query = undefined;
@@ -110,11 +114,25 @@ export class EngineRequest extends LazyEventEmitter {
     /** Engine snapshots are stable - nothing to detach. No-op kept for
      *  interface parity with UwsRequest so shared dispatch code can call it. */
     materialize() { }
+    // Lazy like context: dispatch writes params through the setter only for
+    // parametric routes, so a handler that never reads req.params on a static
+    // route pays no allocation.
+    get params() {
+        let p = this._params;
+        if (p === undefined) {
+            p = {};
+            this._params = p;
+        }
+        return p;
+    }
+    set params(value) {
+        this._params = value;
+    }
     _rawQueryString() {
         let qs = this._queryString;
         if (qs === undefined) {
             // Safe no-op (undefined) after the response terminates - coerce to ''
-            qs = this._server._engine.getQuery(this._reqId) ?? '';
+            qs = this._server._getQuery(this._reqId) ?? '';
             this._queryString = qs;
         }
         return qs;
@@ -151,7 +169,7 @@ export class EngineRequest extends LazyEventEmitter {
             // Duplicate header lines are joined like Node's IncomingMessage ('; '
             // for cookie, ', ' otherwise) - last-wins would let a client hide
             // earlier X-Forwarded-For entries from IP-based middleware.
-            const flat = this._server._engine.getHeaders(this._reqId);
+            const flat = this._server._getHeaders(this._reqId);
             if (flat) {
                 for (let i = 0; i + 1 < flat.length; i += 2) {
                     const key = flat[i];
@@ -233,7 +251,7 @@ export class EngineRequest extends LazyEventEmitter {
     get ip() {
         let ip = this._ip;
         if (ip === undefined) {
-            ip = this._server._engine.getRemoteAddress(this._reqId) ?? '';
+            ip = this._server._getRemoteAddress(this._reqId) ?? '';
             this._ip = ip;
         }
         return ip;
@@ -393,15 +411,18 @@ export class EngineRequest extends LazyEventEmitter {
 export class EngineResponse extends LazyEventEmitter {
     headersSent = false;
     statusCode = 200;
-    responseHeaders = {};
-    locals = {};
     // The EngineRequest wrapper, linked by the server so lifecycle events reach
     // req.on('close') listeners (SSE cleanup, monitors)
     _moroReq = null;
+    /** @internal true while this response is in the server's inflight map */
+    _registered = false;
     _server;
-    _engine;
     _reqId;
     _logger;
+    // Lazy: json/send/end on a response with no user-set headers never
+    // materialize a header object (see _headersFlat / the json fast path)
+    _responseHeaders = undefined;
+    _locals = undefined;
     // Terminal-write latch: headersSent means "head flushed" (true mid-stream
     // after writeHead/write), _ended means the body is complete
     _ended = false;
@@ -409,10 +430,31 @@ export class EngineResponse extends LazyEventEmitter {
     constructor(server, reqId, logger) {
         super();
         this._server = server;
-        this._engine = server._engine;
         this._reqId = reqId;
         this._logger = logger;
     }
+    get responseHeaders() {
+        let h = this._responseHeaders;
+        if (h === undefined) {
+            h = {};
+            this._responseHeaders = h;
+        }
+        return h;
+    }
+    set responseHeaders(value) {
+        this._responseHeaders = value;
+    }
+    get locals() {
+        let l = this._locals;
+        if (l === undefined) {
+            l = {};
+            this._locals = l;
+        }
+        return l;
+    }
+    set locals(value) {
+        this._locals = value;
+    }
     get writableEnded() {
         return this._ended;
     }
@@ -430,7 +472,12 @@ export class EngineResponse extends LazyEventEmitter {
     // Also releases the reqId from the server's in-flight map.
     _emitDone() {
         this._ended = true;
-        this._server._complete(this._reqId);
+        // Sync responses end before onRequest's registration window, so they were
+        // never in the inflight map - skip the wasted delete on a missing key
+        if (this._registered) {
+            this._registered = false;
+            this._server._complete(this._reqId);
+        }
         if (this._events) {
             this.emit('finish');
             this.emit('close');
@@ -447,6 +494,7 @@ export class EngineResponse extends LazyEventEmitter {
             return;
         this._ended = true;
         this._aborted = true;
+        this._registered = false; // onAborted already dropped the map entry
         if (this._events)
             this.emit('close');
         const req = this._moroReq;
@@ -464,7 +512,9 @@ export class EngineResponse extends LazyEventEmitter {
     // actually set. Multi-value headers (set-cookie) become separate pairs so
     // each goes out as its own header line.
     _headersFlat() {
-        const headers = this.responseHeaders;
+        const headers = this._responseHeaders;
+        if (headers === undefined)
+            return null;
         let flat = null;
         // Performance: for...in is the fastest way to iterate response headers
         for (const key in headers) {
@@ -492,13 +542,15 @@ export class EngineResponse extends LazyEventEmitter {
         return this;
     }
     getHeader(name) {
-        const lowerName = name.toLowerCase();
-        return this.responseHeaders[lowerName];
+        const headers = this._responseHeaders;
+        return headers === undefined ? undefined : headers[name.toLowerCase()];
     }
     removeHeader(name) {
-        const lowerName = name.toLowerCase();
-        if (lowerName in this.responseHeaders) {
-            delete this.responseHeaders[lowerName];
+        const headers = this._responseHeaders;
+        if (headers !== undefined) {
+            const lowerName = name.toLowerCase();
+            if (lowerName in headers)
+                delete headers[lowerName];
         }
         return this;
     }
@@ -556,10 +608,19 @@ export class EngineResponse extends LazyEventEmitter {
         else {
             body = JSON.stringify(data);
         }
-        if (!('content-type' in this.responseHeaders)) {
-            this.responseHeaders['content-type'] = 'application/json';
-        }
         try {
+            const rh = this._responseHeaders;
+            if (rh === undefined && !this._server._compression.enabled) {
+                // Hot path: no user-set headers, no compression - one native call
+                // with the shared content-type pair; zero per-response header work
+                this._server._respond(this._reqId, this.statusCode, JSON_HEADER_PAIR, body);
+                this.headersSent = true;
+                this._emitDone();
+                return;
+            }
+            if (rh === undefined || !('content-type' in rh)) {
+                this.responseHeaders['content-type'] = 'application/json';
+            }
             this._respondMaybeCompressed(body, 'application/json');
         }
         catch (err) {
@@ -577,29 +638,30 @@ export class EngineResponse extends LazyEventEmitter {
         // work (byteLength scans the string; header reads allocate nothing but
         // still cost). The default config must pay zero for this feature.
         if (!s.enabled) {
-            this._engine.respond(this._reqId, this.statusCode, this._headersFlat(), body);
+            this._server._respond(this._reqId, this.statusCode, this._headersFlat(), body);
             this.headersSent = true;
             this._emitDone();
             return;
         }
         const bytes = typeof body === 'string' ? Buffer.byteLength(body) : body.length;
-        const alreadyEncoded = 'content-encoding' in this.responseHeaders;
-        const ctHeader = this.responseHeaders['content-type'];
+        const rh = this._responseHeaders;
+        const alreadyEncoded = rh !== undefined && 'content-encoding' in rh;
+        const ctHeader = rh?.['content-type'];
         const ct = contentType ?? (Array.isArray(ctHeader) ? ctHeader[0] : ctHeader);
         if (alreadyEncoded ||
             bytes < s.threshold ||
             !isCompressible(ct) ||
             this.statusCode === 204 ||
             this.statusCode === 304) {
-            this._engine.respond(this._reqId, this.statusCode, this._headersFlat(), body);
+            this._server._respond(this._reqId, this.statusCode, this._headersFlat(), body);
             this.headersSent = true;
             this._emitDone();
             return;
         }
-        const accept = this._engine.getHeader(this._reqId, 'accept-encoding');
+        const accept = this._server._getHeader(this._reqId, 'accept-encoding');
         const encoding = negotiateEncoding(accept, s.encodings);
         if (!encoding) {
-            this._engine.respond(this._reqId, this.statusCode, this._headersFlat(), body);
+            this._server._respond(this._reqId, this.statusCode, this._headersFlat(), body);
             this.headersSent = true;
             this._emitDone();
             return;
@@ -608,12 +670,12 @@ export class EngineResponse extends LazyEventEmitter {
         // raced the await - the reqId would be invalid).
         void compressBuffer(body, encoding, s.level)
             .then(compressed => {
-            if (this._ended || this._engine.isAborted(this._reqId))
+            if (this._ended || this._server._isAborted(this._reqId))
                 return;
             this.responseHeaders['content-encoding'] = encoding;
             const vary = this.responseHeaders['vary'];
             this.responseHeaders['vary'] = vary ? `${vary}, Accept-Encoding` : 'Accept-Encoding';
-            this._engine.respond(this._reqId, this.statusCode, this._headersFlat(), compressed);
+            this._server._respond(this._reqId, this.statusCode, this._headersFlat(), compressed);
             this.headersSent = true;
             this._emitDone();
         })
@@ -626,7 +688,7 @@ export class EngineResponse extends LazyEventEmitter {
         this._logger.error(`${context}: ${err instanceof Error ? err.message : String(err)}`, 'ResponseError');
         if (!this._ended) {
             try {
-                this._engine.respond(this._reqId, 500, null, '{"success":false,"error":"Internal server error"}');
+                this._server._respond(this._reqId, 500, null, '{"success":false,"error":"Internal server error"}');
                 this.headersSent = true;
             }
             catch {
@@ -680,7 +742,7 @@ export class EngineResponse extends LazyEventEmitter {
             }
         }
         try {
-            this._engine.writeHead(this._reqId, statusCode, this._headersFlat());
+            this._server._writeHead(this._reqId, statusCode, this._headersFlat());
             this.headersSent = true;
         }
         catch {
@@ -701,10 +763,10 @@ export class EngineResponse extends LazyEventEmitter {
         let ok = true;
         try {
             if (!this.headersSent) {
-                this._engine.writeHead(this._reqId, this.statusCode, this._headersFlat());
+                this._server._writeHead(this._reqId, this.statusCode, this._headersFlat());
                 this.headersSent = true;
             }
-            ok = this._engine.write(this._reqId, chunk) !== false;
+            ok = this._server._write(this._reqId, chunk) !== false;
         }
         catch {
             this._logger.error('Failed to write response chunk', 'ResponseError');
@@ -729,11 +791,11 @@ export class EngineResponse extends LazyEventEmitter {
         try {
             if (!this.headersSent) {
                 // Terminal single-shot: status + headers + body in one native call
-                this._engine.respond(this._reqId, this.statusCode, this._headersFlat(), data !== undefined && data !== null ? data : null);
+                this._server._respond(this._reqId, this.statusCode, this._headersFlat(), data !== undefined && data !== null ? data : null);
                 this.headersSent = true;
             }
             else {
-                this._engine.end(this._reqId, data !== undefined && data !== null ? data : undefined);
+                this._server._end(this._reqId, data !== undefined && data !== null ? data : undefined);
             }
             this._emitDone();
             if (typeof callback === 'function')
@@ -753,7 +815,7 @@ export class EngineResponse extends LazyEventEmitter {
         this.statusCode = redirectCode;
         this.setHeader('location', url.replace(/[\r\n]/g, ''));
         try {
-            this._engine.respond(this._reqId, redirectCode, this._headersFlat(), null);
+            this._server._respond(this._reqId, redirectCode, this._headersFlat(), null);
             this.headersSent = true;
             this._emitDone();
         }
@@ -1223,6 +1285,22 @@ export class EngineResponse extends LazyEventEmitter {
 export class MoroEngineServer {
     /** @internal read by EngineRequest/EngineResponse for lazy fetchers */
     _engine;
+    // Hot-path native functions hoisted off the loader's module Proxy: every
+    // property access on the engine module runs its `get` trap (a Set probe +
+    // binding load) that V8 cannot inline-cache. Hoisted once here, each
+    // per-request native call becomes a plain monomorphic field load. The
+    // functions are plain N-API exports with no `this` dependence.
+    /** @internal */ _respond;
+    /** @internal */ _writeHead;
+    /** @internal */ _write;
+    /** @internal */ _end;
+    /** @internal */ _isAborted;
+    /** @internal */ _getQuery;
+    /** @internal */ _getHeaders;
+    /** @internal */ _getHeader;
+    /** @internal */ _getBody;
+    /** @internal */ _getRemoteAddress;
+    /** @internal */ _getMethod;
     /** @internal read by EngineRequest#protocol/socket.encrypted - true when the
      *  engine is terminating TLS for this server (engine >= 1.2.0 + ssl passed) */
     isSsl = false;
@@ -1308,6 +1386,17 @@ export class MoroEngineServer {
                 'use UWebSocketsHttpServer for uWS-style modules');
         }
         this._engine = surface;
+        this._respond = surface.respond;
+        this._writeHead = surface.writeHead;
+        this._write = surface.write;
+        this._end = surface.end;
+        this._isAborted = surface.isAborted;
+        this._getQuery = surface.getQuery;
+        this._getHeaders = surface.getHeaders;
+        this._getHeader = surface.getHeader;
+        this._getBody = surface.getBody;
+        this._getRemoteAddress = surface.getRemoteAddress;
+        this._getMethod = surface.getMethod;
         // TLS: pass it through when the engine supports it; otherwise keep the
         // (now capability-gated) warning so a proxy/node fallback is clear.
         if (this._ssl && this._capabilities?.tls) {
@@ -1570,13 +1659,13 @@ export class MoroEngineServer {
         // request, hand the connection to the engine's native WS path. The engine
         // sends the 101 handshake and drives onWsOpen/Message/Close.
         if (this._wsBridge) {
-            const upgrade = this._engine.getHeader(reqId, 'upgrade');
+            const upgrade = this._getHeader(reqId, 'upgrade');
             if (upgrade && upgrade.toLowerCase() === 'websocket') {
                 // Snapshot handshake data now - the upgrade invalidates the reqId,
                 // after which these fetchers return empty values.
-                const ip = this._engine.getRemoteAddress(reqId) || '';
+                const ip = this._getRemoteAddress(reqId) || '';
                 const headers = {};
-                const flat = this._engine.getHeaders(reqId);
+                const flat = this._getHeaders(reqId);
                 if (flat) {
                     // Join duplicates exactly like the EngineRequest.headers getter -
                     // last-wins would let a client send two X-Forwarded-For lines and
@@ -1593,7 +1682,7 @@ export class MoroEngineServer {
                 }
                 // Capture the query string too (invalidated by the upgrade like the
                 // rest), so handlers can read handshake query params (e.g. orgId).
-                const query = this._engine.getQuery(reqId) || '';
+                const query = this._getQuery(reqId) || '';
                 this._pendingWsInfo = { ip, headers, query };
                 const wsId = this._engine.upgradeToWebSocket(reqId);
                 this._pendingWsInfo = undefined;
@@ -1604,7 +1693,7 @@ export class MoroEngineServer {
         }
         // methodIdx 7 (OTHER) needs the extra crossing; the seven common methods
         // resolve from the static table
-        const method = methodIdx === 7 ? this._engine.getMethod(reqId) || 'OTHER' : METHODS[methodIdx];
+        const method = (methodIdx === 7 ? this._getMethod(reqId) || 'OTHER' : METHODS[methodIdx]);
         const httpReq = new EngineRequest(this, reqId, method, path);
         const httpRes = new EngineResponse(this, reqId, this.logger);
         httpRes._moroReq = httpReq;
@@ -1619,7 +1708,46 @@ export class MoroEngineServer {
                 httpRes[key] = this.responseDecorations[key];
             }
         }
-        void this.handleRequest(httpReq, httpRes);
+        this.requestCounter++;
+        // SYNC FAST PATH (parity with MoroHttpServer's handleRequest split): with
+        // no body to parse, no request/response hooks and no global middleware,
+        // the router dispatch runs synchronously in this frame - the async
+        // handleRequest below would allocate a promise + async context per
+        // request only to reach zero awaits. Only the framework's own frame is
+        // de-asynced: an async route handler still returns its promise through
+        // the router and is driven to completion here.
+        const hookManager = this.hookManager;
+        const hooksActive = hookManager &&
+            (hookManager.hasHooks === undefined ||
+                hookManager.hasHooks('request') ||
+                hookManager.hasHooks('response'));
+        const needsBody = method.charCodeAt(0) === 80 && // 'P' char code
+            (method === 'POST' || method === 'PUT' || method === 'PATCH');
+        if (!needsBody && !hooksActive && this.globalMiddleware.length === 0 && this.routerHandler) {
+            let handled = true;
+            try {
+                handled = this.routerHandler(httpReq, httpRes);
+            }
+            catch (error) {
+                // Error path owns the response from here (handled stays true)
+                void this.handleDispatchError(error, httpReq, httpRes);
+            }
+            if (handled !== true) {
+                if (handled && typeof handled.then === 'function') {
+                    handled.then(ok => {
+                        if (!ok)
+                            void this.finishUnrouted(httpReq, httpRes);
+                    }, error => void this.handleDispatchError(error, httpReq, httpRes));
+                }
+                else {
+                    // Sync miss from the router - direct-route fallback, then 404
+                    void this.finishUnrouted(httpReq, httpRes);
+                }
+            }
+        }
+        else {
+            void this.handleRequest(httpReq, httpRes);
+        }
         // Register for onAborted/onWritable routing only when the response is
         // still in flight after the synchronous dispatch window. Sync handlers
         // have already ended by here, and the engine never fires those callbacks
@@ -1627,8 +1755,10 @@ export class MoroEngineServer {
         // long-lived Map's old-space backing store, and entries alive at a
         // scavenge promote the whole request/response graph (at ~570k pipelined
         // req/s that meant full GCs every ~400ms and a ~150 MB heap vs ~30 MB).
-        if (!httpRes.writableEnded)
+        if (!httpRes.writableEnded) {
+            httpRes._registered = true;
             this.inflight.set(reqId, httpRes);
+        }
     }
     onAborted(reqId) {
         const httpRes = this.inflight.get(reqId);
@@ -1642,8 +1772,23 @@ export class MoroEngineServer {
         if (httpRes)
             httpRes._handleWritable();
     }
+    // Router-miss continuation shared by the sync fast path: direct-route
+    // fallback, then 404 - with the same error shaping as handleRequest.
+    async finishUnrouted(httpReq, httpRes) {
+        try {
+            if (await this.dispatchDirectRoute(httpReq, httpRes))
+                return;
+            if (!httpRes.headersSent && !httpRes.writableEnded) {
+                httpRes.statusCode = 404;
+                httpRes.setHeader('Content-Type', 'application/json');
+                httpRes.end('{"success":false,"error":"Not found"}');
+            }
+        }
+        catch (error) {
+            await this.handleDispatchError(error, httpReq, httpRes);
+        }
+    }
     async handleRequest(httpReq, httpRes) {
-        this.requestCounter++;
         try {
             const method = httpReq.method;
             // Parse body only for body methods (all start with 'P'). The engine
@@ -1703,6 +1848,13 @@ export class MoroEngineServer {
             }
         }
         catch (error) {
+            await this.handleDispatchError(error, httpReq, httpRes);
+        }
+    }
+    // Error shaping shared by the async pipeline and the sync fast path:
+    // 413/400 client responses, error hooks, the app's error handler, then 500.
+    async handleDispatchError(error, httpReq, httpRes) {
+        {
             // Payload-too-large: respond 413 rather than a generic 500
             if (error?.statusCode === 413 && !httpRes.writableEnded && !httpRes.headersSent) {
                 httpRes.statusCode = 413;
@@ -1753,7 +1905,7 @@ export class MoroEngineServer {
     // semantics to the Node and uWS servers' readBody). getBody returns a STABLE
     // ArrayBuffer copy, so Buffer.from() views it with no aliasing hazard.
     parseBody(httpReq) {
-        const raw = this._engine.getBody(httpReq._reqId);
+        const raw = this._getBody(httpReq._reqId);
         if (!raw || raw.byteLength === 0)
             return;
         const contentType = httpReq.headers['content-type'] || '';