@hono/node-server 1.2.0 → 1.2.2

package/dist/server.mjs

@@ -1,6 +1,138 @@
 // src/server.ts
-import { createServer as createServerHTTP } from "node:http";
-import { getRequestListener } from "./listener.mjs";
+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);

package/dist/types.d.mts

@@ -0,0 +1,33 @@
+import { Server, ServerOptions as ServerOptions$1, createServer } from 'node:http';
+import { ServerOptions as ServerOptions$2, createServer as createServer$1 } from 'node:https';
+import { Http2Server, Http2SecureServer, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer } from 'node:http2';
+
+declare type FetchCallback = (request: Request) => Promise<unknown> | unknown;
+declare type NextHandlerOption = {
+    fetch: FetchCallback;
+};
+declare type ServerType = Server | Http2Server | Http2SecureServer;
+declare type createHttpOptions = {
+    serverOptions?: ServerOptions$1;
+    createServer?: typeof createServer;
+};
+declare type createHttpsOptions = {
+    serverOptions?: ServerOptions$2;
+    createServer?: typeof createServer$1;
+};
+declare type createHttp2Options = {
+    serverOptions?: ServerOptions$3;
+    createServer?: typeof createServer$2;
+};
+declare type createSecureHttp2Options = {
+    serverOptions?: SecureServerOptions;
+    createServer?: typeof createSecureServer;
+};
+declare type ServerOptions = createHttpOptions | createHttpsOptions | createHttp2Options | createSecureHttp2Options;
+declare type Options = {
+    fetch: FetchCallback;
+    port?: number;
+    hostname?: string;
+} & ServerOptions;
+
+export { FetchCallback, NextHandlerOption, Options, ServerType };

package/dist/types.d.ts

@@ -1,34 +1,33 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { createServer, Server, ServerOptions as HttpServerOptions } from 'node:http';
-import type { createServer as createHttpsServer, ServerOptions as HttpsServerOptions } from 'node:https';
-import type { createSecureServer as createSecureHttp2Server, createServer as createHttp2Server, Http2Server, Http2SecureServer, SecureServerOptions as SecureHttp2ServerOptions, ServerOptions as Http2ServerOptions } from 'node:http2';
-export declare type FetchCallback = (request: Request) => Promise<unknown> | unknown;
-export declare type NextHandlerOption = {
+import { Server, ServerOptions as ServerOptions$1, createServer } from 'node:http';
+import { ServerOptions as ServerOptions$2, createServer as createServer$1 } from 'node:https';
+import { Http2Server, Http2SecureServer, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer } from 'node:http2';
+
+declare type FetchCallback = (request: Request) => Promise<unknown> | unknown;
+declare type NextHandlerOption = {
     fetch: FetchCallback;
 };
-export declare type ServerType = Server | Http2Server | Http2SecureServer;
+declare type ServerType = Server | Http2Server | Http2SecureServer;
 declare type createHttpOptions = {
-    serverOptions?: HttpServerOptions;
+    serverOptions?: ServerOptions$1;
     createServer?: typeof createServer;
 };
 declare type createHttpsOptions = {
-    serverOptions?: HttpsServerOptions;
-    createServer?: typeof createHttpsServer;
+    serverOptions?: ServerOptions$2;
+    createServer?: typeof createServer$1;
 };
 declare type createHttp2Options = {
-    serverOptions?: Http2ServerOptions;
-    createServer?: typeof createHttp2Server;
+    serverOptions?: ServerOptions$3;
+    createServer?: typeof createServer$2;
 };
 declare type createSecureHttp2Options = {
-    serverOptions?: SecureHttp2ServerOptions;
-    createServer?: typeof createSecureHttp2Server;
+    serverOptions?: SecureServerOptions;
+    createServer?: typeof createSecureServer;
 };
 declare type ServerOptions = createHttpOptions | createHttpsOptions | createHttp2Options | createSecureHttp2Options;
-export declare type Options = {
+declare type Options = {
     fetch: FetchCallback;
     port?: number;
     hostname?: string;
 } & ServerOptions;
-export {};
+
+export { FetchCallback, NextHandlerOption, Options, ServerType };

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/utils.d.mts

@@ -0,0 +1,5 @@
+import { Writable } from 'node:stream';
+
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+
+export { writeFromReadableStream };

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import { Writable } from 'node:stream';
+
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+
+export { writeFromReadableStream };

package/dist/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  writeFromReadableStream: () => writeFromReadableStream
+});
+module.exports = __toCommonJS(utils_exports);
+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);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeFromReadableStream
+});

package/dist/utils.mjs

@@ -0,0 +1,43 @@
+// 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);
+    }
+  }
+}
+export {
+  writeFromReadableStream
+};

package/dist/vercel.d.mts

@@ -0,0 +1,7 @@
+import * as http2 from 'http2';
+import * as http from 'http';
+import { Hono } from 'hono';
+
+declare const handle: (app: Hono<any, any, any>) => (incoming: http.IncomingMessage | http2.Http2ServerRequest, outgoing: http.ServerResponse<http.IncomingMessage> | http2.Http2ServerResponse) => Promise<void>;
+
+export { handle };

package/dist/vercel.d.ts

@@ -1,4 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Hono } from 'hono';
-export declare const handle: (app: Hono<any, any, any>) => (incoming: import("http").IncomingMessage | import("http2").Http2ServerRequest, outgoing: import("http").ServerResponse<import("http").IncomingMessage> | import("http2").Http2ServerResponse) => Promise<void>;
+import * as http2 from 'http2';
+import * as http from 'http';
+import { Hono } from 'hono';
+
+declare const handle: (app: Hono<any, any, any>) => (incoming: http.IncomingMessage | http2.Http2ServerRequest, outgoing: http.ServerResponse<http.IncomingMessage> | http2.Http2ServerResponse) => Promise<void>;
+
+export { handle };

package/dist/vercel.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,15 +17,157 @@ 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/vercel.ts
 var vercel_exports = {};
 __export(vercel_exports, {
   handle: () => handle
 });
 module.exports = __toCommonJS(vercel_exports);
-var import_listener = require("./listener");
-const handle = (app) => {
-  return (0, import_listener.getRequestListener)(app.fetch);
+
+// 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/vercel.ts
+var handle = (app) => {
+  return getRequestListener(app.fetch);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {