@morojs/moro 1.8.0 → 1.8.1

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

@@ -53,6 +53,8 @@ function parseCookieHeader(cookieHeader) {
     const cookiePartsLen = cookieParts.length;
     for (let i = 0; i < cookiePartsLen; i++) {
         const cookie = cookieParts[i];
+        if (cookie === undefined)
+            continue;
         const equalIndex = cookie.indexOf('=');
         if (equalIndex > 0) {
             const name = cookie.substring(0, equalIndex).trim();
@@ -183,7 +185,7 @@ export class MoroIncomingMessage extends IncomingMessage {
         if (v === undefined) {
             const forwardedProto = this.headers['x-forwarded-proto'];
             v = forwardedProto
-                ? forwardedProto.split(',')[0].trim()
+                ? (forwardedProto.split(',')[0] ?? '').trim()
                 : this.socket?.encrypted
                     ? 'https'
                     : 'http';
@@ -263,7 +265,7 @@ export class MoroIncomingMessage extends IncomingMessage {
         const ct = (this.headers['content-type'] || '');
         if (!ct)
             return false;
-        const mime = ct.split(';')[0].trim().toLowerCase();
+        const mime = (ct.split(';')[0] ?? '').trim().toLowerCase();
         const t = type.toLowerCase();
         if (t.indexOf('/') === -1) {
             // e.g. 'json' → match */json or +json suffix
@@ -281,7 +283,7 @@ export class MoroIncomingMessage extends IncomingMessage {
         const wanted = Array.isArray(types) ? types : [types];
         if (accept === '*/*' || accept === '')
             return wanted[0] || false;
-        const acceptTypes = accept.split(',').map(s => s.split(';')[0].trim().toLowerCase());
+        const acceptTypes = accept.split(',').map(s => (s.split(';')[0] ?? '').trim().toLowerCase());
         for (const w of wanted) {
             const wl = w.toLowerCase();
             const wMime = wl.indexOf('/') === -1 ? `application/${wl}` : wl;
@@ -308,7 +310,7 @@ export class MoroIncomingMessage extends IncomingMessage {
             .split(',')
             .map(s => {
             const parts = s.trim().split(';');
-            const tag = parts[0].toLowerCase();
+            const tag = (parts[0] ?? '').toLowerCase();
             const qPart = parts.find(p => p.trim().startsWith('q='));
             const q = qPart ? parseFloat(qPart.trim().slice(2)) : 1;
             return { tag, q: isNaN(q) ? 0 : q };
@@ -696,7 +698,9 @@ export class MoroServerResponse extends ServerResponse {
             return this;
         }
         for (const key in headers) {
-            this.setHeader(key, headers[key]);
+            const value = headers[key];
+            if (value !== undefined)
+                this.setHeader(key, value);
         }
         return this;
     }
@@ -792,10 +796,15 @@ export class MoroServerResponse extends ServerResponse {
             // Set Content-Type from extension if not already set
             if (!this.getHeader('Content-Type')) {
                 // fire-and-forget mime lookup; not awaited to keep signature chainable
-                this._server.getMimeType(filename.substring(filename.lastIndexOf('.'))).then(mime => {
+                void this._server
+                    .getMimeType(filename.substring(filename.lastIndexOf('.')))
+                    .then(mime => {
                     if (!this.getHeader('Content-Type') && !this.headersSent) {
                         this.setHeader('Content-Type', mime);
                     }
+                })
+                    .catch(() => {
+                    // best-effort content-type inference
                 });
             }
         }
@@ -956,7 +965,8 @@ export class MoroHttpServer {
         }
         if (limits?.maxHeaders)
             this.server.maxHeadersCount = limits.maxHeaders;
-        this.listenBacklog = limits?.backlog;
+        if (limits?.backlog !== undefined)
+            this.listenBacklog = limits.backlog;
     }
     // Direct router dispatch - called after global middleware, before the legacy
     // route table. Returning true (or a promise of true) means the request was handled.
@@ -1235,7 +1245,11 @@ export class MoroHttpServer {
             const paramNames = route.paramNames;
             const paramNamesLen = paramNames.length;
             for (let i = 0; i < paramNamesLen; i++) {
-                params[paramNames[i]] = matches[i + 1];
+                const paramName = paramNames[i];
+                const value = matches[i + 1];
+                if (paramName !== undefined && value !== undefined) {
+                    params[paramName] = value;
+                }
             }
             httpReq.params = params;
         }
@@ -1469,12 +1483,12 @@ export class MoroHttpServer {
             error.received = contentLength;
             return Promise.reject(error);
         }
-        // For very large payloads, return a streaming interface instead of buffering
-        if (contentLength > maxSize / 2) {
-            // Stream for payloads > 50MB (uploads) or > 5MB (JSON/form)
-            return this.createStreamingBodyParser(req, contentType, maxSize);
-        }
-        // Standard buffered parsing for smaller payloads
+        // Buffer every body up to maxSize and parse it into its real shape. The
+        // incremental limit check below already bounds memory, and every other
+        // backend (uWS, engine) returns the parsed body here - previously bodies
+        // between maxSize/2 and maxSize resolved to a { type, parser } descriptor
+        // object instead, so handlers/validation on the Node backend silently saw
+        // a bogus shape for the exact same request that parsed normally elsewhere.
         return new Promise((resolve, reject) => {
             const chunks = [];
             let totalLength = 0;
@@ -1496,7 +1510,10 @@ export class MoroHttpServer {
                 try {
                     // Single-chunk fast path (most JSON bodies arrive in one chunk);
                     // otherwise concat with the known total length to avoid a re-scan
-                    const body = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, totalLength);
+                    const firstChunk = chunks[0];
+                    const body = chunks.length === 1 && firstChunk !== undefined
+                        ? firstChunk
+                        : Buffer.concat(chunks, totalLength);
                     if (contentType.includes('application/json')) {
                         // Empty JSON body -> null (parity with the engine/uWS servers, and
                         // avoids JSON.parse('') throwing and 500ing an empty POST).
@@ -1525,132 +1542,6 @@ export class MoroHttpServer {
             req.on('error', reject);
         });
     }
-    /**
-     * Create a streaming body parser for large payloads
-     * Returns a streaming interface instead of buffering
-     */
-    createStreamingBodyParser(req, contentType, maxSize) {
-        let totalLength = 0;
-        const chunks = [];
-        return new Promise((resolve, reject) => {
-            const streamParser = {
-                // Streaming JSON parser for large JSON payloads
-                json: () => this.streamJsonParse(req, maxSize),
-                // Streaming form data parser
-                form: () => this.streamFormParse(req, maxSize),
-                // Raw stream access
-                stream: () => ({
-                    onData: (callback) => {
-                        req.on('data', (chunk) => {
-                            totalLength += chunk.length;
-                            if (totalLength > maxSize) {
-                                reject(new Error('Request body too large'));
-                                return;
-                            }
-                            callback(chunk);
-                        });
-                    },
-                    onEnd: (callback) => {
-                        req.on('end', callback);
-                    },
-                    onError: (callback) => {
-                        req.on('error', callback);
-                    },
-                }),
-                // Traditional buffered parsing (fallback)
-                buffer: async () => {
-                    return new Promise((resolveBuffer, rejectBuffer) => {
-                        req.on('data', (chunk) => {
-                            totalLength += chunk.length;
-                            if (totalLength > maxSize) {
-                                rejectBuffer(new Error('Request body too large'));
-                                return;
-                            }
-                            chunks.push(chunk);
-                        });
-                        req.on('end', () => {
-                            try {
-                                const body = Buffer.concat(chunks);
-                                if (contentType.includes('application/json')) {
-                                    resolveBuffer(JSON.parse(body.toString()));
-                                }
-                                else {
-                                    resolveBuffer(body.toString());
-                                }
-                            }
-                            catch (error) {
-                                rejectBuffer(error);
-                            }
-                        });
-                        req.on('error', rejectBuffer);
-                    });
-                },
-            };
-            // Auto-detect and return appropriate parser
-            if (contentType.includes('application/json')) {
-                resolve({ type: 'json', parser: streamParser.json });
-            }
-            else if (contentType.includes('application/x-www-form-urlencoded')) {
-                resolve({ type: 'form', parser: streamParser.form });
-            }
-            else {
-                resolve({ type: 'stream', parser: streamParser.stream });
-            }
-        });
-    }
-    /**
-     * Streaming JSON parser for large payloads
-     */
-    async streamJsonParse(req, maxSize) {
-        return new Promise((resolve, reject) => {
-            let jsonString = '';
-            let totalLength = 0;
-            req.on('data', (chunk) => {
-                totalLength += chunk.length;
-                if (totalLength > maxSize) {
-                    reject(new Error('Request body too large'));
-                    return;
-                }
-                jsonString += chunk.toString();
-            });
-            req.on('end', () => {
-                try {
-                    // For very large JSON, consider streaming JSON parsing in the future
-                    resolve(JSON.parse(jsonString));
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            req.on('error', reject);
-        });
-    }
-    /**
-     * Streaming form data parser
-     */
-    async streamFormParse(req, maxSize) {
-        return new Promise((resolve, reject) => {
-            let formData = '';
-            let totalLength = 0;
-            req.on('data', (chunk) => {
-                totalLength += chunk.length;
-                if (totalLength > maxSize) {
-                    reject(new Error('Request body too large'));
-                    return;
-                }
-                formData += chunk.toString();
-            });
-            req.on('end', () => {
-                try {
-                    resolve(this.parseUrlEncoded(formData));
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            req.on('error', reject);
-        });
-    }
     parseMultipart(buffer, contentType) {
         // Shared implementation - the native engine server parses uploads with
         // the exact same code so both transports agree on body/files shape
@@ -1718,6 +1609,8 @@ export class MoroHttpServer {
             // Only test routes with matching method and segment count
             for (let i = 0; i < candidateLen; i++) {
                 const candidateRoute = candidateRoutes[i];
+                if (candidateRoute === undefined)
+                    continue;
                 if (candidateRoute.method === method && candidateRoute.pattern.test(normalizedPath)) {
                     route = candidateRoute;
                     break;