@hono/node-server 1.2.2 → 1.3.0

package/dist/vercel.mjs

@@ -1,40 +1,21 @@
-// 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();
+  } else if (writable.destroyed) {
+    stream.cancel();
     return;
   }
-  writable.on("drain", onDrain);
+  const reader = stream.getReader();
   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(() => {
@@ -49,7 +30,9 @@ function writeFromReadableStream(stream, writable) {
     try {
       if (done) {
         writable.end();
-      } else if (writable.write(value)) {
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
         return reader.read().then(flow, cancel);
       }
     } catch (e) {
@@ -57,75 +40,239 @@ function writeFromReadableStream(stream, writable) {
     }
   }
 }
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain;charset=UTF-8";
+  return res;
+};
+
+// src/response.ts
+var responseCache = Symbol("responseCache");
+var cacheKey = Symbol("cache");
+var globalResponse = global.Response;
+var Response2 = class {
+  #body;
+  #init;
+  // @ts-ignore
+  get cache() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new globalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    this.#body = body;
+    this.#init = init;
+    if (typeof body === "string" || body instanceof ReadableStream) {
+      let headers = init?.headers || { "content-type": "text/plain;charset=UTF-8" };
+      if (headers instanceof Headers) {
+        headers = buildOutgoingHttpHeaders(headers);
+      }
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "headers",
+  "ok",
+  "redirected",
+  "status",
+  "statusText",
+  "trailers",
+  "type",
+  "url"
+].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this.cache[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this.cache[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, globalResponse);
+Object.setPrototypeOf(Response2.prototype, globalResponse.prototype);
+Object.defineProperty(global, "Response", {
+  value: Response2
+});
+
+// src/globals.ts
+Object.defineProperty(global, "Response", {
+  value: Response2
+});
+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/request.ts
+import { Readable } from "stream";
+var newRequestFromIncoming = (method, url, incoming) => {
+  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";
+  }
+  return new Request(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return `http://${this[incomingKey].headers.host}${this[incomingKey].url}`;
+  },
+  [getRequestCache]() {
+    return this[requestCache] ||= newRequestFromIncoming(this.method, this.url, this[incomingKey]);
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "headers",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, global.Request.prototype);
+var newRequest = (incoming) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  return req;
+};
 
 // 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;
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  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);
+  }
+};
+var responseViaCache = (res, outgoing) => {
+  const [status, body, header] = res[cacheKey];
+  if (typeof body === "string") {
+    header["content-length"] ||= "" + Buffer.byteLength(body);
+    outgoing.writeHead(status, header);
+    outgoing.end(body);
+  } else {
+    outgoing.writeHead(status, header);
+    return writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+};
+var responseViaResponseObject = async (res, outgoing) => {
+  if (res instanceof Promise) {
+    res = await res.catch(handleFetchError);
+  }
+  if (cacheKey in res) {
     try {
-      res = await fetchCallback(new Request(url, init));
+      return responseViaCache(res, outgoing);
     } 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 });
-        }
-      }
+      return handleResponseError(e, outgoing);
     }
-    const resHeaderRecord = {};
-    const cookies = [];
-    for (const [k, v] of res.headers) {
-      if (k === "set-cookie") {
-        cookies.push(v);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  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 {
-        resHeaderRecord[k] = v;
+        const buffer = await res.arrayBuffer();
+        resHeaderRecord["content-length"] = buffer.byteLength;
+        outgoing.writeHead(res.status, resHeaderRecord);
+        outgoing.end(new Uint8Array(buffer));
       }
+    } catch (e) {
+      handleResponseError(e, outgoing);
     }
-    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();
+  }
+};
+var getRequestListener = (fetchCallback) => {
+  return (incoming, outgoing) => {
+    let res;
+    const req = newRequest(incoming);
+    try {
+      res = fetchCallback(req);
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        res = handleFetchError(e);
+      } else {
+        return handleResponseError(e, outgoing);
       }
-    } else {
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end();
     }
+    return responseViaResponseObject(res, outgoing);
   };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,10 +59,9 @@
   "engines": {
     "node": ">=18.14.1"
   },
-  "dependencies": {},
   "devDependencies": {
     "@types/jest": "^29.5.3",
-    "@types/node": "^18.7.16",
+    "@types/node": "^20.10.0",
     "@types/supertest": "^2.0.12",
     "hono": "^3.9.2",
     "jest": "^29.6.1",
@@ -71,6 +70,6 @@
     "supertest": "^6.3.3",
     "ts-jest": "^29.1.1",
     "tsup": "^7.2.0",
-    "typescript": "^4.8.3"
+    "typescript": "^5.3.2"
   }
 }