@hono/node-server 0.4.0 → 0.5.1

package/README.md

@@ -77,7 +77,7 @@ app.get('/', (c) => c.json({ 'Hono meets': 'Node.js' }))
 serve(app)
 ```
 
-### Serve Static Middleware
+## Serve Static Middleware
 
 Use Serve Static Middleware that has been created for Node.js.
 
@@ -89,7 +89,23 @@ import { serveStatic } from '@hono/node-server/serve-static'
 app.use('/static/*', serveStatic({ root: './' }))
 ```
 
-Note that `root` must be *relative* to the current working directory - absolute paths are not supported.
+Note that `root` must be _relative_ to the current working directory - absolute paths are not supported.
+
+### Options
+
+#### `rewriteRequestPath`
+
+If you want to serve files in `./.foojs` with the request path `/__foo/*`, you can write like the following.
+
+```ts
+app.use(
+  '/__foo/*',
+  serveStatic({
+    root: './.foojs/',
+    rewriteRequestPath: (path: string) => path.replace(/^\/__foo/, ''),
+  })
+)
+```
 
 ## Related projects
 

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

@@ -9,9 +9,12 @@ const web_stream_1 = require("@remix-run/web-stream");
 const base64_1 = require("./base64");
 const fetch_1 = require("./fetch");
 function installGlobals() {
-    global.atob = base64_1.atob;
-    global.btoa = base64_1.btoa;
-    global.Blob = fetch_1.Blob;
+    if (typeof base64_1.atob === 'undefined')
+        global.atob = base64_1.atob;
+    if (typeof base64_1.btoa === 'undefined')
+        global.btoa = base64_1.btoa;
+    if (typeof Blob === 'undefined')
+        global.Blob = fetch_1.Blob;
     global.File = fetch_1.File;
     global.Headers = fetch_1.Headers;
     global.Request = fetch_1.Request;
@@ -20,8 +23,18 @@ function installGlobals() {
     global.FormData = fetch_1.FormData;
     global.ReadableStream = web_stream_1.ReadableStream;
     global.WritableStream = web_stream_1.WritableStream;
-    if (typeof global.crypto === "undefined") {
-        global.crypto = node_crypto_1.default;
+    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') {
+            // We can use the webcrypto polyfill
+            global.crypto = require('crypto').webcrypto;
+        }
+        else {
+            global.crypto = node_crypto_1.default;
+        }
     }
 }
 exports.installGlobals = installGlobals;

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

@@ -7,5 +7,6 @@ export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
     index?: string;
+    rewriteRequestPath?: (path: string) => string;
 };
 export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/dist/serve-static.js

@@ -11,8 +11,9 @@ const serveStatic = (options = { root: '' }) => {
             await next();
         }
         const url = new URL(c.req.url);
+        const filename = options.path ?? url.pathname;
         let path = (0, filepath_1.getFilePath)({
-            filename: options.path ?? url.pathname,
+            filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
             root: options.root,
             defaultDocument: options.index ?? 'index.html',
         });

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.4.0",
+  "version": "0.5.1",
   "description": "HTTP Server for Hono on Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
     "@types/jest": "^29.0.1",
     "@types/node": "^18.7.16",
     "@types/supertest": "^2.0.12",
-    "hono": "^2.7.1",
+    "hono": "^3.1.5",
     "jest": "^29.0.3",
     "next": "13.1.6",
     "np": "^7.6.2",