@hono/node-server 0.5.0 → 0.6.0

package/README.md

@@ -1,9 +1,5 @@
 # Hono on Node.js
 
-**`@honojs/node-server` is renamed to `@hono/node-server` !!**
-
----
-
 This is **HTTP Server for Hono on Node.js**.
 Hono is ultrafast web framework for Cloudflare Workers, Deno, and Bun.
 **It's not for Node.js**.
@@ -39,7 +35,9 @@ import { Hono } from 'hono'
 const app = new Hono()
 app.get('/', (c) => c.text('Hono meets Node.js'))
 
-serve(app)
+serve(app, (info) => {
+  console.log(`Listening on http://localhost:${info.port}`) // Listening on http://localhost:3000
+})
 ```
 
 For example, run it using `ts-node`. Then an HTTP server will be launched. The default port is `3000`.
@@ -52,6 +50,8 @@ Open `http://localhost:3000` with your browser.
 
 ## Options
 
+### `port`
+
 ```ts
 serve({
   fetch: app.fetch,
@@ -59,6 +59,24 @@ serve({
 })
 ```
 
+### `createServer`
+
+```ts
+import { createServer } from 'node:https'
+import fs from 'node:fs'
+
+//...
+
+serve({
+  fetch: app.fetch,
+  createServer: createServer,
+  serverOptions: {
+    key: fs.readFileSync('test/fixtures/keys/agent1-key.pem'),
+    cert: fs.readFileSync('test/fixtures/keys/agent1-cert.pem'),
+  },
+})
+```
+
 ## Middleware
 
 Most built-in middleware also works with Node.js.

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/server.d.ts

@@ -1,4 +1,5 @@
 import { Server } from 'node:http';
 import { Options } from './types';
+import type { AddressInfo } from 'node:net';
 export declare const createAdaptorServer: (options: Options) => Server;
-export declare const serve: (options: Options) => Server;
+export declare const serve: (options: Options, listeningListener?: ((info: AddressInfo) => void) | undefined) => Server;

package/dist/server.js

@@ -8,13 +8,17 @@ const listener_1 = require("./listener");
 const createAdaptorServer = (options) => {
     const fetchCallback = options.fetch;
     const requestListener = (0, listener_1.getRequestListener)(fetchCallback);
-    const server = (0, node_http_1.createServer)(options.serverOptions || {}, requestListener);
+    const createServer = options.createServer || node_http_1.createServer;
+    const server = createServer(options.serverOptions || {}, requestListener);
     return server;
 };
 exports.createAdaptorServer = createAdaptorServer;
-const serve = (options) => {
+const serve = (options, listeningListener) => {
     const server = (0, exports.createAdaptorServer)(options);
-    server.listen(options.port || 3000, options.hostname || '0.0.0.0');
+    server.listen(options?.port ?? 3000, options.hostname ?? '0.0.0.0', () => {
+        const serverInfo = server.address();
+        listeningListener && listeningListener(serverInfo);
+    });
     return server;
 };
 exports.serve = serve;

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/dist/types.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import type { Hono } from 'hono';
 import type { NextApiHandler } from 'next/types';
+import type { createServer } from 'node:http';
 export declare type FetchCallback = (request: Request) => Promise<unknown> | unknown;
 export declare type NextHandlerOption = {
     fetch: FetchCallback;
@@ -9,6 +11,7 @@ export declare type Options = {
     port?: number;
     hostname?: string;
     serverOptions?: Object;
+    createServer?: typeof createServer;
 };
 export interface HandleInterface {
     <E extends Hono<any, any>>(subApp: E, path?: string): NextApiHandler;

package/package.json

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