@schmock/core 2.2.3 → 2.3.1

package/dist/http-helpers.js

@@ -1,90 +1,206 @@
+import { isBinaryBody } from "./binary.js";
+import { serializeResponseBody } from "./response-normalizer.js";
+/** An HTTP client error raised while collecting an incoming request body. */
+export class HttpIngressError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "HttpIngressError";
+    }
+}
 /**
  * Convert Node.js IncomingMessage headers to a flat Record<string, string>.
  * Drops array-valued headers (keeps only string values).
  */
 export function parseNodeHeaders(req) {
-    const headers = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-        if (typeof value === "string") {
-            headers[key] = value;
-        }
-    }
-    return headers;
+    // Object.fromEntries defines own properties, so a header literally named
+    // `__proto__` is preserved instead of being swallowed by the prototype
+    // setter. The prototype is retained so consumers keep Object.prototype.
+    return Object.fromEntries(Object.entries(req.headers).filter((entry) => typeof entry[1] === "string"));
 }
 /**
  * Extract query parameters from a URL as a flat Record<string, string>.
  */
 export function parseNodeQuery(url) {
-    const query = {};
-    url.searchParams.forEach((value, key) => {
-        query[key] = value;
-    });
-    return query;
+    // Own-property definition for the same reason as parseNodeHeaders, and it
+    // matches how the fetch interceptor builds its query record.
+    return Object.fromEntries(url.searchParams);
 }
 /** Default body size limit: 10 MB */
 const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024;
+const DECIMAL_CONTENT_LENGTH = /^\d+$/;
+function payloadTooLargeError() {
+    return new HttpIngressError(413, "PAYLOAD_TOO_LARGE", "Request body too large");
+}
+function requestAbortedError() {
+    const error = new Error("Request body collection aborted");
+    error.name = "AbortError";
+    return error;
+}
+function isJsonMediaType(contentType) {
+    const baseMediaType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+    return (baseMediaType === "application/json" || baseMediaType.endsWith("+json"));
+}
 /**
  * Collect and parse the request body from a Node.js IncomingMessage.
- * Returns parsed JSON if content-type includes "json", otherwise the raw string.
+ * Returns parsed JSON for application/json and +json media types, otherwise the
+ * raw string.
  * Returns undefined for empty bodies.
  * @param req - Node.js IncomingMessage
  * @param headers - Parsed request headers
  * @param maxBodySize - Maximum body size in bytes (default: 10 MB)
  */
 export function collectBody(req, headers, maxBodySize = DEFAULT_MAX_BODY_SIZE) {
+    const contentLength = headers["content-length"];
+    const declaredBodyTooLarge = contentLength !== undefined &&
+        DECIMAL_CONTENT_LENGTH.test(contentLength) &&
+        Number(contentLength) > maxBodySize;
     return new Promise((resolve, reject) => {
         const chunks = [];
         let totalSize = 0;
-        req.on("error", reject);
+        let settled = false;
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            chunks.length = 0;
+            reject(error);
+        };
+        const resolveOnce = (body) => {
+            if (settled)
+                return;
+            settled = true;
+            chunks.length = 0;
+            resolve(body);
+        };
+        if (declaredBodyTooLarge) {
+            rejectOnce(payloadTooLargeError());
+        }
+        req.on("error", rejectOnce);
+        req.on("aborted", () => rejectOnce(requestAbortedError()));
+        req.on("close", () => rejectOnce(requestAbortedError()));
         req.on("data", (chunk) => {
-            totalSize += chunk.length;
+            if (settled)
+                return;
+            totalSize += chunk.byteLength;
             if (totalSize > maxBodySize) {
-                req.destroy();
-                reject(Object.assign(new Error("Request body too large"), { status: 413 }));
+                rejectOnce(payloadTooLargeError());
                 return;
             }
             chunks.push(chunk);
         });
         req.on("end", () => {
+            if (settled)
+                return;
             const raw = Buffer.concat(chunks).toString();
             if (!raw) {
-                resolve(undefined);
+                resolveOnce(undefined);
                 return;
             }
             const contentType = headers["content-type"] ?? "";
-            if (contentType.includes("json")) {
+            if (isJsonMediaType(contentType)) {
                 try {
-                    resolve(JSON.parse(raw));
+                    resolveOnce(JSON.parse(raw));
                 }
                 catch {
-                    resolve(raw);
+                    rejectOnce(new HttpIngressError(400, "MALFORMED_JSON", "Malformed JSON request body"));
                 }
             }
             else {
-                resolve(raw);
+                resolveOnce(raw);
             }
         });
     });
 }
+/** How long a rejected request may stay silent before the response ends. */
+const REJECTED_REQUEST_IDLE_MS = 400;
+/** Hard cap for a client that keeps streaming after a rejected request. */
+const REJECTED_REQUEST_DRAIN_GRACE_MS = 5_000;
+function prepareWriteableResponse(response, extraHeaders) {
+    const responseHeaders = { ...response.headers };
+    if (extraHeaders) {
+        const names = new Map(Object.keys(responseHeaders).map((name) => [name.toLowerCase(), name]));
+        for (const [name, value] of Object.entries(extraHeaders)) {
+            const previousName = names.get(name.toLowerCase());
+            if (previousName !== undefined)
+                delete responseHeaders[previousName];
+            responseHeaders[name] = value;
+            names.set(name.toLowerCase(), name);
+        }
+    }
+    const hasContentType = Object.keys(responseHeaders).some((header) => header.toLowerCase() === "content-type");
+    if (!hasContentType &&
+        response.body !== undefined &&
+        isBinaryBody(response.body)) {
+        responseHeaders["content-type"] = "application/octet-stream";
+    }
+    else if (!hasContentType &&
+        response.body !== undefined &&
+        typeof response.body !== "string") {
+        responseHeaders["content-type"] = "application/json";
+    }
+    const body = serializeResponseBody({
+        ...response,
+        headers: responseHeaders,
+    });
+    return { headers: responseHeaders, body };
+}
 /**
  * Write a Schmock Response to a Node.js ServerResponse.
  * Serializes non-string bodies as JSON and sets content-type when missing.
  */
 export function writeSchmockResponse(res, response, extraHeaders) {
-    const responseHeaders = {
-        ...response.headers,
-        ...extraHeaders,
+    const { headers, body } = prepareWriteableResponse(response, extraHeaders);
+    res.writeHead(response.status, headers);
+    res.end(body);
+}
+/**
+ * Write a rejection (e.g. 413) while the client may still be uploading.
+ *
+ * Ending the response immediately makes Node tear the socket down while
+ * request bytes are in flight; the resulting TCP reset discards the
+ * already-written error from the client's receive buffer, so the client
+ * observes ECONNRESET instead of the response. Instead the response body is
+ * flushed right away and the end is deferred — a lingering close — until the
+ * request finishes, goes idle, or exhausts the grace cap.
+ */
+export function writeRejectedSchmockResponse(req, res, response, extraHeaders) {
+    const { headers, body } = prepareWriteableResponse(response, extraHeaders);
+    res.writeHead(response.status, headers);
+    if (body !== undefined)
+        res.write(body);
+    let idleTimer;
+    let graceTimer;
+    let finished = false;
+    const onData = () => {
+        // The client is still sending: keep the socket open so its bytes have
+        // somewhere to go, pushing the deferred end out with every chunk.
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(finish, REJECTED_REQUEST_IDLE_MS);
+        idleTimer.unref?.();
     };
-    if (!responseHeaders["content-type"] &&
-        response.body !== undefined &&
-        typeof response.body !== "string") {
-        responseHeaders["content-type"] = "application/json";
-    }
-    const responseBody = response.body === undefined
-        ? undefined
-        : typeof response.body === "string"
-            ? response.body
-            : JSON.stringify(response.body);
-    res.writeHead(response.status, responseHeaders);
-    res.end(responseBody);
+    const finish = () => {
+        if (finished)
+            return;
+        finished = true;
+        req.off("data", onData);
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+        if (graceTimer !== undefined)
+            clearTimeout(graceTimer);
+        if (!res.writableEnded)
+            res.end();
+    };
+    req.on("data", onData);
+    req.once("end", finish);
+    req.once("close", finish);
+    res.once("close", finish);
+    onData();
+    graceTimer = setTimeout(finish, REJECTED_REQUEST_DRAIN_GRACE_MS);
+    graceTimer.unref?.();
+    req.resume();
 }