react-router-hono-server 2.1.1 → 2.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +126 -11
- package/dist/adapters/bun.d.ts +31 -0
- package/dist/adapters/{bun.mjs → bun.js} +35 -17
- package/dist/adapters/{cloudflare.d.mts → cloudflare.d.ts} +4 -2
- package/dist/adapters/{cloudflare.mjs → cloudflare.js} +18 -12
- package/dist/adapters/{node.d.mts → node.d.ts} +14 -5
- package/dist/adapters/{node.mjs → node.js} +35 -17
- package/dist/chunk-27A6I7NN.js +71 -0
- package/dist/{dev.d.mts → dev.d.ts} +2 -1
- package/dist/{dev.mjs → dev.js} +5 -4
- package/dist/hono-server-options-base.d-XkJeTOq3.d.ts +86 -0
- package/dist/{middleware.mjs → middleware.js} +1 -1
- package/package.json +24 -19
- package/dist/adapters/bun.d.mts +0 -107
- package/dist/hono-server-options-base.d-DChVrA1u.d.mts +0 -54
- /package/dist/{chunk-ENK5WJB4.mjs → chunk-V3H4JZ4H.js} +0 -0
- /package/dist/{cli.mjs → cli.js} +0 -0
- /package/dist/{middleware.d.mts → middleware.d.ts} +0 -0
package/README.md
CHANGED
|
@@ -48,6 +48,9 @@ Install the following npm package.
|
|
|
48
48
|
|
|
49
49
|
```bash
|
|
50
50
|
npm install react-router-hono-server
|
|
51
|
+
|
|
52
|
+
# For Cloudflare Workers, add the following
|
|
53
|
+
npm install -D miniflare wrangler
|
|
51
54
|
```
|
|
52
55
|
|
|
53
56
|
> [!TIP]
|
|
@@ -98,7 +101,7 @@ Ok, by default it works, but you may want to customize the server and use some m
|
|
|
98
101
|
|
|
99
102
|
#### Node
|
|
100
103
|
> [!TIP]
|
|
101
|
-
> Check this [example](./examples/
|
|
104
|
+
> Check this [example](./examples/node/simple/) to see how to use it.
|
|
102
105
|
|
|
103
106
|
```ts
|
|
104
107
|
// vite.config.ts
|
|
@@ -118,7 +121,7 @@ export default defineConfig({
|
|
|
118
121
|
|
|
119
122
|
#### Bun
|
|
120
123
|
> [!TIP]
|
|
121
|
-
> Check this [example](./examples/
|
|
124
|
+
> Check this [example](./examples/bun/simple/) to see how to use it.
|
|
122
125
|
|
|
123
126
|
```ts
|
|
124
127
|
// vite.config.ts
|
|
@@ -138,7 +141,7 @@ export default defineConfig({
|
|
|
138
141
|
|
|
139
142
|
#### Cloudflare Workers
|
|
140
143
|
> [!TIP]
|
|
141
|
-
> Check this [example](./examples/
|
|
144
|
+
> Check this [example](./examples/cloudflare/simple/) to see how to use it.
|
|
142
145
|
|
|
143
146
|
> [!IMPORTANT]
|
|
144
147
|
> You need to add the `cloudflareDevProxy` plugin to use the Cloudflare Workers runtime on dev.
|
|
@@ -310,6 +313,12 @@ type ReactRouterHonoServerPluginOptions = {
|
|
|
310
313
|
##### All adapters
|
|
311
314
|
```ts
|
|
312
315
|
export type HonoServerOptions<E extends Env = BlankEnv> = {
|
|
316
|
+
/**
|
|
317
|
+
* Hono app to use
|
|
318
|
+
*
|
|
319
|
+
* {@link Hono}
|
|
320
|
+
*/
|
|
321
|
+
app?: Hono<E>;
|
|
313
322
|
/**
|
|
314
323
|
* Enable the default logger
|
|
315
324
|
*
|
|
@@ -357,12 +366,6 @@ export type HonoServerOptions<E extends Env = BlankEnv> = {
|
|
|
357
366
|
* Defaults log the port
|
|
358
367
|
*/
|
|
359
368
|
listeningListener?: (info: AddressInfo) => void;
|
|
360
|
-
/**
|
|
361
|
-
* Hono constructor options
|
|
362
|
-
*
|
|
363
|
-
* {@link HonoOptions}
|
|
364
|
-
*/
|
|
365
|
-
honoOptions?: HonoOptions<E>;
|
|
366
369
|
};
|
|
367
370
|
```
|
|
368
371
|
|
|
@@ -431,6 +434,14 @@ export interface HonoServerOptions<E extends Env = BlankEnv> extends HonoServerO
|
|
|
431
434
|
* {@link https://hono.dev/docs/getting-started/nodejs#http2}
|
|
432
435
|
*/
|
|
433
436
|
customNodeServer?: CreateNodeServerOptions;
|
|
437
|
+
/**
|
|
438
|
+
* Callback executed just after `serve` from `@hono/node-server`
|
|
439
|
+
*
|
|
440
|
+
* **Only applied to production mode**
|
|
441
|
+
*
|
|
442
|
+
* For example, you can use this to bind `@hono/node-ws`'s `injectWebSocket`
|
|
443
|
+
*/
|
|
444
|
+
onServe?: (server: ServerType) => void;
|
|
434
445
|
}
|
|
435
446
|
```
|
|
436
447
|
|
|
@@ -530,6 +541,110 @@ export default await createHonoServer({
|
|
|
530
541
|
});
|
|
531
542
|
```
|
|
532
543
|
|
|
544
|
+
### Using WebSockets
|
|
545
|
+
#### Node
|
|
546
|
+
This package has a built-in helper to use `@hono/node-ws`
|
|
547
|
+
|
|
548
|
+
> [!TIP]
|
|
549
|
+
> Check this [example](./examples/node/websocket/) to see how to use it.
|
|
550
|
+
|
|
551
|
+
```ts
|
|
552
|
+
import type { WSContext } from "hono/ws";
|
|
553
|
+
import { createHonoServer } from "react-router-hono-server/node";
|
|
554
|
+
|
|
555
|
+
// Store connected clients
|
|
556
|
+
const clients = new Set<WSContext>();
|
|
557
|
+
|
|
558
|
+
export default await createHonoServer({
|
|
559
|
+
useWebSocket: true,
|
|
560
|
+
// 👆 Unlock this 👇 from @hono/node-ws
|
|
561
|
+
configure: (app, { upgradeWebSocket }) => {
|
|
562
|
+
app.get(
|
|
563
|
+
"/ws",
|
|
564
|
+
upgradeWebSocket((c) => ({
|
|
565
|
+
// https://hono.dev/helpers/websocket
|
|
566
|
+
onOpen(_, ws) {
|
|
567
|
+
console.log("New connection ⬆️");
|
|
568
|
+
clients.add(ws);
|
|
569
|
+
},
|
|
570
|
+
onMessage(event, ws) {
|
|
571
|
+
console.log("Context", c.req.header("Cookie"));
|
|
572
|
+
console.log("Event", event);
|
|
573
|
+
console.log(`Message from client: ${event.data}`);
|
|
574
|
+
// Broadcast to all clients except sender
|
|
575
|
+
clients.forEach((client) => {
|
|
576
|
+
if (client.readyState === 1) {
|
|
577
|
+
client.send(`${event.data}`);
|
|
578
|
+
}
|
|
579
|
+
});
|
|
580
|
+
},
|
|
581
|
+
onClose(_, ws) {
|
|
582
|
+
console.log("Connection closed");
|
|
583
|
+
clients.delete(ws);
|
|
584
|
+
},
|
|
585
|
+
}))
|
|
586
|
+
);
|
|
587
|
+
},
|
|
588
|
+
});
|
|
589
|
+
```
|
|
590
|
+
|
|
591
|
+
#### Bun
|
|
592
|
+
This package has a built-in helper to use `hono/bun` in prod and `@hono/node-ws` in dev
|
|
593
|
+
|
|
594
|
+
> [!TIP]
|
|
595
|
+
> Check this [example](./examples/bun/websocket/) to see how to use it.
|
|
596
|
+
|
|
597
|
+
```ts
|
|
598
|
+
import { WSContext } from "hono/ws";
|
|
599
|
+
import { createHonoServer } from "react-router-hono-server/bun";
|
|
600
|
+
|
|
601
|
+
// Store connected clients
|
|
602
|
+
const clients = new Set<WSContext>();
|
|
603
|
+
|
|
604
|
+
export default await createHonoServer({
|
|
605
|
+
useWebSocket: true,
|
|
606
|
+
// 👆 Unlock this 👇 from @hono/node-ws in dev, hono/bun in prod
|
|
607
|
+
configure(app, { upgradeWebSocket }) {
|
|
608
|
+
app.get(
|
|
609
|
+
"/ws",
|
|
610
|
+
upgradeWebSocket((c) => ({
|
|
611
|
+
// https://hono.dev/helpers/websocket
|
|
612
|
+
onOpen(_, ws) {
|
|
613
|
+
console.log("New connection 🔥");
|
|
614
|
+
clients.add(ws);
|
|
615
|
+
},
|
|
616
|
+
onMessage(event, ws) {
|
|
617
|
+
console.log("Context", c.req.header("Cookie"));
|
|
618
|
+
console.log("Event", event);
|
|
619
|
+
console.log(`Message from client: ${event.data}`);
|
|
620
|
+
// Broadcast to all clients except sender
|
|
621
|
+
clients.forEach((client) => {
|
|
622
|
+
if (client.readyState === 1) {
|
|
623
|
+
client.send(`${event.data}`);
|
|
624
|
+
}
|
|
625
|
+
});
|
|
626
|
+
},
|
|
627
|
+
onClose(_, ws) {
|
|
628
|
+
console.log("Connection closed");
|
|
629
|
+
clients.delete(ws);
|
|
630
|
+
},
|
|
631
|
+
}))
|
|
632
|
+
);
|
|
633
|
+
},
|
|
634
|
+
});
|
|
635
|
+
```
|
|
636
|
+
|
|
637
|
+
#### Cloudflare Workers
|
|
638
|
+
Cloudflare requires a different approach to WebSockets, based on Durable Objects.
|
|
639
|
+
|
|
640
|
+
> [!TIP]
|
|
641
|
+
> Check this [example](./examples/cloudflare/websocket/) to see how to use it.
|
|
642
|
+
|
|
643
|
+
> [!IMPORTANT]
|
|
644
|
+
> For now, HMR is not supported in Cloudflare Workers. Will try to come back to it later.
|
|
645
|
+
>
|
|
646
|
+
> Work in progress on Cloudflare team: https://github.com/flarelabs-net/vite-plugin-cloudflare
|
|
647
|
+
|
|
533
648
|
### Migrate from v1
|
|
534
649
|
_You should not expect any breaking changes._
|
|
535
650
|
|
|
@@ -591,9 +706,9 @@ Many options are gone or have changed.
|
|
|
591
706
|
##### You used `buildEnd` from `remix()` plugin or a custom `buildDirectory` option
|
|
592
707
|
You may know that it has been moved to `react-router.config.ts` (see [here](https://reactrouter.com/upgrading/remix#5-add-a-react-router-config) for more information).
|
|
593
708
|
|
|
594
|
-
If you used this hook for Sentry, check this [example](./examples/
|
|
709
|
+
If you used this hook for Sentry, check this [example](./examples/node/with-sentry/react-router.config.ts) to see how to migrate.
|
|
595
710
|
|
|
596
|
-
If you used a custom `buildDirectory` option, check this [example](./examples/
|
|
711
|
+
If you used a custom `buildDirectory` option, check this [example](./examples/node/custom-build/react-router.config.ts) to see how to migrate.
|
|
597
712
|
|
|
598
713
|
#### Update your package.json scripts
|
|
599
714
|
```json
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import { Serve, ServeOptions } from 'bun';
|
|
2
|
+
import { Env } from 'hono';
|
|
3
|
+
import { BlankEnv } from 'hono/types';
|
|
4
|
+
import { W as WithWebsocket, a as WithoutWebsocket, H as HonoServerOptionsBase } from '../hono-server-options-base.d-XkJeTOq3.js';
|
|
5
|
+
import 'hono/hono-base';
|
|
6
|
+
import 'hono/ws';
|
|
7
|
+
import 'react-router';
|
|
8
|
+
|
|
9
|
+
type CustomBunServer = Serve & ServeOptions & {
|
|
10
|
+
websocket?: unknown;
|
|
11
|
+
};
|
|
12
|
+
interface HonoBunServerOptions<E extends Env = BlankEnv> extends HonoServerOptionsBase<E> {
|
|
13
|
+
/**
|
|
14
|
+
* Customize the bun server
|
|
15
|
+
*
|
|
16
|
+
* {@link https://bun.sh/docs/api/http#start-a-server-bun-serve}
|
|
17
|
+
*/
|
|
18
|
+
customBunServer?: Partial<CustomBunServer>;
|
|
19
|
+
}
|
|
20
|
+
type HonoServerOptionsWithWebSocket<E extends Env = BlankEnv> = HonoBunServerOptions<E> & WithWebsocket<E>;
|
|
21
|
+
type HonoServerOptionsWithoutWebSocket<E extends Env = BlankEnv> = HonoBunServerOptions<E> & WithoutWebsocket<E>;
|
|
22
|
+
type HonoServerOptions<E extends Env = BlankEnv> = HonoServerOptionsWithWebSocket<E> | HonoServerOptionsWithoutWebSocket<E>;
|
|
23
|
+
/**
|
|
24
|
+
* Create a Hono server
|
|
25
|
+
*
|
|
26
|
+
* @param HonoServerOptions options {@link HonoServerOptions} - The configuration options for the server
|
|
27
|
+
*/
|
|
28
|
+
declare function createHonoServer<E extends Env = BlankEnv>(options?: HonoServerOptionsWithoutWebSocket<E>): Promise<CustomBunServer>;
|
|
29
|
+
declare function createHonoServer<E extends Env = BlankEnv>(options?: HonoServerOptionsWithWebSocket<E>): Promise<CustomBunServer>;
|
|
30
|
+
|
|
31
|
+
export { type HonoServerOptions, createHonoServer };
|
|
@@ -1,6 +1,11 @@
|
|
|
1
|
+
import {
|
|
2
|
+
cleanUpgradeListeners,
|
|
3
|
+
createWebSocket,
|
|
4
|
+
patchUpgradeListener
|
|
5
|
+
} from "../chunk-27A6I7NN.js";
|
|
1
6
|
import {
|
|
2
7
|
cache
|
|
3
|
-
} from "../chunk-
|
|
8
|
+
} from "../chunk-V3H4JZ4H.js";
|
|
4
9
|
|
|
5
10
|
// src/adapters/bun.ts
|
|
6
11
|
import { Hono } from "hono";
|
|
@@ -8,30 +13,36 @@ import { serveStatic } from "hono/bun";
|
|
|
8
13
|
import { createMiddleware } from "hono/factory";
|
|
9
14
|
import { logger } from "hono/logger";
|
|
10
15
|
import { createRequestHandler } from "react-router";
|
|
11
|
-
async function createHonoServer(options
|
|
16
|
+
async function createHonoServer(options) {
|
|
12
17
|
const mergedOptions = {
|
|
13
18
|
...options,
|
|
14
|
-
port: options
|
|
15
|
-
defaultLogger: options
|
|
19
|
+
port: options?.port || Number(options?.customBunServer?.port) || Number(process.env.PORT) || 3e3,
|
|
20
|
+
defaultLogger: options?.defaultLogger ?? true
|
|
16
21
|
};
|
|
17
|
-
const mode = import.meta.env.MODE;
|
|
22
|
+
const mode = import.meta.env.MODE || "production";
|
|
18
23
|
const PRODUCTION = mode === "production";
|
|
19
|
-
const
|
|
24
|
+
const app = new Hono(mergedOptions.honoOptions || mergedOptions.app);
|
|
20
25
|
const clientBuildPath = `${import.meta.env.REACT_ROUTER_HONO_SERVER_BUILD_DIRECTORY}/client`;
|
|
21
|
-
|
|
26
|
+
const { upgradeWebSocket, injectWebSocket } = await createWebSocket({
|
|
27
|
+
app,
|
|
28
|
+
enabled: mergedOptions.useWebSocket ?? false
|
|
29
|
+
});
|
|
30
|
+
app.use(
|
|
22
31
|
`/${import.meta.env.REACT_ROUTER_HONO_SERVER_ASSETS_DIR}/*`,
|
|
23
32
|
cache(60 * 60 * 24 * 365),
|
|
24
33
|
// 1 year
|
|
25
34
|
serveStatic({ root: clientBuildPath })
|
|
26
35
|
);
|
|
27
|
-
|
|
36
|
+
app.use("*", cache(60 * 60), serveStatic({ root: PRODUCTION ? clientBuildPath : "./public" }));
|
|
28
37
|
if (mergedOptions.defaultLogger) {
|
|
29
|
-
|
|
38
|
+
app.use("*", logger());
|
|
30
39
|
}
|
|
31
|
-
if (mergedOptions.
|
|
32
|
-
await mergedOptions.configure(
|
|
40
|
+
if (mergedOptions.useWebSocket) {
|
|
41
|
+
await mergedOptions.configure(app, { upgradeWebSocket });
|
|
42
|
+
} else {
|
|
43
|
+
await mergedOptions.configure?.(app);
|
|
33
44
|
}
|
|
34
|
-
|
|
45
|
+
app.use(async (c, next) => {
|
|
35
46
|
const build = await import(
|
|
36
47
|
// @ts-expect-error - Virtual module provided by React Router at build time
|
|
37
48
|
"virtual:react-router/server-build"
|
|
@@ -42,15 +53,22 @@ async function createHonoServer(options = {}) {
|
|
|
42
53
|
return requestHandler(c2.req.raw, loadContext instanceof Promise ? await loadContext : loadContext);
|
|
43
54
|
})(c, next);
|
|
44
55
|
});
|
|
45
|
-
|
|
46
|
-
console.log("\u{1F6A7} Running in development mode");
|
|
47
|
-
}
|
|
48
|
-
return {
|
|
56
|
+
let server = {
|
|
49
57
|
...mergedOptions.customBunServer,
|
|
50
|
-
fetch:
|
|
58
|
+
fetch: app.fetch,
|
|
51
59
|
port: mergedOptions.port,
|
|
52
60
|
development: !PRODUCTION
|
|
53
61
|
};
|
|
62
|
+
if (PRODUCTION) {
|
|
63
|
+
server = injectWebSocket(server);
|
|
64
|
+
} else if (globalThis.__viteDevServer?.httpServer) {
|
|
65
|
+
const httpServer = globalThis.__viteDevServer.httpServer;
|
|
66
|
+
cleanUpgradeListeners(httpServer);
|
|
67
|
+
injectWebSocket(httpServer);
|
|
68
|
+
patchUpgradeListener(httpServer);
|
|
69
|
+
console.log("\u{1F6A7} Running in development mode");
|
|
70
|
+
}
|
|
71
|
+
return server;
|
|
54
72
|
}
|
|
55
73
|
export {
|
|
56
74
|
createHonoServer
|
|
@@ -1,12 +1,14 @@
|
|
|
1
1
|
import * as hono_types from 'hono/types';
|
|
2
2
|
import { BlankEnv } from 'hono/types';
|
|
3
3
|
import { Env, Hono } from 'hono';
|
|
4
|
-
import { H as HonoServerOptionsBase } from '../hono-server-options-base.d-
|
|
4
|
+
import { a as WithoutWebsocket, H as HonoServerOptionsBase } from '../hono-server-options-base.d-XkJeTOq3.js';
|
|
5
5
|
import 'hono/hono-base';
|
|
6
|
+
import 'hono/ws';
|
|
6
7
|
import 'react-router';
|
|
7
8
|
|
|
8
|
-
interface
|
|
9
|
+
interface HonoCloudflareOptions<E extends Env = BlankEnv> extends HonoServerOptionsBase<E> {
|
|
9
10
|
}
|
|
11
|
+
type HonoServerOptions<E extends Env = BlankEnv> = HonoCloudflareOptions<E> & Omit<WithoutWebsocket<E>, "useWebSocket">;
|
|
10
12
|
/**
|
|
11
13
|
* Create a Hono server
|
|
12
14
|
*
|
|
@@ -1,23 +1,29 @@
|
|
|
1
|
+
import {
|
|
2
|
+
cache
|
|
3
|
+
} from "../chunk-V3H4JZ4H.js";
|
|
4
|
+
|
|
1
5
|
// src/adapters/cloudflare.ts
|
|
2
6
|
import { Hono } from "hono";
|
|
3
7
|
import { createMiddleware } from "hono/factory";
|
|
4
8
|
import { logger } from "hono/logger";
|
|
5
9
|
import { createRequestHandler } from "react-router";
|
|
6
|
-
async function createHonoServer(options
|
|
10
|
+
async function createHonoServer(options) {
|
|
7
11
|
const mergedOptions = {
|
|
8
12
|
...options,
|
|
9
|
-
defaultLogger: options
|
|
13
|
+
defaultLogger: options?.defaultLogger ?? true
|
|
10
14
|
};
|
|
11
|
-
const mode = import.meta.env.MODE;
|
|
12
|
-
const
|
|
13
|
-
const
|
|
14
|
-
if (
|
|
15
|
-
|
|
15
|
+
const mode = import.meta.env.MODE || "production";
|
|
16
|
+
const DEV = mode === "development";
|
|
17
|
+
const app = new Hono(mergedOptions.honoOptions || mergedOptions.app);
|
|
18
|
+
if (DEV) {
|
|
19
|
+
const { serveStatic } = await import("@hono/node-server/serve-static");
|
|
20
|
+
app.use("*", cache(60 * 60), serveStatic({ root: "./public" }));
|
|
16
21
|
}
|
|
17
|
-
if (mergedOptions.
|
|
18
|
-
|
|
22
|
+
if (mergedOptions.defaultLogger) {
|
|
23
|
+
app.use("*", logger());
|
|
19
24
|
}
|
|
20
|
-
|
|
25
|
+
await mergedOptions.configure?.(app);
|
|
26
|
+
app.use(async (c, next) => {
|
|
21
27
|
const build = await import(
|
|
22
28
|
// @ts-expect-error - Virtual module provided by React Router at build time
|
|
23
29
|
"virtual:react-router/server-build"
|
|
@@ -28,10 +34,10 @@ async function createHonoServer(options = {}) {
|
|
|
28
34
|
return requestHandler(c2.req.raw, loadContext instanceof Promise ? await loadContext : loadContext);
|
|
29
35
|
})(c, next);
|
|
30
36
|
});
|
|
31
|
-
if (
|
|
37
|
+
if (DEV) {
|
|
32
38
|
console.log("\u{1F6A7} Running in development mode");
|
|
33
39
|
}
|
|
34
|
-
return
|
|
40
|
+
return app;
|
|
35
41
|
}
|
|
36
42
|
export {
|
|
37
43
|
createHonoServer
|
|
@@ -1,12 +1,13 @@
|
|
|
1
|
-
import * as hono_types from 'hono/types';
|
|
2
|
-
import { BlankEnv } from 'hono/types';
|
|
3
1
|
import { AddressInfo } from 'node:net';
|
|
2
|
+
import { ServerType } from '@hono/node-server';
|
|
4
3
|
import { Env, Hono } from 'hono';
|
|
5
|
-
import {
|
|
4
|
+
import { BlankEnv } from 'hono/types';
|
|
5
|
+
import { W as WithWebsocket, a as WithoutWebsocket, H as HonoServerOptionsBase } from '../hono-server-options-base.d-XkJeTOq3.js';
|
|
6
6
|
import { ServerOptions, createServer } from 'node:http';
|
|
7
7
|
import { ServerOptions as ServerOptions$2, createServer as createServer$2, SecureServerOptions, createSecureServer } from 'node:http2';
|
|
8
8
|
import { ServerOptions as ServerOptions$1, createServer as createServer$1 } from 'node:https';
|
|
9
9
|
import 'hono/hono-base';
|
|
10
|
+
import 'hono/ws';
|
|
10
11
|
import 'react-router';
|
|
11
12
|
|
|
12
13
|
type createHttpOptions = {
|
|
@@ -31,7 +32,7 @@ type CreateNodeServerOptions =
|
|
|
31
32
|
| createHttp2Options
|
|
32
33
|
| createSecureHttp2Options;
|
|
33
34
|
|
|
34
|
-
interface
|
|
35
|
+
interface HonoNodeServerOptions<E extends Env = BlankEnv> extends HonoServerOptionsBase<E> {
|
|
35
36
|
/**
|
|
36
37
|
* Listening listener (production mode only)
|
|
37
38
|
*
|
|
@@ -46,12 +47,20 @@ interface HonoServerOptions<E extends Env = BlankEnv> extends HonoServerOptionsB
|
|
|
46
47
|
* {@link https://hono.dev/docs/getting-started/nodejs#http2}
|
|
47
48
|
*/
|
|
48
49
|
customNodeServer?: CreateNodeServerOptions;
|
|
50
|
+
/**
|
|
51
|
+
* Callback executed just after `serve` from `@hono/node-server`
|
|
52
|
+
*/
|
|
53
|
+
onServe?: (server: ServerType) => void;
|
|
49
54
|
}
|
|
55
|
+
type HonoServerOptionsWithWebSocket<E extends Env = BlankEnv> = HonoNodeServerOptions<E> & WithWebsocket<E>;
|
|
56
|
+
type HonoServerOptionsWithoutWebSocket<E extends Env = BlankEnv> = HonoNodeServerOptions<E> & WithoutWebsocket<E>;
|
|
57
|
+
type HonoServerOptions<E extends Env = BlankEnv> = HonoServerOptionsWithWebSocket<E> | HonoServerOptionsWithoutWebSocket<E>;
|
|
50
58
|
/**
|
|
51
59
|
* Create a Hono server
|
|
52
60
|
*
|
|
53
61
|
* @param config {@link HonoServerOptions} - The configuration options for the server
|
|
54
62
|
*/
|
|
55
|
-
declare function createHonoServer<E extends Env = BlankEnv>(options?:
|
|
63
|
+
declare function createHonoServer<E extends Env = BlankEnv>(options?: HonoServerOptionsWithoutWebSocket<E>): Promise<Hono<E>>;
|
|
64
|
+
declare function createHonoServer<E extends Env = BlankEnv>(options?: HonoServerOptionsWithWebSocket<E>): Promise<Hono<E>>;
|
|
56
65
|
|
|
57
66
|
export { type HonoServerOptions, createHonoServer };
|
|
@@ -1,6 +1,11 @@
|
|
|
1
|
+
import {
|
|
2
|
+
cleanUpgradeListeners,
|
|
3
|
+
createWebSocket,
|
|
4
|
+
patchUpgradeListener
|
|
5
|
+
} from "../chunk-27A6I7NN.js";
|
|
1
6
|
import {
|
|
2
7
|
cache
|
|
3
|
-
} from "../chunk-
|
|
8
|
+
} from "../chunk-V3H4JZ4H.js";
|
|
4
9
|
|
|
5
10
|
// src/adapters/node.ts
|
|
6
11
|
import { serve } from "@hono/node-server";
|
|
@@ -9,34 +14,40 @@ import { Hono } from "hono";
|
|
|
9
14
|
import { createMiddleware } from "hono/factory";
|
|
10
15
|
import { logger } from "hono/logger";
|
|
11
16
|
import { createRequestHandler } from "react-router";
|
|
12
|
-
async function createHonoServer(options
|
|
17
|
+
async function createHonoServer(options) {
|
|
13
18
|
const mergedOptions = {
|
|
19
|
+
...options,
|
|
14
20
|
listeningListener: (info) => {
|
|
15
21
|
console.log(`\u{1F680} Server started on port ${info.port}`);
|
|
16
22
|
console.log(`\u{1F30D} http://127.0.0.1:${info.port}`);
|
|
17
23
|
},
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
defaultLogger: options.defaultLogger ?? true
|
|
24
|
+
port: options?.port || Number(process.env.PORT) || 3e3,
|
|
25
|
+
defaultLogger: options?.defaultLogger ?? true
|
|
21
26
|
};
|
|
22
|
-
const mode = import.meta.env.MODE;
|
|
27
|
+
const mode = import.meta.env.MODE || "production";
|
|
23
28
|
const PRODUCTION = mode === "production";
|
|
24
|
-
const
|
|
29
|
+
const app = new Hono(mergedOptions.honoOptions || mergedOptions.app);
|
|
25
30
|
const clientBuildPath = `${import.meta.env.REACT_ROUTER_HONO_SERVER_BUILD_DIRECTORY}/client`;
|
|
26
|
-
|
|
31
|
+
const { upgradeWebSocket, injectWebSocket } = await createWebSocket({
|
|
32
|
+
app,
|
|
33
|
+
enabled: mergedOptions.useWebSocket ?? false
|
|
34
|
+
});
|
|
35
|
+
app.use(
|
|
27
36
|
`/${import.meta.env.REACT_ROUTER_HONO_SERVER_ASSETS_DIR}/*`,
|
|
28
37
|
cache(60 * 60 * 24 * 365),
|
|
29
38
|
// 1 year
|
|
30
39
|
serveStatic({ root: clientBuildPath })
|
|
31
40
|
);
|
|
32
|
-
|
|
41
|
+
app.use("*", cache(60 * 60), serveStatic({ root: PRODUCTION ? clientBuildPath : "./public" }));
|
|
33
42
|
if (mergedOptions.defaultLogger) {
|
|
34
|
-
|
|
43
|
+
app.use("*", logger());
|
|
35
44
|
}
|
|
36
|
-
if (mergedOptions.
|
|
37
|
-
await mergedOptions.configure(
|
|
45
|
+
if (mergedOptions.useWebSocket) {
|
|
46
|
+
await mergedOptions.configure(app, { upgradeWebSocket });
|
|
47
|
+
} else {
|
|
48
|
+
await mergedOptions.configure?.(app);
|
|
38
49
|
}
|
|
39
|
-
|
|
50
|
+
app.use(async (c, next) => {
|
|
40
51
|
const build = await import(
|
|
41
52
|
// @ts-expect-error - Virtual module provided by React Router at build time
|
|
42
53
|
"virtual:react-router/server-build"
|
|
@@ -48,18 +59,25 @@ async function createHonoServer(options = {}) {
|
|
|
48
59
|
})(c, next);
|
|
49
60
|
});
|
|
50
61
|
if (PRODUCTION) {
|
|
51
|
-
serve(
|
|
62
|
+
const server = serve(
|
|
52
63
|
{
|
|
53
|
-
...
|
|
64
|
+
...app,
|
|
54
65
|
...mergedOptions.customNodeServer,
|
|
55
66
|
port: mergedOptions.port
|
|
56
67
|
},
|
|
57
68
|
mergedOptions.listeningListener
|
|
58
69
|
);
|
|
59
|
-
|
|
70
|
+
mergedOptions.onServe?.(server);
|
|
71
|
+
injectWebSocket(server);
|
|
72
|
+
} else if (globalThis.__viteDevServer?.httpServer) {
|
|
73
|
+
const httpServer = globalThis.__viteDevServer.httpServer;
|
|
74
|
+
cleanUpgradeListeners(httpServer);
|
|
75
|
+
mergedOptions.onServe?.(httpServer);
|
|
76
|
+
injectWebSocket(httpServer);
|
|
77
|
+
patchUpgradeListener(httpServer);
|
|
60
78
|
console.log("\u{1F6A7} Dev server started");
|
|
61
79
|
}
|
|
62
|
-
return
|
|
80
|
+
return app;
|
|
63
81
|
}
|
|
64
82
|
export {
|
|
65
83
|
createHonoServer
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
// src/helpers.ts
|
|
2
|
+
var defaultWebSocket = {
|
|
3
|
+
upgradeWebSocket: () => async () => {
|
|
4
|
+
},
|
|
5
|
+
injectWebSocket: (server) => server
|
|
6
|
+
};
|
|
7
|
+
async function createWebSocket({ app, enabled }) {
|
|
8
|
+
if (!enabled) {
|
|
9
|
+
return defaultWebSocket;
|
|
10
|
+
}
|
|
11
|
+
const mode = import.meta.env.MODE;
|
|
12
|
+
const DEV = mode === "development";
|
|
13
|
+
const runtime = import.meta.env.REACT_ROUTER_HONO_SERVER_RUNTIME;
|
|
14
|
+
if (DEV || runtime === "node") {
|
|
15
|
+
const { createNodeWebSocket } = await import("@hono/node-ws");
|
|
16
|
+
const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
|
|
17
|
+
return {
|
|
18
|
+
upgradeWebSocket,
|
|
19
|
+
injectWebSocket(server) {
|
|
20
|
+
injectWebSocket(server);
|
|
21
|
+
return server;
|
|
22
|
+
}
|
|
23
|
+
};
|
|
24
|
+
}
|
|
25
|
+
if (runtime === "bun") {
|
|
26
|
+
const { createBunWebSocket } = await import("hono/bun");
|
|
27
|
+
const { upgradeWebSocket, websocket } = createBunWebSocket();
|
|
28
|
+
return {
|
|
29
|
+
upgradeWebSocket,
|
|
30
|
+
injectWebSocket: (server) => {
|
|
31
|
+
return {
|
|
32
|
+
...server,
|
|
33
|
+
websocket
|
|
34
|
+
};
|
|
35
|
+
}
|
|
36
|
+
};
|
|
37
|
+
}
|
|
38
|
+
return defaultWebSocket;
|
|
39
|
+
}
|
|
40
|
+
function cleanUpgradeListeners(httpServer) {
|
|
41
|
+
const upgradeListeners = httpServer.listeners("upgrade").filter((listener) => listener.name !== "hmrServerWsListener");
|
|
42
|
+
for (const listener of upgradeListeners) {
|
|
43
|
+
httpServer.removeListener(
|
|
44
|
+
"upgrade",
|
|
45
|
+
/* @ts-ignore - we don't care */
|
|
46
|
+
listener
|
|
47
|
+
);
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
function patchUpgradeListener(httpServer) {
|
|
51
|
+
const upgradeListeners = httpServer.listeners("upgrade").filter((listener) => listener.name !== "hmrServerWsListener");
|
|
52
|
+
for (const listener of upgradeListeners) {
|
|
53
|
+
httpServer.removeListener(
|
|
54
|
+
"upgrade",
|
|
55
|
+
/* @ts-ignore - we don't care */
|
|
56
|
+
listener
|
|
57
|
+
);
|
|
58
|
+
httpServer.on("upgrade", (request, ...rest) => {
|
|
59
|
+
if (request.headers["sec-websocket-protocol"] === "vite-hmr") {
|
|
60
|
+
return;
|
|
61
|
+
}
|
|
62
|
+
return listener(request, ...rest);
|
|
63
|
+
});
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
export {
|
|
68
|
+
createWebSocket,
|
|
69
|
+
cleanUpgradeListeners,
|
|
70
|
+
patchUpgradeListener
|
|
71
|
+
};
|
|
@@ -2,6 +2,7 @@ import { DevServerOptions } from '@hono/vite-dev-server';
|
|
|
2
2
|
import { Plugin } from 'vite';
|
|
3
3
|
|
|
4
4
|
type Runtime = "node" | "bun" | "cloudflare";
|
|
5
|
+
|
|
5
6
|
type ReactRouterHonoServerPluginOptions = {
|
|
6
7
|
/**
|
|
7
8
|
* The runtime to use for the server.
|
|
@@ -16,7 +17,7 @@ type ReactRouterHonoServerPluginOptions = {
|
|
|
16
17
|
*
|
|
17
18
|
* Defaults to `${appDirectory}/server[.ts | /index.ts]` if present.
|
|
18
19
|
*
|
|
19
|
-
* Fallback to a virtual module `virtual:react-router-hono-server/server
|
|
20
|
+
* Fallback to a virtual module `virtual:react-router-hono-server/server`.`
|
|
20
21
|
*/
|
|
21
22
|
serverEntryPoint?: string;
|
|
22
23
|
/**
|
package/dist/{dev.mjs → dev.js}
RENAMED
|
@@ -33,18 +33,18 @@ function reactRouterHonoServer(options = {}) {
|
|
|
33
33
|
return;
|
|
34
34
|
}
|
|
35
35
|
if (runtime === "cloudflare" && !config.plugins?.find((p) => p && "name" in p && p.name === "react-router-cloudflare-vite-dev-proxy")) {
|
|
36
|
-
console.
|
|
36
|
+
console.warn(
|
|
37
37
|
`\x1B[31mMissing cloudflareDevProxy() in your vite.config.ts.
|
|
38
38
|
Please add it to your plugins: import { cloudflareDevProxy } from "@react-router/dev/vite/cloudflare";\x1B[0m
|
|
39
39
|
`
|
|
40
40
|
);
|
|
41
|
-
throw new Error("Missing mandatory plugin cloudflareDevProxy() in vite.config.ts");
|
|
42
41
|
}
|
|
43
42
|
const baseConfig = {
|
|
44
43
|
// Define environment variables that are hot-swapped during development and SSR build
|
|
45
44
|
define: {
|
|
46
45
|
"import.meta.env.REACT_ROUTER_HONO_SERVER_BUILD_DIRECTORY": JSON.stringify(pluginConfig.buildDirectory),
|
|
47
|
-
"import.meta.env.REACT_ROUTER_HONO_SERVER_ASSETS_DIR": JSON.stringify(pluginConfig.assetsDir)
|
|
46
|
+
"import.meta.env.REACT_ROUTER_HONO_SERVER_ASSETS_DIR": JSON.stringify(pluginConfig.assetsDir),
|
|
47
|
+
"import.meta.env.REACT_ROUTER_HONO_SERVER_RUNTIME": JSON.stringify(runtime)
|
|
48
48
|
},
|
|
49
49
|
ssr: {
|
|
50
50
|
target: runtime === "cloudflare" ? "webworker" : void 0,
|
|
@@ -66,7 +66,8 @@ Please add it to your plugins: import { cloudflareDevProxy } from "@react-router
|
|
|
66
66
|
}
|
|
67
67
|
};
|
|
68
68
|
},
|
|
69
|
-
configureServer(server) {
|
|
69
|
+
async configureServer(server) {
|
|
70
|
+
globalThis.__viteDevServer = server;
|
|
70
71
|
if (!pluginConfig) {
|
|
71
72
|
return;
|
|
72
73
|
}
|
|
@@ -0,0 +1,86 @@
|
|
|
1
|
+
import { Env, Hono, Context } from 'hono';
|
|
2
|
+
import { HonoOptions } from 'hono/hono-base';
|
|
3
|
+
import { UpgradeWebSocket } from 'hono/ws';
|
|
4
|
+
import { ServerBuild, AppLoadContext } from 'react-router';
|
|
5
|
+
|
|
6
|
+
interface HonoServerOptionsBase<E extends Env> {
|
|
7
|
+
/**
|
|
8
|
+
* Hono app to use
|
|
9
|
+
*
|
|
10
|
+
* {@link Hono}
|
|
11
|
+
*/
|
|
12
|
+
app?: Hono<E>;
|
|
13
|
+
/**
|
|
14
|
+
* Enable the default logger
|
|
15
|
+
*
|
|
16
|
+
* Defaults to `true`
|
|
17
|
+
*/
|
|
18
|
+
defaultLogger?: boolean;
|
|
19
|
+
/**
|
|
20
|
+
* The port to start the server on
|
|
21
|
+
*
|
|
22
|
+
* Defaults to `process.env.PORT || 3000`
|
|
23
|
+
*/
|
|
24
|
+
port?: number;
|
|
25
|
+
/**
|
|
26
|
+
* Augment the React Router AppLoadContext
|
|
27
|
+
*
|
|
28
|
+
* Don't forget to declare the AppLoadContext in your app, next to where you create the Hono server
|
|
29
|
+
*
|
|
30
|
+
* ```ts
|
|
31
|
+
* declare module "react-router" {
|
|
32
|
+
* interface AppLoadContext {
|
|
33
|
+
* // Add your custom context here
|
|
34
|
+
* whatever: string;
|
|
35
|
+
* }
|
|
36
|
+
* }
|
|
37
|
+
* ```
|
|
38
|
+
*/
|
|
39
|
+
getLoadContext?: (
|
|
40
|
+
c: Context,
|
|
41
|
+
options: {
|
|
42
|
+
build: ServerBuild;
|
|
43
|
+
mode: string;
|
|
44
|
+
}
|
|
45
|
+
) => Promise<AppLoadContext> | AppLoadContext;
|
|
46
|
+
/**
|
|
47
|
+
* @deprecated Use `app` instead
|
|
48
|
+
*/
|
|
49
|
+
honoOptions?: HonoOptions<E>;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
interface WithWebsocket<E extends Env> {
|
|
53
|
+
/**
|
|
54
|
+
* Enable WebSockets support in `configure`
|
|
55
|
+
*
|
|
56
|
+
* For `bun` and `cloudflare` we will use the `@hono/node-ws`'s `injectWebSocket` on dev (only),
|
|
57
|
+
*
|
|
58
|
+
* Defaults to `false`
|
|
59
|
+
*/
|
|
60
|
+
useWebSocket: true;
|
|
61
|
+
/**
|
|
62
|
+
* Customize the Hono server, for example, adding middleware
|
|
63
|
+
*
|
|
64
|
+
* It is applied after the default middleware and before the React Router middleware
|
|
65
|
+
*/
|
|
66
|
+
configure: (app: Hono<E>, options: { upgradeWebSocket: UpgradeWebSocket }) => Promise<void> | void;
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
interface WithoutWebsocket<E extends Env> {
|
|
70
|
+
/**
|
|
71
|
+
* Enable WebSockets support in `configure`
|
|
72
|
+
*
|
|
73
|
+
* For `bun` and `cloudflare` we will use the `@hono/node-ws`'s `injectWebSocket` on dev (only),
|
|
74
|
+
*
|
|
75
|
+
* Defaults to `false`
|
|
76
|
+
*/
|
|
77
|
+
useWebSocket?: false | undefined;
|
|
78
|
+
/**
|
|
79
|
+
* Customize the Hono server, for example, adding middleware
|
|
80
|
+
*
|
|
81
|
+
* It is applied after the default middleware and before the React Router middleware
|
|
82
|
+
*/
|
|
83
|
+
configure?: (app: Hono<E>) => Promise<void> | void;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
export type { HonoServerOptionsBase as H, WithWebsocket as W, WithoutWebsocket as a };
|
package/package.json
CHANGED
|
@@ -1,41 +1,42 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "react-router-hono-server",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.2.0",
|
|
4
|
+
"type": "module",
|
|
4
5
|
"description": "The Vite plugin you need to create a Hono server for your React Router app in less than 10 seconds.",
|
|
5
6
|
"exports": {
|
|
6
7
|
"./node": {
|
|
7
8
|
"import": {
|
|
8
|
-
"import": "./dist/adapters/node.
|
|
9
|
-
"types": "./dist/adapters/node.d.
|
|
10
|
-
"default": "./dist/adapters/node.
|
|
9
|
+
"import": "./dist/adapters/node.js",
|
|
10
|
+
"types": "./dist/adapters/node.d.ts",
|
|
11
|
+
"default": "./dist/adapters/node.js"
|
|
11
12
|
}
|
|
12
13
|
},
|
|
13
14
|
"./bun": {
|
|
14
15
|
"import": {
|
|
15
|
-
"import": "./dist/adapters/bun.
|
|
16
|
-
"types": "./dist/adapters/bun.d.
|
|
17
|
-
"default": "./dist/adapters/bun.
|
|
16
|
+
"import": "./dist/adapters/bun.js",
|
|
17
|
+
"types": "./dist/adapters/bun.d.ts",
|
|
18
|
+
"default": "./dist/adapters/bun.js"
|
|
18
19
|
}
|
|
19
20
|
},
|
|
20
21
|
"./cloudflare": {
|
|
21
22
|
"import": {
|
|
22
|
-
"import": "./dist/adapters/cloudflare.
|
|
23
|
-
"types": "./dist/adapters/cloudflare.d.
|
|
24
|
-
"default": "./dist/adapters/cloudflare.
|
|
23
|
+
"import": "./dist/adapters/cloudflare.js",
|
|
24
|
+
"types": "./dist/adapters/cloudflare.d.ts",
|
|
25
|
+
"default": "./dist/adapters/cloudflare.js"
|
|
25
26
|
}
|
|
26
27
|
},
|
|
27
28
|
"./dev": {
|
|
28
29
|
"import": {
|
|
29
|
-
"import": "./dist/dev.
|
|
30
|
-
"types": "./dist/dev.d.
|
|
31
|
-
"default": "./dist/dev.
|
|
30
|
+
"import": "./dist/dev.js",
|
|
31
|
+
"types": "./dist/dev.d.ts",
|
|
32
|
+
"default": "./dist/dev.js"
|
|
32
33
|
}
|
|
33
34
|
},
|
|
34
35
|
"./middlewares": {
|
|
35
36
|
"import": {
|
|
36
|
-
"import": "./dist/middlewares.
|
|
37
|
-
"types": "./dist/middlewares.d.
|
|
38
|
-
"default": "./dist/middlewares.
|
|
37
|
+
"import": "./dist/middlewares.js",
|
|
38
|
+
"types": "./dist/middlewares.d.ts",
|
|
39
|
+
"default": "./dist/middlewares.js"
|
|
39
40
|
}
|
|
40
41
|
}
|
|
41
42
|
},
|
|
@@ -62,24 +63,28 @@
|
|
|
62
63
|
"url": "https://github.com/rphlmr/react-router-hono-server/issues"
|
|
63
64
|
},
|
|
64
65
|
"bin": {
|
|
65
|
-
"react-router-hono-server": "dist/cli.
|
|
66
|
+
"react-router-hono-server": "dist/cli.js"
|
|
66
67
|
},
|
|
67
68
|
"files": ["dist"],
|
|
68
|
-
"workspaces": [".", "examples
|
|
69
|
+
"workspaces": [".", "examples/**/*"],
|
|
69
70
|
"homepage": "https://github.com/rphlmr/react-router-hono-server#readme",
|
|
70
71
|
"dependencies": {
|
|
71
72
|
"@drizzle-team/brocli": "^0.11.0",
|
|
72
73
|
"@hono/node-server": "^1.13.7",
|
|
74
|
+
"@hono/node-ws": "^1.0.4",
|
|
73
75
|
"@hono/vite-dev-server": "^0.17.0",
|
|
74
76
|
"hono": "^4.6.11"
|
|
75
77
|
},
|
|
78
|
+
"optionalDependencies": {
|
|
79
|
+
"miniflare": "^3.20241205.0",
|
|
80
|
+
"wrangler": "^3.91.0"
|
|
81
|
+
},
|
|
76
82
|
"devDependencies": {
|
|
77
83
|
"@biomejs/biome": "^1.9.4",
|
|
78
84
|
"@types/bun": "^1.1.14",
|
|
79
85
|
"@types/node": "^22.9.3",
|
|
80
86
|
"@vitest/coverage-v8": "^2.1.5",
|
|
81
87
|
"lefthook": "^1.8.4",
|
|
82
|
-
"miniflare": "^3.20241106.1",
|
|
83
88
|
"npm-run-all": "^4.1.5",
|
|
84
89
|
"tsup": "^8.3.5",
|
|
85
90
|
"typescript": "^5.7.2",
|
package/dist/adapters/bun.d.mts
DELETED
|
@@ -1,107 +0,0 @@
|
|
|
1
|
-
import * as bun from 'bun';
|
|
2
|
-
import { Serve, ServeOptions } from 'bun';
|
|
3
|
-
import * as hono from 'hono';
|
|
4
|
-
import { Env } from 'hono';
|
|
5
|
-
import { BlankEnv } from 'hono/types';
|
|
6
|
-
import { H as HonoServerOptionsBase } from '../hono-server-options-base.d-DChVrA1u.mjs';
|
|
7
|
-
import 'hono/hono-base';
|
|
8
|
-
import 'react-router';
|
|
9
|
-
|
|
10
|
-
interface HonoServerOptions<E extends Env = BlankEnv> extends HonoServerOptionsBase<E> {
|
|
11
|
-
/**
|
|
12
|
-
* Customize the bun server
|
|
13
|
-
*
|
|
14
|
-
* {@link https://bun.sh/docs/api/http#start-a-server-bun-serve}
|
|
15
|
-
*/
|
|
16
|
-
customBunServer?: Serve & ServeOptions;
|
|
17
|
-
}
|
|
18
|
-
/**
|
|
19
|
-
* Create a Hono server
|
|
20
|
-
*
|
|
21
|
-
* @param HonoServerOptions options {@link HonoServerOptions} - The configuration options for the server
|
|
22
|
-
*/
|
|
23
|
-
declare function createHonoServer<E extends Env = BlankEnv>(options?: HonoServerOptions<E>): Promise<{
|
|
24
|
-
fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
|
|
25
|
-
port: number;
|
|
26
|
-
development: boolean;
|
|
27
|
-
} | {
|
|
28
|
-
fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
|
|
29
|
-
port: number;
|
|
30
|
-
development: boolean;
|
|
31
|
-
reusePort?: boolean;
|
|
32
|
-
hostname?: string;
|
|
33
|
-
unix?: never;
|
|
34
|
-
idleTimeout?: number;
|
|
35
|
-
maxRequestBodySize?: number;
|
|
36
|
-
error?: (this: bun.Server, error: bun.ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
|
|
37
|
-
id?: string | null;
|
|
38
|
-
static?: Record<`/${string}`, Response>;
|
|
39
|
-
} | {
|
|
40
|
-
fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
|
|
41
|
-
port: number;
|
|
42
|
-
development: boolean;
|
|
43
|
-
tls?: bun.TLSOptions | bun.TLSOptions[];
|
|
44
|
-
reusePort?: boolean;
|
|
45
|
-
hostname?: string;
|
|
46
|
-
unix?: never;
|
|
47
|
-
idleTimeout?: number;
|
|
48
|
-
maxRequestBodySize?: number;
|
|
49
|
-
error?: (this: bun.Server, error: bun.ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
|
|
50
|
-
id?: string | null;
|
|
51
|
-
static?: Record<`/${string}`, Response>;
|
|
52
|
-
passphrase?: string;
|
|
53
|
-
dhParamsFile?: string;
|
|
54
|
-
serverName?: string;
|
|
55
|
-
lowMemoryMode?: boolean;
|
|
56
|
-
rejectUnauthorized?: boolean;
|
|
57
|
-
requestCert?: boolean;
|
|
58
|
-
ca?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
59
|
-
cert?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
60
|
-
key?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
61
|
-
secureOptions?: number | undefined;
|
|
62
|
-
keyFile?: string;
|
|
63
|
-
certFile?: string;
|
|
64
|
-
caFile?: string;
|
|
65
|
-
} | {
|
|
66
|
-
fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
|
|
67
|
-
port: number;
|
|
68
|
-
development: boolean;
|
|
69
|
-
hostname?: string;
|
|
70
|
-
websocket: bun.WebSocketHandler<undefined>;
|
|
71
|
-
maxRequestBodySize?: number;
|
|
72
|
-
error?: (this: bun.Server, error: bun.ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
|
|
73
|
-
id?: string | null;
|
|
74
|
-
static?: Record<`/${string}`, Response>;
|
|
75
|
-
reusePort?: boolean;
|
|
76
|
-
unix?: never;
|
|
77
|
-
idleTimeout?: number;
|
|
78
|
-
} | {
|
|
79
|
-
fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
|
|
80
|
-
port: number;
|
|
81
|
-
development: boolean;
|
|
82
|
-
unix?: never;
|
|
83
|
-
tls?: bun.TLSOptions | bun.TLSOptions[];
|
|
84
|
-
hostname?: string;
|
|
85
|
-
websocket: bun.WebSocketHandler<undefined>;
|
|
86
|
-
maxRequestBodySize?: number;
|
|
87
|
-
error?: (this: bun.Server, error: bun.ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
|
|
88
|
-
id?: string | null;
|
|
89
|
-
static?: Record<`/${string}`, Response>;
|
|
90
|
-
passphrase?: string;
|
|
91
|
-
dhParamsFile?: string;
|
|
92
|
-
serverName?: string;
|
|
93
|
-
lowMemoryMode?: boolean;
|
|
94
|
-
rejectUnauthorized?: boolean;
|
|
95
|
-
requestCert?: boolean;
|
|
96
|
-
ca?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
97
|
-
cert?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
98
|
-
key?: string | Buffer | bun.BunFile | Array<string | Buffer | bun.BunFile> | undefined;
|
|
99
|
-
secureOptions?: number | undefined;
|
|
100
|
-
keyFile?: string;
|
|
101
|
-
certFile?: string;
|
|
102
|
-
caFile?: string;
|
|
103
|
-
reusePort?: boolean;
|
|
104
|
-
idleTimeout?: number;
|
|
105
|
-
}>;
|
|
106
|
-
|
|
107
|
-
export { type HonoServerOptions, createHonoServer };
|
|
@@ -1,54 +0,0 @@
|
|
|
1
|
-
import { Env, Hono, Context } from 'hono';
|
|
2
|
-
import { HonoOptions } from 'hono/hono-base';
|
|
3
|
-
import { BlankEnv } from 'hono/types';
|
|
4
|
-
import { ServerBuild, AppLoadContext } from 'react-router';
|
|
5
|
-
|
|
6
|
-
interface HonoServerOptionsBase<E extends Env = BlankEnv> {
|
|
7
|
-
/**
|
|
8
|
-
* Enable the default logger
|
|
9
|
-
*
|
|
10
|
-
* Defaults to `true`
|
|
11
|
-
*/
|
|
12
|
-
defaultLogger?: boolean;
|
|
13
|
-
/**
|
|
14
|
-
* The port to start the server on
|
|
15
|
-
*
|
|
16
|
-
* Defaults to `process.env.PORT || 3000`
|
|
17
|
-
*/
|
|
18
|
-
port?: number;
|
|
19
|
-
/**
|
|
20
|
-
* Customize the Hono server, for example, adding middleware
|
|
21
|
-
*
|
|
22
|
-
* It is applied after the default middleware and before the React Router middleware
|
|
23
|
-
*/
|
|
24
|
-
configure?: <E extends Env = BlankEnv>(server: Hono<E>) => Promise<void> | void;
|
|
25
|
-
/**
|
|
26
|
-
* Augment the React Router AppLoadContext
|
|
27
|
-
*
|
|
28
|
-
* Don't forget to declare the AppLoadContext in your app, next to where you create the Hono server
|
|
29
|
-
*
|
|
30
|
-
* ```ts
|
|
31
|
-
* declare module "react-router" {
|
|
32
|
-
* interface AppLoadContext {
|
|
33
|
-
* // Add your custom context here
|
|
34
|
-
* whatever: string;
|
|
35
|
-
* }
|
|
36
|
-
* }
|
|
37
|
-
* ```
|
|
38
|
-
*/
|
|
39
|
-
getLoadContext?: (
|
|
40
|
-
c: Context,
|
|
41
|
-
options: {
|
|
42
|
-
build: ServerBuild;
|
|
43
|
-
mode: string;
|
|
44
|
-
}
|
|
45
|
-
) => Promise<AppLoadContext> | AppLoadContext;
|
|
46
|
-
/**
|
|
47
|
-
* Hono constructor options
|
|
48
|
-
*
|
|
49
|
-
* {@link HonoOptions}
|
|
50
|
-
*/
|
|
51
|
-
honoOptions?: HonoOptions<E>;
|
|
52
|
-
}
|
|
53
|
-
|
|
54
|
-
export type { HonoServerOptionsBase as H };
|
|
File without changes
|
/package/dist/{cli.mjs → cli.js}
RENAMED
|
File without changes
|
|
File without changes
|