@hono/node-server 0.2.0

package/README.md

@@ -0,0 +1,103 @@
+# Hono on Node.js
+
+**`@honojs/node-server` is renamed to `@hono/node-serer` !!**
+
+---
+
+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**.
+**BUT**, there may be a case that you really want to run on Node.js. This library is an adapter server that connects Hono and Node.js.
+
+Hono is ultra fast, but not so fast on Node.js, because there is an overhead to adapt Hono's API to Node.js.
+
+By the way, it is 2.x times faster than Express.
+
+## Install
+
+You can install from npm registry with `npm` command:
+
+```
+npm install @hono/node-server
+```
+
+Or use `yarn`:
+
+```
+yarn add @hono/node-server
+```
+
+## Usage
+
+Just import `@hono/node-server` at the top and write the code as usual.
+The same code that runs on Cloudflare Workers, Deno, and Bun will work.
+
+```ts
+import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
+
+const app = new Hono()
+app.get('/', (c) => c.text('Hono meets Node.js'))
+
+serve(app)
+```
+
+For example, run it using `ts-node`. Then an HTTP server will be launched. The default port is `3000`.
+
+```
+ts-node ./index.ts
+```
+
+Open `http://localhost:3000` with your browser.
+
+## Options
+
+```ts
+serve({
+  fetch: app.fetch,
+  port: 8787, // Port number, default is 3000
+})
+```
+
+## Middleware
+
+Most built-in middleware also works with Node.js.
+Read [the documentation](https://honojs.dev/docs/builtin-middleware/) and use the Middleware of your liking.
+
+```ts
+import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
+import { prettyJSON } from 'hono/pretty-json'
+
+const app = new Hono()
+
+app.get('*', prettyJSON())
+app.get('/', (c) => c.json({ 'Hono meets': 'Node.js' }))
+
+serve(app)
+```
+
+### Serve Static Middleware
+
+Use Serve Static Middleware that has been created for Node.js.
+
+```ts
+import { serve, serveStatic } from '@hono/node-server'
+
+//...
+
+app.use('/static/*', serveStatic({ root: './' }))
+```
+
+## Related projects
+
+- Hono - <https://honojs.dev>
+- Hono GitHub repository - <https://github.com/honojs/hono>
+
+## Author
+
+Yusuke Wada <https://github.com/yusukebe>
+
+## License
+
+MIT

package/dist/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function atob(a: string): string;
+export declare function btoa(b: string): string;

package/dist/base64.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.btoa = exports.atob = void 0;
+function atob(a) {
+    return Buffer.from(a, 'base64').toString('binary');
+}
+exports.atob = atob;
+function btoa(b) {
+    return Buffer.from(b, 'binary').toString('base64');
+}
+exports.btoa = btoa;

package/dist/fetch.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import type { Readable } from 'node:stream';
+import { fetch as webFetch, Headers as WebHeaders, Request as WebRequest, Response as WebResponse } from '@remix-run/web-fetch';
+export { FormData } from '@remix-run/web-fetch';
+export { File, Blob } from '@remix-run/web-file';
+declare type NodeHeadersInit = ConstructorParameters<typeof WebHeaders>[0];
+declare type NodeResponseInit = NonNullable<ConstructorParameters<typeof WebResponse>[1]>;
+declare type NodeRequestInfo = ConstructorParameters<typeof WebRequest>[0] | NodeRequest;
+declare type NodeRequestInit = Omit<NonNullable<ConstructorParameters<typeof WebRequest>[1]>, 'body'> & {
+    body?: NonNullable<ConstructorParameters<typeof WebRequest>[1]>['body'] | Readable;
+};
+export type { NodeHeadersInit as HeadersInit, NodeRequestInfo as RequestInfo, NodeRequestInit as RequestInit, NodeResponseInit as ResponseInit, };
+declare class NodeRequest extends WebRequest {
+    constructor(info: NodeRequestInfo, init?: NodeRequestInit);
+    get headers(): WebHeaders;
+    clone(): NodeRequest;
+}
+declare class NodeResponse extends WebResponse {
+    get headers(): WebHeaders;
+    clone(): NodeResponse;
+}
+export { WebHeaders as Headers, NodeRequest as Request, NodeResponse as Response };
+export declare const fetch: typeof webFetch;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/fetch.ts
+ */

package/dist/fetch.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = exports.Response = exports.Request = exports.Headers = exports.Blob = exports.File = exports.FormData = void 0;
+const web_fetch_1 = require("@remix-run/web-fetch");
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return web_fetch_1.Headers; } });
+var web_fetch_2 = require("@remix-run/web-fetch");
+Object.defineProperty(exports, "FormData", { enumerable: true, get: function () { return web_fetch_2.FormData; } });
+var web_file_1 = require("@remix-run/web-file");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return web_file_1.File; } });
+Object.defineProperty(exports, "Blob", { enumerable: true, get: function () { return web_file_1.Blob; } });
+class NodeRequest extends web_fetch_1.Request {
+    constructor(info, init) {
+        super(info, init);
+    }
+    get headers() {
+        return super.headers;
+    }
+    // @ts-ignore
+    clone() {
+        return new NodeRequest(this);
+    }
+}
+exports.Request = NodeRequest;
+class NodeResponse extends web_fetch_1.Response {
+    get headers() {
+        return super.headers;
+    }
+    clone() {
+        return super.clone();
+    }
+}
+exports.Response = NodeResponse;
+const 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 (0, web_fetch_1.fetch)(info, init);
+};
+exports.fetch = fetch;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/fetch.ts
+ */

