Remix/React Router + Hono

React Router is a web framework for building web applications, which can run on the Edge.

Hono is a small and ultrafast web framework for the Edges.

This adapter allows you to use Hono with React Router, so you can use the best of each one.

Let Hono power your HTTP server and its middlewares, then use React Router to build your web application.

Installation

Install the package

1npm add remix-hono

The following packages are optional dependencies, you will need to install them depending on what features from remix-hono you're using.

• @react-router/cloudflare if you're using Cloudflare integration.
• i18next and remix-i18next if you're using the i18n middleware.
• zod if you're using typedEnv.

[!NOTE] You don't really need to install them if you don't use them, but you will need to install them yourself (they don't come not automatically) if you use the features that depends on those packages.

Usage

Create your Hono + React Routers server:

1import { logDevReady } from "@react-router/cloudflare";
2import { Hono } from "hono";
3// You can also use it with other runtimes
4import { handle } from "hono/cloudflare-pages";
5import { reactRouter } from "remix-hono/handler";
6
7import build from "./build/server";
8
9if (process.env.NODE_ENV === "development") logDevReady(build);
10
11/* type your Cloudflare bindings here */
12type Bindings = {};
13
14/* type your Hono variables (used with c.get/c.set) here */
15type Variables = {};
16
17type ContextEnv = { Bindings: Bindings; Variables: Variables };
18
19const server = new Hono<ContextEnv>();
20
21// Add the React Router middleware to your Hono server
22server.use(
23	"*",
24	reactRouter({
25		build,
26		mode: process.env.NODE_ENV as "development" | "production",
27		// getLoadContext is optional, the default function is the same as here
28		getLoadContext(c) {
29			return c.env;
30		},
31	}),
32);
33
34// Create a Cloudflare Pages request handler for your Hono server
35export const onRequest = handle(server);

Now, you can add more Hono middlewares, like the basic auth middleware:

1import { basicAuth } from "hono/basic-auth";
2
3server.use(
4	"*",
5	basicAuth({ username: "hono", password: "react-router" }),
6	// Ensure React Router request handler is the last one
7	reactRouter(options),
8);

With just that, your app will now have basic auth protection, which can work great of preview applications.

Session Management

Additionally to the reactRouter Hono middleware, there are other three middlewares to work with React Router sessions.

Because React Router sessions typically use a secret coming from the environment you will need access to Hono c.env to use them. If you're using the Worker KV session storage you will also need to pass the KV binding to the middleware.

You can use the different middlewares included in this package to do that:

1import { session } from "remix-hono/session";
2import { createWorkerKVSessionStorage } from "@react-router/cloudflare";
3
4server.use(
5	"*",
6	session({
7		autoCommit: true,
8		createSessionStorage(c) {
9			return createWorkersKVSessionStorage({
10				kv: c.env.MY_KV_BINDING,
11				cookie: {
12					name: "session",
13					httpOnly: true,
14					secrets: [c.SESSION_SECRET],
15				},
16			});
17		},
18	}),
19);

Now, setup the React Router middleware after your session middleware and use the helpers getSessionStorage and getSession to access the SessionStorage and Session objects.

Note The Session object will only be defined if autoCommit was set as true in the session middleware options. If you set it to false, you will need to call sessionStorage.getSession() manually.

1import { getSessionStorage, getSession } from "remix-hono/session";
2
3server.use(
4	"*",
5	reactRouter<ContextEnv>({
6		build,
7		mode: process.env.NODE_ENV as "development" | "production",
8		// getLoadContext is optional, the default function is the same as here
9		getLoadContext(c) {
10			let sessionStorage = getSessionStorage(c);
11			let session = getSession(c);
12
13			// Return them here to access them in your loaders and actions
14			return { ...c.env, sessionStorage, session };
15		},
16	}),
17);

The session middleware is generic and lets you use any session storage mechanism. If you want to use the Worker KV session storage you can use the workerKVSession middleware instead.

1import { workerKVSession } from "remix-hono/cloudflare";
2
3server.use(
4	"*",
5	workerKVSession({
6		autoCommit: true, // same as in the session middleware
7		cookie: {
8			name: "session", // all cookie options as in createWorkerKVSessionStorage
9			// In this function, you can access c.env to get the session secret
10			secrets(c) {
11				return [c.env.SECRET];
12			},
13		},
14		// The name of the binding using for the KVNamespace
15		binding: "KV_BINDING",
16	}),
17);

If you want to use the cookie session storage, you can use the cookieSession middleware instead.

1import { cookieSession } from "remix-hono/cloudflare";
2
3server.use(
4	"*",
5	cookieSession({
6		autoCommit: true, // same as in the session middleware
7		cookie: {
8			name: "session", // all cookie options as in createCookieSessionStorage
9			// In this function, you can access c.env to get the session secret
10			secrets(c) {
11				return [c.env.SECRET];
12			},
13		},
14	}),
15);

In both workerKVSession and cookieSession you use getSession and getSessionStorage imported from remix-hono/session

Static Assets on Cloudflare

If you're using Remix Hono with Cloudflare, you will need to serve your static from the public folder (except for public/build). The staticAssets middleware serves this purpose.

First install @react-router/cloudflare if you haven't installed it yet.

1npm add @react-router/cloudflare

Then use the middleware in your server.

1import { staticAssets } from "remix-hono/cloudflare";
2import { reactRouter } from "remix-hono/handler";
3
4server.use(
5	"*",
6	staticAssets(),
7	// Add React Router request handler as the last middleware
8	reactRouter(options),
9);

i18next integration

If you're using remix-i18next to support i18n in your React Router app, the i18next middleware let's you setup it for your React Router app as a middleware that you can later use in your getLoadContext function to pass the locale and t functions to your loaders and actions.

First install i18next and remix-i18next if you haven't already.

1npm add i18next remix-i18next

Then use the middleware in your server.

1import { i18next } from "remix-hono/i18next";
2
3// Same options as in remix-i18next
4server.use("*", i18next(options));

Then, in your getLoadContext function you can access the locale and t functions using the helpers i18next.getLocale and i18next.getFixedT.

1server.use(
2	"*",
3	reactRouter({
4		build,
5		mode: process.env.NODE_ENV as "development" | "production",
6		// getLoadContext is optional, the default function is the same as here
7		getLoadContext(c) {
8			// get the locale from the context
9			let locale = i18next.getLocale(c);
10			// get t function for the default namespace
11			let t = await i18next.getFixedT(c);
12			// get t function for a specific namespace
13			let errorT = await i18next.getFixedT(c, "error");
14			return { env: c.env, locale, t, errorT };
15		},
16	}),
17);

There's also an i18next.get function that returns the RemixI18Next instance in case you need it.

HTTPS Only

You can enforce your server to use HTTPS only with the httpsOnly middleware.

1import { httpsOnly } from "remix-hono/security";
2
3server.use("*", httpsOnly());

Trailing Slash

You can enforce your server to use trailing slashes with the trailingSlash middleware.

1import { trailingSlash } from "remix-hono/trailing-slash";
2
3// By default, trailing slashes are disabled, so `https://company.tld/about/`
4// will be redirect to `https://company.tld/about`
5server.use("*", trailingSlash());
6server.use("*", trailingSlash({ enabled: false }));
7
8// You can also enable trailing slashes, so `https://company.tld/about` will be
9// redirect to `https://company.tld/about/` instead
10server.use("*", trailingSlash({ enabled: true }));

Typed Envs with Zod

The typedEnv helper let's you get the environment variables for any runtimes and use Zod to validate it against a schema.

First install Zod if you haven't installed it yet.

1npm add zod

Then use the helper in any middleware or request handler.

1import { typedEnv } from "remix-hono/typed-env";
2
3// Define your schema
4const Schema = z.object({ SECRET: z.string() });
5
6// Use the helper
7server.get("/about", (c) => {
8	let env = typedEnv(c, Schema);
9	let secret = env.SECRET; // or typedEnv(c, Schema, "SECRET");
10	// do something here
11});

Author

• Sergio Xalambrí

License

• MIT License