@web-widget/node 2.3.1 → 3.0.0-beta.2

package/dist/node.js

@@ -25,10 +25,7 @@ import {
 import primitives2 from "@edge-runtime/primitives";
 
 // src/incoming-request.ts
-import {
-  buildToHeaders,
-  buildToReadableStream
-} from "@edge-runtime/node-utils";
+import { buildToHeaders } from "@edge-runtime/node-utils";
 function isHttp2PseudoHeader(name) {
   return name.startsWith(":");
 }
@@ -76,6 +73,32 @@ function computeRequestOrigin(headers, defaultOrigin) {
   }
   return `${protocol}://${authority}`;
 }
+function buildToReadableStream(dependencies2) {
+  const { ReadableStream: ReadableStreamCtor, Uint8Array: Uint8ArrayCtor } = dependencies2;
+  return function toReadableStream(stream) {
+    return new ReadableStreamCtor({
+      start(controller) {
+        const onData = (chunk) => {
+          controller.enqueue(new Uint8ArrayCtor(chunk));
+          if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+            stream.pause();
+          }
+        };
+        const onEnd = () => controller.close();
+        const onError = (err) => controller.error(err);
+        stream.on("data", onData);
+        stream.on("end", onEnd);
+        stream.on("error", onError);
+      },
+      pull() {
+        stream.resume();
+      },
+      cancel() {
+        stream.destroy();
+      }
+    });
+  };
+}
 function buildToRequestWithHttp2Compat(dependencies2) {
   const toHeaders = buildToHeaders(dependencies2);
   const toReadableStream = buildToReadableStream(dependencies2);
@@ -133,36 +156,40 @@ function addDuplexToInit(init) {
   }
   return init;
 }
+function isHttp2ServerResponse(serverResponse) {
+  if ("stream" in serverResponse && serverResponse.stream) return true;
+  const httpVersionMajor = serverResponse.httpVersionMajor;
+  return Number(httpVersionMajor) >= 2;
+}
+function setHttp1StatusMessage(serverResponse, statusMessage) {
+  if (!isHttp2ServerResponse(serverResponse) && statusMessage) {
+    serverResponse.statusMessage = statusMessage;
+  }
+}
 function toMiddleware(webHandler, options) {
   const toRequest = buildToRequestWithHttp2Compat(dependencies);
   const toFetchEvent = buildToFetchEvent(dependencies);
   return async function middleware(incomingMessage, serverResponse, next) {
+    const request = toRequest(incomingMessage, options);
     try {
-      const request = toRequest(incomingMessage, options);
       const env = process.env;
       const event = toFetchEvent(request);
       const webResponse = await webHandler(request, env, event);
       await toServerResponse(webResponse, serverResponse);
-      await next();
-    } catch (error) {
-      let responded = false;
-      if (checkWritable(serverResponse) && !serverResponse.headersSent) {
-        try {
-          serverResponse.statusCode = 500;
-          serverResponse.statusMessage = "Internal Server Error";
-          serverResponse.setHeader("content-type", "text/plain; charset=utf-8");
-          serverResponse.end(
-            error instanceof Error ? error.message : "Internal Server Error"
-          );
-          responded = true;
-        } catch {
-        }
+      if (!serverResponse.headersSent && !serverResponse.writableEnded) {
+        await next();
       }
-      if (responded) {
+    } catch (error) {
+      if (sendServerError(
+        serverResponse,
+        error instanceof Error ? error.message : void 0
+      )) {
         next();
       } else {
         next(error);
       }
+    } finally {
+      cancelRequestBody(request);
     }
   };
 }
@@ -174,14 +201,19 @@ async function toServerResponse(webResponse, serverResponse) {
     serverResponse.end();
     return;
   }
+  const isHttp2 = isHttp2ServerResponse(serverResponse);
+  const headers = toOutgoingHeaders(webResponse.headers);
+  const status = webResponse.status;
   if (!serverResponse.headersSent) {
-    mergeIntoServerResponse(
-      toOutgoingHeaders(webResponse.headers),
-      serverResponse
-    );
+    mergeIntoServerResponse(headers, serverResponse);
+    serverResponse.statusCode = status;
+    if (!isHttp2) {
+      setHttp1StatusMessage(serverResponse, webResponse.statusText);
+    }
+  } else if (!isHttp2) {
+    serverResponse.statusCode = status;
+    setHttp1StatusMessage(serverResponse, webResponse.statusText);
   }
-  serverResponse.statusCode = webResponse.status;
-  serverResponse.statusMessage = webResponse.statusText;
   if (!webResponse.body) {
     serverResponse.end();
     return;
@@ -189,31 +221,79 @@ async function toServerResponse(webResponse, serverResponse) {
   await writeReadableStreamToWritable(webResponse.body, serverResponse);
 }
 async function writeReadableStreamToWritable(stream, writable) {
-  let reader = stream.getReader();
-  let flushable = writable;
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  const flushable = writable;
+  const onAbort = () => {
+    reader.cancel().catch(() => {
+    });
+  };
+  writable.once("close", onAbort);
+  writable.once("error", onAbort);
   try {
-    while (true) {
-      let { done, value } = await reader.read();
+    while (!writable.destroyed) {
+      const { done, value } = await reader.read();
       if (done) {
-        writable.end();
+        if (!writable.destroyed) writable.end();
         break;
       }
-      writable.write(value);
+      if (writable.write(value) === false) {
+        await new Promise((resolve) => {
+          if (writable.destroyed) {
+            resolve();
+          } else {
+            writable.once("drain", resolve);
+          }
+        });
+      }
       if (typeof flushable.flush === "function") {
         flushable.flush();
       }
     }
   } catch (error) {
-    writable.destroy(error);
-    throw error;
+    if (!writable.destroyed) {
+      writable.destroy(error instanceof Error ? error : void 0);
+      throw error;
+    }
+  } finally {
+    writable.removeListener("close", onAbort);
+    writable.removeListener("error", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
   }
 }
 function checkWritable(serverResponse) {
   if (serverResponse.writableEnded || serverResponse.finished) return false;
+  if ("stream" in serverResponse && serverResponse.stream) return true;
   const socket = serverResponse.socket;
   if (!socket) return true;
   return socket.writable;
 }
+function sendServerError(serverResponse, message) {
+  if (!checkWritable(serverResponse) || serverResponse.headersSent) {
+    return false;
+  }
+  try {
+    serverResponse.statusCode = 500;
+    setHttp1StatusMessage(serverResponse, "Internal Server Error");
+    serverResponse.setHeader("content-type", "text/plain; charset=utf-8");
+    serverResponse.end(message || "Internal Server Error");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cancelRequestBody(request) {
+  const body = request.body;
+  if (body && !body.locked) {
+    body.cancel().catch(() => {
+    });
+  }
+}
 function buildToNodeHandler(dependencies2, options) {
   const toRequest = buildToRequestWithHttp2Compat(dependencies2);
   const toFetchEvent = buildToFetchEvent(dependencies2);
@@ -223,30 +303,14 @@ function buildToNodeHandler(dependencies2, options) {
       const env = process.env;
       const event = toFetchEvent(request);
       const maybePromise = webHandler(request, env, event);
+      const respond = (response) => toServerResponse(response, serverResponse).finally(
+        () => cancelRequestBody(request)
+      );
+      const fail = () => sendServerError(serverResponse);
       if (maybePromise instanceof Promise) {
-        maybePromise.then((response) => toServerResponse(response, serverResponse)).catch(() => {
-          if (checkWritable(serverResponse) && !serverResponse.headersSent) {
-            serverResponse.statusCode = 500;
-            serverResponse.statusMessage = "Internal Server Error";
-            serverResponse.setHeader(
-              "content-type",
-              "text/plain; charset=utf-8"
-            );
-            serverResponse.end("Internal Server Error");
-          }
-        });
+        maybePromise.then(respond).catch(fail);
       } else {
-        toServerResponse(maybePromise, serverResponse).catch(() => {
-          if (checkWritable(serverResponse) && !serverResponse.headersSent) {
-            serverResponse.statusCode = 500;
-            serverResponse.statusMessage = "Internal Server Error";
-            serverResponse.setHeader(
-              "content-type",
-              "text/plain; charset=utf-8"
-            );
-            serverResponse.end("Internal Server Error");
-          }
-        });
+        respond(maybePromise).catch(fail);
       }
     };
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/node",
   "description": "Node.js adapter",
-  "version": "2.3.1",
+  "version": "3.0.0-beta.2",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "devDependencies": {
     "@types/node": "^22.2.0",
     "tsup": "^8.3.4",
-    "typescript": "^5.5.4"
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=18"