package/dist/globals.d.ts

@@ -0,0 +1,27 @@
+import { atob, btoa } from './base64';
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv {
+            NODE_ENV: 'development' | 'production' | 'test';
+        }
+        interface Global {
+            atob: typeof atob;
+            btoa: typeof btoa;
+            Blob: typeof Blob;
+            File: typeof File;
+            Headers: typeof Headers;
+            Request: typeof Request;
+            Response: typeof Response;
+            fetch: typeof fetch;
+            FormData: typeof FormData;
+            ReadableStream: typeof ReadableStream;
+            WritableStream: typeof WritableStream;
+            crypto: Crypto;
+        }
+    }
+}
+export declare function installGlobals(): void;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/globals.ts
+ */

package/dist/globals.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installGlobals = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+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;
+    global.File = fetch_1.File;
+    global.Headers = fetch_1.Headers;
+    global.Request = fetch_1.Request;
+    global.Response = fetch_1.Response;
+    global.fetch = fetch_1.fetch;
+    global.FormData = fetch_1.FormData;
+    global.ReadableStream = web_stream_1.ReadableStream;
+    global.WritableStream = web_stream_1.WritableStream;
+    global.crypto = node_crypto_1.default;
+}
+exports.installGlobals = installGlobals;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/globals.ts
+ */

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { serve } from './server';
+export { serveStatic } from './serve-static';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = exports.serve = void 0;
+var server_1 = require("./server");
+Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return server_1.serve; } });
+var serve_static_1 = require("./serve-static");
+Object.defineProperty(exports, "serveStatic", { enumerable: true, get: function () { return serve_static_1.serveStatic; } });

package/dist/serve-static.d.ts

@@ -0,0 +1,8 @@
+import type { Next } from 'hono';
+import { Context } from 'hono';
+export declare type ServeStaticOptions = {
+    root?: string;
+    path?: string;
+    index?: string;
+};
+export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/dist/serve-static.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const fs_1 = require("fs");
+const filepath_1 = require("hono/utils/filepath");
+const mime_1 = require("hono/utils/mime");
+const serveStatic = (options = { root: '' }) => {
+    return async (c, next) => {
+        // Do nothing if Response is already set
+        if (c.finalized) {
+            await next();
+        }
+        const url = new URL(c.req.url);
+        let path = (0, filepath_1.getFilePath)({
+            filename: options.path ?? url.pathname,
+            root: options.root,
+            defaultDocument: options.index ?? 'index.html',
+        });
+        path = `./${path}`;
+        if ((0, fs_1.existsSync)(path)) {
+            const content = (0, fs_1.readFileSync)(path);
+            if (content) {
+                const mimeType = (0, mime_1.getMimeType)(path);
+                if (mimeType) {
+                    c.header('Content-Type', mimeType);
+                }
+                // Return Response object
+                return c.body(content);
+            }
+        }
+        console.warn(`Static file: ${path} is not found`);
+        await next();
+        return;
+    };
+};
+exports.serveStatic = serveStatic;

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { Server } from 'node:http';
+declare type FetchCallback = (request: Request) => Promise<unknown> | unknown;
+declare type Options = {
+    fetch: FetchCallback;
+    port?: number;
+    serverOptions?: Object;
+};
+export declare const createAdaptorServer: (options: Options) => Server;
+export declare const serve: (options: Options) => Server;
+export {};

