@morojs/moro 1.8.12 → 1.8.13

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

@@ -20,6 +20,7 @@ import { createFrameworkLogger } from '../logger/index.js';
 import { loadNativeEngine, getNativeEngineLoadErrors, } from '../utilities/package-utils.js';
 import { parseMultipart as parseMultipartBuffer, } from './utils/multipart-parser.js';
 import { resolveCompressionSettings, compressBuffer, isCompressible, negotiateEncoding, } from './utils/compression.js';
+import { bodyIsText } from './utils/body-type.js';
 import { LazyEventEmitter } from './utils/lazy-event-emitter.js';
 import { parseRawQueryString as parseUwsQueryString } from './utils/query-parser.js';
 import { PathMatcher } from '../routing/path-matcher.js';
@@ -148,6 +149,12 @@ export class EngineRequest extends LazyEventEmitter {
     method;
     path;
     body = null;
+    /** Undecoded request body bytes (parseBody keeps the same Buffer it parsed) */
+    _rawBody = undefined;
+    /** The request body exactly as received, before any parsing; null when empty. */
+    get rawBody() {
+        return this._rawBody ?? null;
+    }
     _server;
     _reqId;
     _params = undefined;
@@ -1468,6 +1475,13 @@ export class MoroEngineServer {
     /** @internal */ _setStaticRoute;
     _staticOn = false;
     staticRoutes = [];
+    // Engine-answered parameter routes (engine >= 1.1.9, capabilities.paramRoutes):
+    // one variable path segment between prefix and suffix, echoed as the body,
+    // sent without calling into JS. Same guard and same re-apply story as the
+    // static routes above.
+    /** @internal */ _setParamRoute;
+    _paramOn = false;
+    paramRoutes = [];
     // Batched pipelined dispatch (engine >= 1.1.6, capabilities.batchDispatch):
     // the engine parses complete pipelined requests ahead and delivers them in
     // one onRequestBatch(count) call; the descriptors/control/paths buffers are
@@ -1593,6 +1607,10 @@ export class MoroEngineServer {
             this._setStaticRoute = surface.setStaticRoute;
             this._staticOn = true;
         }
+        if (this._capabilities?.paramRoutes === true && typeof surface.setParamRoute === 'function') {
+            this._setParamRoute = surface.setParamRoute;
+            this._paramOn = true;
+        }
         if (this._capabilities?.batchDispatch === true &&
             typeof surface.getBatchBuffers === 'function' &&
             typeof surface.getPath === 'function') {
@@ -1619,7 +1637,11 @@ export class MoroEngineServer {
         this.handle = Object.defineProperties({
             engine: '@morojs/engine',
             address: () => this.isListening
-                ? { address: this.host || '0.0.0.0', family: 'IPv4', port: this.port || 0 }
+                ? {
+                    address: this.host || '::',
+                    family: (this.host || '::').includes(':') ? 'IPv6' : 'IPv4',
+                    port: this.port || 0,
+                }
                 : null,
             close: (cb) => {
                 this.close(cb);
@@ -1709,13 +1731,58 @@ export class MoroEngineServer {
         }
     }
     // listen() after close() registers a fresh native server; give it every
-    // static route the old one had.
+    // static and parameter route the old one had.
     _reapplyStaticRoutes() {
         const fn = this._setStaticRoute;
-        if (fn === undefined)
-            return;
-        for (const r of this.staticRoutes) {
-            fn(this.serverId, r.methodIdx, r.path, r.status, r.headersFlat, r.body);
+        if (fn !== undefined) {
+            for (const r of this.staticRoutes) {
+                fn(this.serverId, r.methodIdx, r.path, r.status, r.headersFlat, r.body);
+            }
+        }
+        const pfn = this._setParamRoute;
+        if (pfn !== undefined) {
+            for (const r of this.paramRoutes) {
+                pfn(this.serverId, r.methodIdx, r.prefix, r.suffix, r.status, r.headersFlat);
+            }
+        }
+    }
+    /** Whether this engine build answers parameter routes itself. */
+    get paramRoutesEnabled() {
+        return this._paramOn;
+    }
+    /**
+     * Register a route with one variable path segment, between `prefix` and
+     * `suffix`, that the engine answers itself with that segment as the body:
+     * "/user/" + "" for `/user/:id`. The segment goes out undecoded, as it is
+     * on the wire. Returns false when this engine cannot take it (no
+     * capability, compression on, or an unindexed method), so the caller keeps
+     * its JS handler. Registering the same (method, prefix, suffix) again
+     * replaces the earlier reply.
+     */
+    setParamRoute(method, prefix, suffix, status = 200, headers) {
+        const fn = this._setParamRoute;
+        if (!this._paramOn || fn === undefined)
+            return false;
+        if (this._compression.enabled)
+            return false;
+        const methodIdx = METHODS.indexOf(method.toUpperCase());
+        if (methodIdx < 0 || methodIdx >= STATIC_ROUTE_METHODS)
+            return false;
+        const headersFlat = flattenHeaders(headers);
+        const entry = { methodIdx, prefix, suffix, status, headersFlat };
+        const at = this.paramRoutes.findIndex(r => r.methodIdx === methodIdx && r.prefix === prefix && r.suffix === suffix);
+        if (at === -1)
+            this.paramRoutes.push(entry);
+        else
+            this.paramRoutes[at] = entry;
+        fn(this.serverId, methodIdx, prefix, suffix, status, headersFlat);
+        return true;
+    }
+    /** Drop every engine-answered parameter route; the JS routes are untouched. */
+    clearParamRoutes() {
+        this.paramRoutes.length = 0;
+        if (this._paramOn && typeof this._engine.clearParamRoutes === 'function') {
+            this._engine.clearParamRoutes(this.serverId);
         }
     }
     // Register callbacks + limits with the native engine, returning the new
@@ -2279,6 +2346,9 @@ export class MoroEngineServer {
             throw error;
         }
         const buffer = Buffer.from(raw);
+        // getBody() handed us a stable copy, so the raw bytes cost nothing to keep
+        // (webhook signature checks need them even for JSON bodies)
+        httpReq._rawBody = buffer;
         try {
             if (contentType.includes('application/json')) {
                 httpReq.body = JSON.parse(buffer.toString('utf-8'));
@@ -2297,7 +2367,9 @@ export class MoroEngineServer {
                 httpReq.body = parseMultipartBuffer(buffer, contentType, this.multipartLimits);
             }
             else {
-                httpReq.body = buffer.toString('utf-8');
+                // Text decodes to a string; binary (octet-stream, images, protobuf,
+                // ...) stays a Buffer - decoding it would corrupt it irreversibly.
+                httpReq.body = bodyIsText(contentType) ? buffer.toString('utf-8') : buffer;
             }
         }
         catch (parseError) {
@@ -2447,7 +2519,10 @@ export class MoroEngineServer {
             this.logger.warn('Server is already listening', 'Listen');
             return;
         }
-        const host = typeof hostOrCallback === 'string' ? hostOrCallback : '0.0.0.0';
+        // No host = every interface, dual-stack, exactly like Node's
+        // server.listen(port): a client that resolves `localhost` to ::1 first
+        // must not be refused. Hosts without IPv6 fall back to IPv4-any below.
+        const host = typeof hostOrCallback === 'string' ? hostOrCallback : '::';
         const cb = typeof hostOrCallback === 'function' ? hostOrCallback : callback;
         try {
             // listen() after close(): the old native server's handles are torn
@@ -2461,11 +2536,23 @@ export class MoroEngineServer {
             }
             // Synchronous bind; throws on bind errors, returns the actual port
             // (meaningful when port 0 asks for an ephemeral one)
-            const actualPort = this._engine.listen(this.serverId, host, port);
+            let boundHost = host;
+            let actualPort;
+            try {
+                actualPort = this._engine.listen(this.serverId, host, port);
+            }
+            catch (error) {
+                const code = error?.code;
+                if (host !== '::' || (code !== 'EAFNOSUPPORT' && code !== 'EADDRNOTAVAIL'))
+                    throw error;
+                // IPv6 not configured on this host - IPv4-any is what Node does too
+                boundHost = '0.0.0.0';
+                actualPort = this._engine.listen(this.serverId, boundHost, port);
+            }
             this.port = typeof actualPort === 'number' ? actualPort : port;
-            this.host = host;
+            this.host = boundHost;
             this.isListening = true;
-            this.logger.info(`Moro engine HTTP server listening on ${host}:${this.port}`, 'Listen');
+            this.logger.info(`Moro engine HTTP server listening on ${boundHost}:${this.port}`, 'Listen');
             if (cb)
                 cb();
         }
@@ -2539,6 +2626,23 @@ export class MoroEngineServer {
                 callback(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * Replace the TLS certificate/key for every handshake from now on
+     * (engine capabilities.tlsReload). Established connections keep the context
+     * they handshaked with. Validated by the engine before the swap: a bad
+     * config throws and the current certificate keeps serving.
+     */
+    updateSsl(ssl) {
+        if (!this._ssl || !this.isSsl) {
+            throw new Error('updateSsl: this server was not started with TLS (server.ssl)');
+        }
+        if (!this._capabilities?.tlsReload || typeof this._engine.updateSsl !== 'function') {
+            throw new Error('TLS reload needs @morojs/engine with capabilities.tlsReload (engine >= 1.1.8)');
+        }
+        this._engine.updateSsl(this.serverId, ssl);
+        // A later close() -> listen() cycle re-registers with the new material
+        this._ssl = ssl;
+    }
     getServer() {
         // Stable observability handle (listening/address) - there is no app object
         return this.handle;