@hono/node-server 1.15.0 → 1.16.0

package/README.md

@@ -125,6 +125,18 @@ serve({
 })
 ```
 
+### `autoCleanupIncoming`
+
+The default value is `true`. The Node.js Adapter automatically cleans up (explicitly call `destroy()` method) if application is not finished to consume the incoming request. If you don't want to do that, set `false`.
+If the application accepts connections from arbitrary clients, this cleanup must be done otherwise incomplete requests from clients may cause the application to stop responding. If your application only accepts connections from trusted clients, such as in a reverse proxy environment and there is no process that returns a response without reading the body of the POST request all the way through, you can improve performance by setting it to `false`.
+
+```ts
+serve({
+  fetch: app.fetch,
+  autoCleanupIncoming: false,
+})
+```
+
 ## Middleware
 
 Most built-in middleware also works with Node.js.

package/dist/globals.d.mts

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

package/dist/globals.d.ts

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

package/dist/index.js

@@ -40,6 +40,9 @@ module.exports = __toCommonJS(src_exports);
 // src/server.ts
 var import_node_http = require("http");
 
+// src/listener.ts
+var import_node_http22 = require("http2");
+
 // src/request.ts
 var import_node_http2 = require("http2");
 var import_node_stream = require("stream");
@@ -68,6 +71,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -101,6 +105,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = import_node_stream.Readable.toWeb(incoming);
     }
@@ -349,6 +370,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -394,10 +416,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -443,8 +467,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -457,15 +484,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof import_node_http22.Http2ServerRequest) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });
@@ -501,7 +559,8 @@ var createAdaptorServer = (options) => {
   const fetchCallback = options.fetch;
   const requestListener = getRequestListener(fetchCallback, {
     hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
   });
   const createServer = options.createServer || import_node_http.createServer;
   const server = createServer(options.serverOptions || {}, requestListener);

package/dist/index.mjs

@@ -1,6 +1,9 @@
 // src/server.ts
 import { createServer as createServerHTTP } from "http";
 
+// src/listener.ts
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+
 // src/request.ts
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
@@ -29,6 +32,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -62,6 +66,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = Readable.toWeb(incoming);
     }
@@ -310,6 +331,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -355,10 +377,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -404,8 +428,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -418,15 +445,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });
@@ -462,7 +520,8 @@ var createAdaptorServer = (options) => {
   const fetchCallback = options.fetch;
   const requestListener = getRequestListener(fetchCallback, {
     hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
   });
   const createServer = options.createServer || createServerHTTP;
   const server = createServer(options.serverOptions || {}, requestListener);

package/dist/listener.d.mts

@@ -7,6 +7,7 @@ declare const getRequestListener: (fetchCallback: FetchCallback, options?: {
     hostname?: string;
     errorHandler?: CustomErrorHandler;
     overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
 }) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
 
 export { getRequestListener };

package/dist/listener.d.ts

@@ -7,6 +7,7 @@ declare const getRequestListener: (fetchCallback: FetchCallback, options?: {
     hostname?: string;
     errorHandler?: CustomErrorHandler;
     overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
 }) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
 
 export { getRequestListener };

package/dist/listener.js

@@ -33,6 +33,7 @@ __export(listener_exports, {
   getRequestListener: () => getRequestListener
 });
 module.exports = __toCommonJS(listener_exports);
+var import_node_http22 = require("http2");
 
 // src/request.ts
 var import_node_http2 = require("http2");
@@ -62,6 +63,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -95,6 +97,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = import_node_stream.Readable.toWeb(incoming);
     }
@@ -343,6 +362,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -388,10 +408,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -437,8 +459,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -451,15 +476,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof import_node_http22.Http2ServerRequest) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });

package/dist/listener.mjs

@@ -1,3 +1,6 @@
+// src/listener.ts
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+
 // src/request.ts
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
@@ -26,6 +29,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -59,6 +63,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = Readable.toWeb(incoming);
     }
@@ -307,6 +328,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -352,10 +374,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -401,8 +425,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -415,15 +442,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });

package/dist/request.d.mts

@@ -14,8 +14,12 @@ declare const GlobalRequest: {
 declare class Request extends GlobalRequest {
     constructor(input: string | Request, options?: RequestInit);
 }
+type IncomingMessageWithWrapBodyStream = IncomingMessage & {
+    [wrapBodyStream]: boolean;
+};
+declare const wrapBodyStream: unique symbol;
 declare const abortControllerKey: unique symbol;
 declare const getAbortController: unique symbol;
 declare const newRequest: (incoming: IncomingMessage | Http2ServerRequest, defaultHostname?: string) => any;
 
-export { GlobalRequest, Request, RequestError, abortControllerKey, getAbortController, newRequest, toRequestError };
+export { GlobalRequest, IncomingMessageWithWrapBodyStream, Request, RequestError, abortControllerKey, getAbortController, newRequest, toRequestError, wrapBodyStream };

package/dist/request.d.ts

@@ -14,8 +14,12 @@ declare const GlobalRequest: {
 declare class Request extends GlobalRequest {
     constructor(input: string | Request, options?: RequestInit);
 }
+type IncomingMessageWithWrapBodyStream = IncomingMessage & {
+    [wrapBodyStream]: boolean;
+};
+declare const wrapBodyStream: unique symbol;
 declare const abortControllerKey: unique symbol;
 declare const getAbortController: unique symbol;
 declare const newRequest: (incoming: IncomingMessage | Http2ServerRequest, defaultHostname?: string) => any;
 
-export { GlobalRequest, Request, RequestError, abortControllerKey, getAbortController, newRequest, toRequestError };
+export { GlobalRequest, IncomingMessageWithWrapBodyStream, Request, RequestError, abortControllerKey, getAbortController, newRequest, toRequestError, wrapBodyStream };

package/dist/request.js

@@ -26,7 +26,8 @@ __export(request_exports, {
   abortControllerKey: () => abortControllerKey,
   getAbortController: () => getAbortController,
   newRequest: () => newRequest,
-  toRequestError: () => toRequestError
+  toRequestError: () => toRequestError,
+  wrapBodyStream: () => wrapBodyStream
 });
 module.exports = __toCommonJS(request_exports);
 var import_node_http2 = require("http2");
@@ -56,6 +57,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -89,6 +91,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = import_node_stream.Readable.toWeb(incoming);
     }
@@ -196,5 +215,6 @@ var newRequest = (incoming, defaultHostname) => {
   abortControllerKey,
   getAbortController,
   newRequest,
-  toRequestError
+  toRequestError,
+  wrapBodyStream
 });

package/dist/request.mjs

@@ -26,6 +26,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -59,6 +60,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = Readable.toWeb(incoming);
     }
@@ -165,5 +183,6 @@ export {
   abortControllerKey,
   getAbortController,
   newRequest,
-  toRequestError
+  toRequestError,
+  wrapBodyStream
 };

package/dist/response.d.mts

@@ -23,4 +23,4 @@ declare class Response {
     get ok(): boolean;
 }
 
-export { GlobalResponse, type InternalCache, Response, cacheKey };
+export { GlobalResponse, InternalCache, Response, cacheKey };

package/dist/response.d.ts

@@ -23,4 +23,4 @@ declare class Response {
     get ok(): boolean;
 }
 
-export { GlobalResponse, type InternalCache, Response, cacheKey };
+export { GlobalResponse, InternalCache, Response, cacheKey };

package/dist/serve-static.d.mts

@@ -14,4 +14,4 @@ type ServeStaticOptions<E extends Env = Env> = {
 };
 declare const serveStatic: <E extends Env = any>(options?: ServeStaticOptions<E>) => MiddlewareHandler<E>;
 
-export { type ServeStaticOptions, serveStatic };
+export { ServeStaticOptions, serveStatic };

package/dist/serve-static.d.ts

@@ -14,4 +14,4 @@ type ServeStaticOptions<E extends Env = Env> = {
 };
 declare const serveStatic: <E extends Env = any>(options?: ServeStaticOptions<E>) => MiddlewareHandler<E>;
 
-export { type ServeStaticOptions, serveStatic };
+export { ServeStaticOptions, serveStatic };

package/dist/server.js

@@ -36,6 +36,9 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 var import_node_http = require("http");
 
+// src/listener.ts
+var import_node_http22 = require("http2");
+
 // src/request.ts
 var import_node_http2 = require("http2");
 var import_node_stream = require("stream");
@@ -64,6 +67,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -97,6 +101,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = import_node_stream.Readable.toWeb(incoming);
     }
@@ -345,6 +366,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -390,10 +412,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -439,8 +463,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -453,15 +480,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof import_node_http22.Http2ServerRequest) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });
@@ -497,7 +555,8 @@ var createAdaptorServer = (options) => {
   const fetchCallback = options.fetch;
   const requestListener = getRequestListener(fetchCallback, {
     hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
   });
   const createServer = options.createServer || import_node_http.createServer;
   const server = createServer(options.serverOptions || {}, requestListener);

package/dist/server.mjs

@@ -1,6 +1,9 @@
 // src/server.ts
 import { createServer as createServerHTTP } from "http";
 
+// src/listener.ts
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+
 // src/request.ts
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
@@ -29,6 +32,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -62,6 +66,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = Readable.toWeb(incoming);
     }
@@ -310,6 +331,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -355,10 +377,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -404,8 +428,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -418,15 +445,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });
@@ -462,7 +520,8 @@ var createAdaptorServer = (options) => {
   const fetchCallback = options.fetch;
   const requestListener = getRequestListener(fetchCallback, {
     hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
   });
   const createServer = options.createServer || createServerHTTP;
   const server = createServer(options.serverOptions || {}, requestListener);

package/dist/types.d.mts

@@ -1,5 +1,5 @@
-import { IncomingMessage, ServerResponse, ServerOptions as ServerOptions$1, createServer, Server } from 'node:http';
-import { Http2ServerRequest, Http2ServerResponse, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer, Http2Server, Http2SecureServer } from 'node:http2';
+import { IncomingMessage, ServerResponse, Server, ServerOptions as ServerOptions$1, createServer } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse, Http2Server, Http2SecureServer, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer } from 'node:http2';
 import { ServerOptions as ServerOptions$2, createServer as createServer$1 } from 'node:https';
 
 type HttpBindings = {
@@ -35,9 +35,10 @@ type ServerOptions = createHttpOptions | createHttpsOptions | createHttp2Options
 type Options = {
     fetch: FetchCallback;
     overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
     port?: number;
     hostname?: string;
 } & ServerOptions;
 type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>;
 
-export type { CustomErrorHandler, FetchCallback, Http2Bindings, HttpBindings, NextHandlerOption, Options, ServerOptions, ServerType };
+export { CustomErrorHandler, FetchCallback, Http2Bindings, HttpBindings, NextHandlerOption, Options, ServerOptions, ServerType };

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import { IncomingMessage, ServerResponse, ServerOptions as ServerOptions$1, createServer, Server } from 'node:http';
-import { Http2ServerRequest, Http2ServerResponse, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer, Http2Server, Http2SecureServer } from 'node:http2';
+import { IncomingMessage, ServerResponse, Server, ServerOptions as ServerOptions$1, createServer } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse, Http2Server, Http2SecureServer, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer } from 'node:http2';
 import { ServerOptions as ServerOptions$2, createServer as createServer$1 } from 'node:https';
 
 type HttpBindings = {
@@ -35,9 +35,10 @@ type ServerOptions = createHttpOptions | createHttpsOptions | createHttp2Options
 type Options = {
     fetch: FetchCallback;
     overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
     port?: number;
     hostname?: string;
 } & ServerOptions;
 type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>;
 
-export type { CustomErrorHandler, FetchCallback, Http2Bindings, HttpBindings, NextHandlerOption, Options, ServerOptions, ServerType };
+export { CustomErrorHandler, FetchCallback, Http2Bindings, HttpBindings, NextHandlerOption, Options, ServerOptions, ServerType };

package/dist/utils.d.mts

@@ -1,7 +1,7 @@
 import { OutgoingHttpHeaders } from 'node:http';
 import { Writable } from 'node:stream';
 
-declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<void> | undefined;
 declare const buildOutgoingHttpHeaders: (headers: Headers | HeadersInit | null | undefined) => OutgoingHttpHeaders;
 
 export { buildOutgoingHttpHeaders, writeFromReadableStream };

package/dist/utils.d.ts

@@ -1,7 +1,7 @@
 import { OutgoingHttpHeaders } from 'node:http';
 import { Writable } from 'node:stream';
 
-declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<void> | undefined;
 declare const buildOutgoingHttpHeaders: (headers: Headers | HeadersInit | null | undefined) => OutgoingHttpHeaders;
 
 export { buildOutgoingHttpHeaders, writeFromReadableStream };

package/dist/vercel.js

@@ -34,6 +34,9 @@ __export(vercel_exports, {
 });
 module.exports = __toCommonJS(vercel_exports);
 
+// src/listener.ts
+var import_node_http22 = require("http2");
+
 // src/request.ts
 var import_node_http2 = require("http2");
 var import_node_stream = require("stream");
@@ -62,6 +65,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -95,6 +99,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = import_node_stream.Readable.toWeb(incoming);
     }
@@ -343,6 +364,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -388,10 +410,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -437,8 +461,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -451,15 +478,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof import_node_http22.Http2ServerRequest) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });

package/dist/vercel.mjs

@@ -1,3 +1,6 @@
+// src/listener.ts
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+
 // src/request.ts
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
@@ -26,6 +29,7 @@ var Request = class extends GlobalRequest {
     super(input, options);
   }
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
@@ -59,6 +63,23 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
           controller.close();
         }
       });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
     } else {
       init.body = Readable.toWeb(incoming);
     }
@@ -307,6 +328,7 @@ global.fetch = (info, init) => {
 };
 
 // src/listener.ts
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
@@ -352,10 +374,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    return writeFromReadableStream(body, outgoing)?.catch(
+    await writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
   if (res instanceof Promise) {
@@ -401,8 +425,11 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
+  ;
+  outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
   if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
       value: Request
@@ -415,15 +442,46 @@ var getRequestListener = (fetchCallback, options = {}) => {
     let res, req;
     try {
       req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
         }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
         }
       });
       res = fetchCallback(req, { incoming, outgoing });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",