package/dist/server.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serve = exports.createAdaptorServer = void 0;
+const node_http_1 = require("node:http");
+const fetch_1 = require("./fetch");
+const stream_1 = require("./stream");
+const globals_1 = require("./globals");
+(0, globals_1.installGlobals)();
+const createAdaptorServer = (options) => {
+    const fetchCallback = options.fetch;
+    const requestListener = getRequestListener(fetchCallback);
+    const server = (0, node_http_1.createServer)(options.serverOptions || {}, requestListener);
+    return server;
+};
+exports.createAdaptorServer = createAdaptorServer;
+const serve = (options) => {
+    const server = (0, exports.createAdaptorServer)(options);
+    server.listen(options.port || 3000);
+    return server;
+};
+exports.serve = serve;
+const 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++) {
+            if (i % 2 === 0) {
+                const key = incoming.rawHeaders[i];
+                headerRecord[key] = incoming.rawHeaders[i + 1];
+            }
+        }
+        const init = {
+            method: method,
+            headers: headerRecord,
+        };
+        if (!(method === 'GET' || method === 'HEAD')) {
+            const buffers = [];
+            for await (const chunk of incoming) {
+                buffers.push(chunk);
+            }
+            const buffer = Buffer.concat(buffers);
+            init['body'] = buffer;
+        }
+        let res;
+        try {
+            res = (await fetchCallback(new Request(url.toString(), init)));
+        }
+        catch {
+            res = new fetch_1.Response(null, { status: 500 });
+        }
+        const contentType = res.headers.get('content-type') || '';
+        const contentEncoding = res.headers.get('content-encoding');
+        for (const [k, v] of res.headers) {
+            if (k === 'set-cookie') {
+                outgoing.setHeader(k, res.headers.getAll(k));
+            }
+            else {
+                outgoing.setHeader(k, v);
+            }
+        }
+        outgoing.statusCode = res.status;
+        if (res.body) {
+            if (!contentEncoding && contentType.startsWith('text')) {
+                outgoing.end(await res.text());
+            }
+            else if (!contentEncoding && contentType.startsWith('application/json')) {
+                outgoing.end(await res.text());
+            }
+            else {
+                await (0, stream_1.writeReadableStreamToWritable)(res.body, outgoing);
+            }
+        }
+        else {
+            outgoing.end();
+        }
+    };
+};

package/dist/stream.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { Writable } from 'node:stream';
+export declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/stream.ts
+ */

package/dist/stream.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeReadableStreamToWritable = void 0;
+async function writeReadableStreamToWritable(stream, writable) {
+    let reader = stream.getReader();
+    async function read() {
+        let { done, value } = await reader.read();
+        if (done) {
+            writable.end();
+            return;
+        }
+        writable.write(value);
+        await read();
+    }
+    try {
+        await read();
+    }
+    catch (error) {
+        writable.destroy(error);
+        throw error;
+    }
+}
+exports.writeReadableStreamToWritable = writeReadableStreamToWritable;
+/**
+ * Credits:
+ *   - https://github.com/remix-run/remix/blob/e77e2eb/packages/remix-node/stream.ts
+ */

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@hono/node-server",
+  "version": "0.2.0",
+  "description": "HTTP Server for Hono on Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "rimraf dist && tsc",
+    "prerelease": "yarn build && yarn test",
+    "release": "np"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hono/node-server.git"
+  },
+  "homepage": "https://github.com/hono/node-server",
+  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "@remix-run/web-fetch": "^4.2.0",
+    "@remix-run/web-file": "^3.0.2",
+    "@remix-run/web-stream": "^1.0.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.1",
+    "@types/node": "^18.7.16",
+    "@types/supertest": "^2.0.12",
+    "hono": "^2.7.1",
+    "jest": "^29.0.3",
+    "np": "^7.6.2",
+    "rimraf": "^3.0.2",
+    "supertest": "^6.2.4",
+    "ts-jest": "^29.0.0",
+    "typescript": "^4.8.3"
+  }
+}