@web-widget/node 3.0.0-beta.0 → 3.0.0-beta.3

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);
@@ -147,8 +170,8 @@ 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);
@@ -157,24 +180,16 @@ function toMiddleware(webHandler, options) {
         await next();
       }
     } catch (error) {
-      let responded = false;
-      if (checkWritable(serverResponse) && !serverResponse.headersSent) {
-        try {
-          serverResponse.statusCode = 500;
-          setHttp1StatusMessage(serverResponse, "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 (responded) {
+      if (sendServerError(
+        serverResponse,
+        error instanceof Error ? error.message : void 0
+      )) {
         next();
       } else {
         next(error);
       }
+    } finally {
+      cancelRequestBody(request);
     }
   };
 }
@@ -206,23 +221,49 @@ 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) {
@@ -232,6 +273,27 @@ function checkWritable(serverResponse) {
   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);
@@ -241,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;
-            setHttp1StatusMessage(serverResponse, "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;
-            setHttp1StatusMessage(serverResponse, "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": "3.0.0-beta.0",
+  "version": "3.0.0-beta.3",
   "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"