@hono/node-server 0.5.0 → 0.5.1

package/dist/globals.d.ts

@@ -16,6 +16,9 @@ declare global {
             FormData: typeof FormData;
             ReadableStream: typeof ReadableStream;
             WritableStream: typeof WritableStream;
+            TransformStream: typeof TransformStream;
+            TextDecoderStream: typeof TextDecoderStream;
+            TextEncoderStream: typeof TextEncoderStream;
             crypto: Crypto;
         }
     }

package/dist/globals.js

@@ -23,6 +23,9 @@ function installGlobals() {
     global.FormData = fetch_1.FormData;
     global.ReadableStream = web_stream_1.ReadableStream;
     global.WritableStream = web_stream_1.WritableStream;
+    global.TransformStream = web_stream_1.TransformStream;
+    global.TextDecoderStream = web_stream_1.TextDecoderStream;
+    global.TextEncoderStream = web_stream_1.TextEncoderStream;
     if (typeof global.crypto === 'undefined') {
         // If crypto.subtle is undefined, we're in a Node.js v16 environment
         if (typeof node_crypto_1.default.subtle === 'undefined') {

package/dist/listener.js

@@ -18,17 +18,11 @@ const getRequestListener = (fetchCallback) => {
         const init = {
             method: method,
             headers: headerRecord,
+            // duplex: 'half', should used in nodejs 18
         };
         if (!(method === 'GET' || method === 'HEAD')) {
             // lazy-consume request body
-            init.body = new ReadableStream({
-                start: async (controller) => {
-                    for await (const chunk of incoming) {
-                        controller.enqueue(chunk);
-                    }
-                    controller.close();
-                }
-            });
+            init.body = (0, stream_1.nodeReadableToWebReadableStream)(incoming);
         }
         let res;
         try {

package/dist/stream.d.ts

@@ -1,3 +1,7 @@
 /// <reference types="node" />
-import type { Writable } from 'node:stream';
+import { Writable, Readable } from 'node:stream';
+/** pipeline will assure the backpressure and reduce huge memory usage */
 export declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
+/** This implementation use nodejs Readable::fromWeb as references */
+export declare function webReadableStreamToNodeReadable(stream: ReadableStream): Readable;
+export declare function nodeReadableToWebReadableStream(readable: Readable): ReadableStream<Uint8Array>;

package/dist/stream.js

@@ -1,25 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeReadableStreamToWritable = void 0;
+exports.nodeReadableToWebReadableStream = exports.webReadableStreamToNodeReadable = exports.writeReadableStreamToWritable = void 0;
+const node_stream_1 = require("node:stream");
+const node_util_1 = require("node:util");
+const pipelinePromise = (0, node_util_1.promisify)(node_stream_1.pipeline);
+/** pipeline will assure the backpressure and reduce huge memory usage */
 async function writeReadableStreamToWritable(stream, writable) {
+    const readable = webReadableStreamToNodeReadable(stream);
+    return pipelinePromise(readable, writable);
+}
+exports.writeReadableStreamToWritable = writeReadableStreamToWritable;
+/** This implementation use nodejs Readable::fromWeb as references */
+function webReadableStreamToNodeReadable(stream) {
     const reader = stream.getReader();
-    function onClose() {
-        reader.cancel(new Error('Response writer closed'));
-    }
-    writable.once('close', onClose);
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                writable.end();
+    let closed = false;
+    const readable = new node_stream_1.Readable({
+        read() {
+            reader
+                .read()
+                .then(({ done, value }) => {
+                if (done) {
+                    this.push(null);
+                }
+                else {
+                    this.push(value);
+                }
+            })
+                .catch(e => {
+                readable.destroy(e);
+            });
+        },
+        destroy(error, callback) {
+            const done = () => {
+                try {
+                    callback(error);
+                }
+                catch (err) {
+                    process.nextTick(() => {
+                        throw err;
+                    });
+                }
+            };
+            if (!closed) {
+                reader.cancel(error).then(done, done);
                 return;
             }
-            writable.write(value);
-        }
-    }
-    finally {
-        writable.off('close', onClose);
-        reader.releaseLock();
+            done();
+        },
+    });
+    reader.closed.then(() => {
+        closed = true;
+    }, error => {
+        readable.destroy(error);
+    });
+    return readable;
+}
+exports.webReadableStreamToNodeReadable = webReadableStreamToNodeReadable;
+function nodeReadableToWebReadableStream(readable) {
+    if (readable.destroyed) {
+        const stream = new ReadableStream();
+        stream.cancel();
+        return stream;
     }
+    const highWaterMark = readable.readableHighWaterMark;
+    const strategy = { highWaterMark };
+    let controller;
+    const onData = (chunk) => {
+        // Copy the Buffer to detach it from the pool.
+        if (Buffer.isBuffer(chunk)) {
+            chunk = new Uint8Array(chunk);
+        }
+        controller.enqueue(chunk);
+        if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+            readable.pause();
+        }
+    };
+    readable.pause();
+    const cleanup = (0, node_stream_1.finished)(readable, error => {
+        if (error?.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+            const err = new Error(undefined, { cause: error });
+            Object.defineProperty(err, 'name', 'AbortError');
+            error = err;
+        }
+        cleanup();
+        // This is a protection against non-standard, legacy streams
+        // that happen to emit an error event again after finished is called.
+        readable.on('error', () => { });
+        if (error) {
+            return controller.error(error);
+        }
+        controller.close();
+    });
+    readable.on('data', onData);
+    return new ReadableStream({
+        start(c) {
+            controller = c;
+        },
+        pull() {
+            readable.resume();
+        },
+        cancel(reason) {
+            readable.destroy(reason);
+        },
+    }, strategy);
 }
-exports.writeReadableStreamToWritable = writeReadableStreamToWritable;
+exports.nodeReadableToWebReadableStream = nodeReadableToWebReadableStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "HTTP Server for Hono on Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",