@hono/node-server 1.2.0 → 1.2.2

package/dist/globals.d.mts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/globals.d.ts

@@ -1 +1,2 @@
-export {};
+
+export { }

package/dist/globals.js

@@ -21,8 +21,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var import_node_crypto = __toESM(require("node:crypto"));
-const webFetch = global.fetch;
+
+// src/globals.ts
+var import_node_crypto = __toESM(require("crypto"));
+var webFetch = global.fetch;
 if (typeof global.crypto === "undefined") {
   global.crypto = import_node_crypto.default;
 }

package/dist/globals.mjs

@@ -1,5 +1,5 @@
 // src/globals.ts
-import crypto from "node:crypto";
+import crypto from "crypto";
 var webFetch = global.fetch;
 if (typeof global.crypto === "undefined") {
   global.crypto = crypto;

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+export { createAdaptorServer, serve } from './server.mjs';
+export { getRequestListener } from './listener.mjs';
+import 'node:net';
+import './types.mjs';
+import 'node:http';
+import 'node:https';
+import 'node:http2';

package/dist/index.d.ts

@@ -1,2 +1,7 @@
-export { serve, createAdaptorServer } from './server';
-export { getRequestListener } from './listener';
+export { createAdaptorServer, serve } from './server.js';
+export { getRequestListener } from './listener.js';
+import 'node:net';
+import './types.js';
+import 'node:http';
+import 'node:https';
+import 'node:http2';

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,175 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createAdaptorServer: () => import_server.createAdaptorServer,
-  getRequestListener: () => import_listener.getRequestListener,
-  serve: () => import_server.serve
+  createAdaptorServer: () => createAdaptorServer,
+  getRequestListener: () => getRequestListener,
+  serve: () => serve
 });
 module.exports = __toCommonJS(src_exports);
-var import_server = require("./server");
-var import_listener = require("./listener");
+
+// src/server.ts
+var import_node_http = require("http");
+
+// src/listener.ts
+var import_node_stream = require("stream");
+
+// src/globals.ts
+var import_node_crypto = __toESM(require("crypto"));
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = import_node_crypto.default;
+}
+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 = import_node_stream.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/server.ts
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback);
+  const createServer = options.createServer || import_node_http.createServer;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname ?? "0.0.0.0", () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAdaptorServer,

package/dist/index.mjs

@@ -1,6 +1,153 @@
-// src/index.ts
-import { serve, createAdaptorServer } from "./server.mjs";
-import { getRequestListener } from "./listener.mjs";
+// src/server.ts
+import { createServer as createServerHTTP } from "http";
+
+// 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/server.ts
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback);
+  const createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname ?? "0.0.0.0", () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
 export {
   createAdaptorServer,
   getRequestListener,

package/dist/listener.d.mts

@@ -0,0 +1,8 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { FetchCallback } from './types.mjs';
+import 'node:https';
+
+declare const getRequestListener: (fetchCallback: FetchCallback) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
+
+export { getRequestListener };

package/dist/listener.d.ts

@@ -1,5 +1,8 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
-import type { FetchCallback } from './types';
-import './globals';
-export declare const getRequestListener: (fetchCallback: FetchCallback) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { FetchCallback } from './types.js';
+import 'node:https';
+
+declare const getRequestListener: (fetchCallback: FetchCallback) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
+
+export { getRequestListener };

package/dist/listener.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,85 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/listener.ts
 var listener_exports = {};
 __export(listener_exports, {
   getRequestListener: () => getRequestListener
 });
 module.exports = __toCommonJS(listener_exports);
-var import_node_stream = require("node:stream");
-var import_promises = require("node:stream/promises");
-var import_globals = require("./globals");
-const getRequestListener = (fetchCallback) => {
+var import_node_stream = require("stream");
+
+// src/globals.ts
+var import_node_crypto = __toESM(require("crypto"));
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = import_node_crypto.default;
+}
+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}`;
@@ -43,7 +114,7 @@ const getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -52,27 +123,29 @@ const getRequestListener = (fetchCallback) => {
         }
       }
     }
-    const contentType = res.headers.get("content-type") || "";
-    const buffering = res.headers.get("x-accel-buffering") || "";
-    const contentEncoding = res.headers.get("content-encoding");
-    const contentLength = res.headers.get("content-length");
-    const transferEncoding = res.headers.get("transfer-encoding");
+    const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
-        if (contentEncoding || transferEncoding || contentLength || /^no$/i.test(buffering) || !/^(application\/json\b|text\/(?!event-stream\b))/i.test(contentType)) {
-          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        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 text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          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 });
@@ -84,6 +157,7 @@ const getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };