@hono/node-server 1.2.0 → 1.2.2

package/dist/vercel.mjs

@@ -1,5 +1,135 @@
+// src/listener.ts
+import { Readable } from "stream";
+
+// src/globals.ts
+import crypto from "crypto";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto;
+}
+global.fetch = (info, init) => {
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};
+
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
+// src/listener.ts
+var regBuffer = /^no$/i;
+var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
+var getRequestListener = (fetchCallback) => {
+  return async (incoming, outgoing) => {
+    const method = incoming.method || "GET";
+    const url = `http://${incoming.headers.host}${incoming.url}`;
+    const headerRecord = [];
+    const len = incoming.rawHeaders.length;
+    for (let i = 0; i < len; i += 2) {
+      headerRecord.push([incoming.rawHeaders[i], incoming.rawHeaders[i + 1]]);
+    }
+    const init = {
+      method,
+      headers: headerRecord
+    };
+    if (!(method === "GET" || method === "HEAD")) {
+      init.body = Readable.toWeb(incoming);
+      init.duplex = "half";
+    }
+    let res;
+    try {
+      res = await fetchCallback(new Request(url, init));
+    } catch (e) {
+      res = new Response(null, { status: 500 });
+      if (e instanceof Error) {
+        if (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") {
+          res = new Response(null, { status: 504 });
+        }
+      }
+    }
+    const resHeaderRecord = {};
+    const cookies = [];
+    for (const [k, v] of res.headers) {
+      if (k === "set-cookie") {
+        cookies.push(v);
+      } else {
+        resHeaderRecord[k] = v;
+      }
+    }
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
+    if (res.body) {
+      try {
+        if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
+        } else {
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
+        }
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+        if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+          console.info("The user aborted a request.");
+        } else {
+          console.error(e);
+          outgoing.destroy(err);
+        }
+      }
+    } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
+      outgoing.end();
+    }
+  };
+};
+
 // src/vercel.ts
-import { getRequestListener } from "./listener.mjs";
 var handle = (app) => {
   return getRequestListener(app.fetch);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,7 +39,8 @@
   },
   "scripts": {
     "test": "jest",
-    "build": "rimraf dist && tsx ./build.ts",
+    "build": "tsup",
+    "watch": "tsup --watch",
     "postbuild": "publint",
     "prerelease": "yarn build && yarn test",
     "release": "np"
@@ -56,23 +57,20 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=18.14.1"
   },
   "dependencies": {},
   "devDependencies": {
-    "@types/glob": "^8.1.0",
     "@types/jest": "^29.5.3",
     "@types/node": "^18.7.16",
     "@types/supertest": "^2.0.12",
-    "esbuild": "^0.18.13",
-    "hono": "^3.3.4",
+    "hono": "^3.9.2",
     "jest": "^29.6.1",
     "np": "^7.7.0",
     "publint": "^0.1.16",
-    "rimraf": "^3.0.2",
     "supertest": "^6.3.3",
     "ts-jest": "^29.1.1",
-    "tsx": "^3.12.7",
+    "tsup": "^7.2.0",
     "typescript": "^4.8.3"
   }
 }