@mcansh/react-router-fastify 5.0.0

package/README.md

@@ -0,0 +1,260 @@
+# react-router-fastify
+
+A Fastify adapter for React Router v8 framework mode, plus a Vite plugin so `react-router dev` runs through your Fastify server.
+
+## Features
+
+- Adapts Fastify requests and replies to React Router's Web Fetch request/response runtime
+- Registers React Router as a Fastify catch-all route while preserving your own Fastify routes
+- Loads `virtual:react-router/server-build` during development
+- Serves `build/client` with `@fastify/static` in production
+- Provides a Vite plugin that mounts your Fastify app during `react-router dev`
+- Preserves shared server/app module identity for React Router context tokens
+
+## Installation
+
+```sh
+npm i @mcansh/react-router-fastify fastify react-router @react-router/node
+npm i -D @react-router/dev vite
+```
+
+React Router v8 currently requires Node `>=22.22.0`.
+
+## Usage
+
+Create a server module that exports a factory. The factory receives the Vite dev server in development and `undefined` in production.
+
+```ts
+// server.ts
+import { pathToFileURL } from "node:url"
+
+import { fastifyReactRouter } from "@mcansh/react-router-fastify"
+import { fastify } from "fastify"
+import type { ViteDevServer } from "vite"
+
+export async function createServer(vite?: ViteDevServer) {
+  let app = fastify()
+
+  app.get("/api/health", async () => ({ ok: true }))
+
+  await app.register(fastifyReactRouter, { devServer: vite })
+
+  return app
+}
+
+let isMain = import.meta.url === pathToFileURL(process.argv[1]).href
+if (isMain) {
+  let app = await createServer()
+  await app.listen({ port: 3000, host: "0.0.0.0" })
+}
+```
+
+Add the Vite plugin so `react-router dev` uses that Fastify server:
+
+```ts
+// vite.config.ts
+import { reactRouter } from "@react-router/dev/vite"
+import { fastifyReactRouterDev } from "@mcansh/react-router-fastify/vite"
+import { defineConfig } from "vite"
+
+export default defineConfig({
+  plugins: [reactRouter(), fastifyReactRouterDev({ entry: "./server.ts" })],
+})
+```
+
+Use the normal React Router commands:
+
+```json
+{
+  "scripts": {
+    "dev": "react-router dev",
+    "build": "react-router build",
+    "start": "NODE_ENV=production node ./server.js"
+  }
+}
+```
+
+## Example
+
+A runnable example lives in `examples/basic`:
+
+```sh
+pnpm install
+pnpm run example:dev
+```
+
+The example includes a Fastify API route at `/api/health`, `getLoadContext`
+that seeds React Router context, root route middleware that updates that same
+context, and a `vite.config.ts` that uses `fastifyReactRouterDev` with the
+standard `react-router dev` command.
+
+## Shared Context
+
+React Router v8 uses `RouterContextProvider` for loaders, actions, and
+middleware. When your Fastify server and React Router app both need the same
+context token, put that token in a module that both sides import through the
+same package import specifier.
+
+Add a package import for the shared module:
+
+```json
+{
+  "imports": {
+    "#request-info": "./app/request-info.ts"
+  }
+}
+```
+
+Create the context token in your app:
+
+```ts
+// app/request-info.ts
+import { createContext } from "react-router"
+
+export interface RequestInfo {
+  requestId: string
+  userAgent: string
+}
+
+export let requestInfoContext = createContext<RequestInfo>()
+```
+
+Seed it from `getLoadContext`:
+
+```ts
+// server.ts
+import { requestInfoContext } from "#request-info"
+import { fastifyReactRouter } from "@mcansh/react-router-fastify"
+import { RouterContextProvider } from "react-router"
+
+app.register(fastifyReactRouter, {
+  devServer: vite,
+  getLoadContext(request) {
+    let context = new RouterContextProvider()
+    context.set(requestInfoContext, {
+      requestId: request.id,
+      userAgent: request.headers["user-agent"] ?? "unknown",
+    })
+    return context
+  },
+})
+```
+
+Read or update the same context from React Router middleware and route modules:
+
+```ts
+// app/root.tsx
+import { requestInfoContext } from "#request-info"
+import type { MiddlewareFunction } from "react-router"
+
+export const middleware: MiddlewareFunction[] = [
+  async ({ context }, next) => {
+    let requestInfo = context.get(requestInfoContext)
+    context.set(requestInfoContext, requestInfo)
+    return next()
+  },
+]
+```
+
+```ts
+// app/routes/home.tsx
+import { requestInfoContext } from "#request-info"
+import type { LoaderFunctionArgs } from "react-router"
+
+export async function loader({ context }: LoaderFunctionArgs) {
+  return {
+    requestInfo: context.get(requestInfoContext),
+  }
+}
+```
+
+Tell the Vite plugin to keep that package import external in React Router's SSR
+build:
+
+```ts
+// vite.config.ts
+import { reactRouter } from "@react-router/dev/vite"
+import { fastifyReactRouterDev } from "@mcansh/react-router-fastify/vite"
+import { defineConfig } from "vite"
+
+export default defineConfig({
+  plugins: [
+    reactRouter(),
+    fastifyReactRouterDev({
+      entry: "./server.ts",
+      externalizeServerEntryImports: ["#request-info"],
+    }),
+  ],
+})
+```
+
+This prevents the production server bundle from inlining a second
+`createContext()` instance. The built React Router server keeps
+`import { requestInfoContext } from "#request-info"`, so `server.ts`,
+middleware, and loaders all use the same token.
+
+## Production
+
+Without a Vite dev server, `fastifyReactRouter` imports `build/server/index.js` and serves static files from `build/client`:
+
+```sh
+react-router build
+NODE_ENV=production node ./server.js
+```
+
+If your build output uses different paths, pass them directly:
+
+```ts
+await app.register(fastifyReactRouter, {
+  serverBuildPath: "dist/server.js",
+  clientBuildDirectory: "dist/client",
+})
+```
+
+## API
+
+`fastifyReactRouter` options:
+
+- `devServer` - Vite dev server, provided by `fastifyReactRouterDev` during development
+- `basePath` - URL base path for static files and the catch-all route, default `/`
+- `serverBuildPath` - production server build module, default `build/server/index.js`
+- `clientBuildDirectory` - production client asset directory, default `build/client`
+- `mode` - value passed to React Router's request handler, default `process.env.NODE_ENV`
+- `getLoadContext` - returns a `RouterContextProvider` for each request
+- `build` - production-only React Router server build or build loader override
+- `staticOptions` - options forwarded to `@fastify/static`
+- `assetCacheControl` - cache-control string for files under `<clientBuildDirectory>/assets`
+- `fileCacheControl` - cache-control string for other files in `clientBuildDirectory`
+- `routeOptions` - Fastify route options for the catch-all route
+
+When `devServer` is provided, `fastifyReactRouter` always uses Vite's
+`virtual:react-router/server-build` module. This keeps development requests
+hot-reloaded even if a production `build` override is configured.
+
+`fastifyReactRouterDev` options:
+
+- `entry` - server module loaded by Vite, default `./server.ts`
+- `exportName` - named server factory export, default `createServer`
+- `externalizeServerEntryImports` - keeps local `#` and relative imports from
+  the server entry external in the React Router SSR build; pass an explicit
+  list such as `["#request-info"]` for tighter production packaging control.
+  Externalized modules must be available to Node in production.
+
+## Lower-level Handler
+
+You can wire the route yourself with `createRequestHandler`:
+
+```ts
+import { createRequestHandler } from "@mcansh/react-router-fastify"
+
+app.all(
+  "*",
+  createRequestHandler({
+    build: () => import("./build/server/index.js"),
+  }),
+)
+```
+
+## License
+
+See [LICENSE](https://github.com/mcansh/remix-fastify/blob/main/LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+import { FastifyStaticOptions } from "@fastify/static";
+import { RouterContextProvider, ServerBuild } from "react-router";
+import { FastifyInstance, FastifyReply, FastifyRequest, RouteShorthandOptions } from "fastify";
+import { ViteDevServer } from "vite";
+
+//#region src/handler.d.ts
+type HttpRequest = FastifyRequest["raw"];
+type HttpResponse = FastifyReply["raw"];
+type ReactRouterLoadContext = RouterContextProvider;
+type GetLoadContextFunction = (request: FastifyRequest, reply: FastifyReply) => ReactRouterLoadContext | undefined | Promise<ReactRouterLoadContext | undefined>;
+type RequestHandler = (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+interface CreateRequestHandlerOptions {
+  build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+  getLoadContext?: GetLoadContextFunction;
+  mode?: string;
+}
+/**
+ * Creates a Fastify route handler backed by React Router's server runtime.
+ *
+ * @param options React Router build, mode, and optional load context hook.
+ * @returns Fastify route handler.
+ */
+declare function createRequestHandler(options: CreateRequestHandlerOptions): RequestHandler;
+//#endregion
+//#region src/fastify.d.ts
+interface FastifyReactRouterOptions {
+  devServer?: ViteDevServer;
+  basePath?: string;
+  serverBuildPath?: string;
+  clientBuildDirectory?: string;
+  mode?: string;
+  getLoadContext?: GetLoadContextFunction;
+  build?: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+  staticOptions?: FastifyStaticOptions;
+  assetCacheControl?: string;
+  fileCacheControl?: string;
+  routeOptions?: RouteShorthandOptions;
+}
+/**
+ * Fastify plugin that serves React Router framework builds.
+ *
+ * @param fastify Fastify instance.
+ * @param options Adapter options.
+ */
+declare function fastifyReactRouter(fastify: FastifyInstance, options: FastifyReactRouterOptions): Promise<void>;
+//#endregion
+//#region src/request.d.ts
+/**
+ * Copies Fastify's normalized request headers into Web Fetch `Headers`.
+ *
+ * @param source Fastify request headers.
+ * @returns Fetch-compatible headers.
+ */
+declare function createHeaders(source: FastifyRequest["headers"]): Headers;
+/**
+ * Builds the absolute request URL that React Router expects.
+ *
+ * @param request Fastify request.
+ * @returns Absolute URL for the original incoming request.
+ */
+declare function createUrl(request: FastifyRequest): string;
+/**
+ * Adapts a Fastify request to a Web Fetch `Request`.
+ *
+ * @param request Fastify request.
+ * @param reply Fastify reply, used to abort work when the connection closes.
+ * @returns Fetch-compatible request for React Router.
+ */
+declare function createRequest(request: FastifyRequest, reply: FastifyReply): Request;
+//#endregion
+//#region src/response.d.ts
+/**
+ * Writes a Web Fetch `Response` through a Fastify reply.
+ *
+ * @param reply Fastify reply.
+ * @param response React Router response.
+ * @returns A promise that settles after the response is sent.
+ */
+declare function sendResponse(reply: FastifyReply, response: Response): Promise<void>;
+//#endregion
+export { type CreateRequestHandlerOptions, type FastifyReactRouterOptions, type GetLoadContextFunction, type HttpRequest, type HttpResponse, type ReactRouterLoadContext, type RequestHandler, createHeaders, createRequest, createRequestHandler, createUrl, fastifyReactRouter, sendResponse };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,182 @@
+import { t as importSsrModule } from "./vite-runtime-Cuj_Fjkd.mjs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fastifyStatic from "@fastify/static";
+import { createRequestHandler as createRequestHandler$1 } from "react-router";
+import { Readable } from "node:stream";
+import { createReadableStreamFromReadable } from "@react-router/node";
+//#region src/request.ts
+/**
+* Copies Fastify's normalized request headers into Web Fetch `Headers`.
+*
+* @param source Fastify request headers.
+* @returns Fetch-compatible headers.
+*/
+function createHeaders(source) {
+	let headers = new Headers();
+	for (let [name, value] of Object.entries(source)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) for (let item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	return headers;
+}
+/**
+* Builds the absolute request URL that React Router expects.
+*
+* @param request Fastify request.
+* @returns Absolute URL for the original incoming request.
+*/
+function createUrl(request) {
+	return `${request.protocol}://${request.host}${request.originalUrl}`;
+}
+/**
+* Adapts a Fastify request to a Web Fetch `Request`.
+*
+* @param request Fastify request.
+* @param reply Fastify reply, used to abort work when the connection closes.
+* @returns Fetch-compatible request for React Router.
+*/
+function createRequest(request, reply) {
+	let controller = new AbortController();
+	let init = {
+		method: request.method,
+		headers: createHeaders(request.headers),
+		signal: controller.signal
+	};
+	reply.raw.once("finish", () => {
+		controller = null;
+	});
+	reply.raw.once("close", () => {
+		controller?.abort();
+	});
+	if (["GET", "HEAD"].includes(request.method) === false) {
+		init.body = getBody(request);
+		init.duplex = "half";
+	}
+	return new Request(createUrl(request), init);
+}
+function getBody(request) {
+	let body = request.body;
+	if (body == null) return createReadableStreamFromReadable(request.raw);
+	if (body instanceof Readable) return createReadableStreamFromReadable(body);
+	if (body instanceof ReadableStream) return body;
+	if (body instanceof URLSearchParams) return body;
+	if (body instanceof ArrayBuffer) return body;
+	if (body instanceof Blob) return body;
+	if (body instanceof FormData) return body;
+	if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+	if (typeof body === "string") return body;
+	return JSON.stringify(body);
+}
+//#endregion
+//#region src/response.ts
+/**
+* Writes a Web Fetch `Response` through a Fastify reply.
+*
+* @param reply Fastify reply.
+* @param response React Router response.
+* @returns A promise that settles after the response is sent.
+*/
+async function sendResponse(reply, response) {
+	reply.status(response.status);
+	writeHeaders(reply, response.headers);
+	if (response.body == null) return reply.send();
+	return reply.send(readableFromWeb(response.body));
+}
+function writeHeaders(reply, headers) {
+	let cookies = readSetCookies(headers);
+	for (let [name, value] of headers) {
+		if (name.toLowerCase() === "set-cookie" && cookies.length > 0) continue;
+		reply.header(name, value);
+	}
+	if (cookies.length > 0) reply.header("set-cookie", cookies);
+}
+function readSetCookies(headers) {
+	let cookies = headers.getSetCookie?.();
+	if (cookies && cookies.length > 0) return cookies;
+	let cookie = headers.get("Set-Cookie");
+	return cookie ? [cookie] : [];
+}
+function readableFromWeb(body) {
+	let reader = body.getReader();
+	return new Readable({ read() {
+		reader.read().then(({ done, value }) => {
+			this.push(done ? null : Buffer.from(value));
+		}, (error) => {
+			this.destroy(error instanceof Error ? error : new Error(String(error)));
+		});
+	} });
+}
+//#endregion
+//#region src/handler.ts
+/**
+* Creates a Fastify route handler backed by React Router's server runtime.
+*
+* @param options React Router build, mode, and optional load context hook.
+* @returns Fastify route handler.
+*/
+function createRequestHandler(options) {
+	let reactRouterHandler = createRequestHandler$1(options.build, options.mode ?? process.env.NODE_ENV);
+	return async (request, reply) => {
+		await sendResponse(reply, await reactRouterHandler(createRequest(request, reply), await options.getLoadContext?.(request, reply)));
+	};
+}
+//#endregion
+//#region src/fastify.ts
+/**
+* Fastify plugin that serves React Router framework builds.
+*
+* @param fastify Fastify instance.
+* @param options Adapter options.
+*/
+async function fastifyReactRouter(fastify, options) {
+	let { devServer, basePath = "/", serverBuildPath = "build/server/index.js", clientBuildDirectory = "build/client", mode = process.env.NODE_ENV, getLoadContext, build, staticOptions, assetCacheControl = "public, max-age=31536000, immutable", fileCacheControl = "public, max-age=3600", routeOptions } = options;
+	let serverBuild = devServer == null ? build ?? createBuildLoader(devServer, path.resolve(serverBuildPath)) : createBuildLoader(devServer, path.resolve(serverBuildPath));
+	if (devServer == null) await registerStaticFiles(fastify, {
+		basePath,
+		clientBuildDirectory: path.resolve(clientBuildDirectory),
+		assetCacheControl,
+		fileCacheControl,
+		staticOptions
+	});
+	let handler = createRequestHandler({
+		build: serverBuild,
+		getLoadContext,
+		mode
+	});
+	fastify.removeAllContentTypeParsers();
+	fastify.addContentTypeParser("*", (_request, payload, done) => {
+		done(null, payload);
+	});
+	if (routeOptions) fastify.all("*", routeOptions, handler);
+	else fastify.all("*", handler);
+}
+function createBuildLoader(devServer, serverBuildPath) {
+	if (devServer != null) return () => importSsrModule(devServer, "virtual:react-router/server-build");
+	return async () => import(
+		/* @vite-ignore */
+		pathToFileURL(serverBuildPath).href
+);
+}
+async function registerStaticFiles(fastify, options) {
+	let assetsDirectory = path.join(options.clientBuildDirectory, "assets");
+	await fastify.register(fastifyStatic, {
+		root: options.clientBuildDirectory,
+		prefix: options.basePath,
+		wildcard: false,
+		cacheControl: false,
+		dotfiles: "ignore",
+		etag: true,
+		lastModified: true,
+		setHeaders(res, filePath) {
+			let isAsset = filePath.startsWith(assetsDirectory);
+			res.setHeader("cache-control", isAsset ? options.assetCacheControl : options.fileCacheControl);
+		},
+		...options.staticOptions
+	});
+}
+//#endregion
+export { createHeaders, createRequest, createRequestHandler, createUrl, fastifyReactRouter, sendResponse };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["withCookies","createReactRouterHandler"],"sources":["../src/request.ts","../src/response.ts","../src/handler.ts","../src/fastify.ts"],"sourcesContent":["import { Readable } from \"node:stream\"\n\nimport { createReadableStreamFromReadable } from \"@react-router/node\"\nimport type { FastifyReply, FastifyRequest } from \"fastify\"\n\n/**\n * Copies Fastify's normalized request headers into Web Fetch `Headers`.\n *\n * @param source Fastify request headers.\n * @returns Fetch-compatible headers.\n */\nexport function createHeaders(source: FastifyRequest[\"headers\"]): Headers {\n  let headers = new Headers()\n\n  for (let [name, value] of Object.entries(source)) {\n    if (value == null) continue\n\n    if (Array.isArray(value)) {\n      for (let item of value) {\n        headers.append(name, item)\n      }\n    } else {\n      headers.set(name, value)\n    }\n  }\n\n  return headers\n}\n\n/**\n * Builds the absolute request URL that React Router expects.\n *\n * @param request Fastify request.\n * @returns Absolute URL for the original incoming request.\n */\nexport function createUrl(request: FastifyRequest): string {\n  return `${request.protocol}://${request.host}${request.originalUrl}`\n}\n\n/**\n * Adapts a Fastify request to a Web Fetch `Request`.\n *\n * @param request Fastify request.\n * @param reply Fastify reply, used to abort work when the connection closes.\n * @returns Fetch-compatible request for React Router.\n */\nexport function createRequest(\n  request: FastifyRequest,\n  reply: FastifyReply,\n): Request {\n  let controller: AbortController | null = new AbortController()\n\n  let init: RequestInit & { duplex?: \"half\" } = {\n    method: request.method,\n    headers: createHeaders(request.headers),\n    signal: controller.signal,\n  }\n\n  reply.raw.once(\"finish\", () => {\n    controller = null\n  })\n  reply.raw.once(\"close\", () => {\n    controller?.abort()\n  })\n\n  if ([\"GET\", \"HEAD\"].includes(request.method) === false) {\n    init.body = getBody(request)\n    init.duplex = \"half\"\n  }\n\n  return new Request(createUrl(request), init)\n}\n\nfunction getBody(request: FastifyRequest): BodyInit | null {\n  let body = request.body\n\n  if (body == null) return createReadableStreamFromReadable(request.raw)\n  if (body instanceof Readable) return createReadableStreamFromReadable(body)\n  if (body instanceof ReadableStream) return body\n  if (body instanceof URLSearchParams) return body\n  if (body instanceof ArrayBuffer) return body\n  if (body instanceof Blob) return body\n  if (body instanceof FormData) return body\n  if (ArrayBuffer.isView(body)) {\n    return new Uint8Array(\n      body.buffer as ArrayBuffer,\n      body.byteOffset,\n      body.byteLength,\n    )\n  }\n  if (typeof body === \"string\") return body\n\n  return JSON.stringify(body)\n}\n","import { Readable } from \"node:stream\"\n\nimport type { FastifyReply } from \"fastify\"\n\n/**\n * Writes a Web Fetch `Response` through a Fastify reply.\n *\n * @param reply Fastify reply.\n * @param response React Router response.\n * @returns A promise that settles after the response is sent.\n */\nexport async function sendResponse(\n  reply: FastifyReply,\n  response: Response,\n): Promise<void> {\n  reply.status(response.status)\n  writeHeaders(reply, response.headers)\n\n  if (response.body == null) {\n    return reply.send()\n  }\n\n  return reply.send(readableFromWeb(response.body))\n}\n\nfunction writeHeaders(reply: FastifyReply, headers: Headers): void {\n  let cookies = readSetCookies(headers)\n\n  for (let [name, value] of headers) {\n    if (name.toLowerCase() === \"set-cookie\" && cookies.length > 0) continue\n    reply.header(name, value)\n  }\n\n  if (cookies.length > 0) {\n    reply.header(\"set-cookie\", cookies)\n  }\n}\n\nfunction readSetCookies(headers: Headers): string[] {\n  let withCookies = headers as Headers & { getSetCookie?: () => string[] }\n  let cookies = withCookies.getSetCookie?.()\n  if (cookies && cookies.length > 0) return cookies\n\n  let cookie = headers.get(\"Set-Cookie\")\n  return cookie ? [cookie] : []\n}\n\nfunction readableFromWeb(body: ReadableStream<Uint8Array>): Readable {\n  let reader = body.getReader()\n\n  return new Readable({\n    read() {\n      reader.read().then(\n        ({ done, value }) => {\n          this.push(done ? null : Buffer.from(value))\n        },\n        (error: unknown) => {\n          this.destroy(\n            error instanceof Error ? error : new Error(String(error)),\n          )\n        },\n      )\n    },\n  })\n}\n","import type { FastifyReply, FastifyRequest } from \"fastify\"\nimport type { RouterContextProvider, ServerBuild } from \"react-router\"\nimport { createRequestHandler as createReactRouterHandler } from \"react-router\"\n\nimport { createRequest } from \"./request.ts\"\nimport { sendResponse } from \"./response.ts\"\n\nexport type HttpRequest = FastifyRequest[\"raw\"]\nexport type HttpResponse = FastifyReply[\"raw\"]\n\nexport type ReactRouterLoadContext = RouterContextProvider\n\nexport type GetLoadContextFunction = (\n  request: FastifyRequest,\n  reply: FastifyReply,\n) =>\n  | ReactRouterLoadContext\n  | undefined\n  | Promise<ReactRouterLoadContext | undefined>\n\nexport type RequestHandler = (\n  request: FastifyRequest,\n  reply: FastifyReply,\n) => Promise<void>\n\nexport interface CreateRequestHandlerOptions {\n  build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>)\n  getLoadContext?: GetLoadContextFunction\n  mode?: string\n}\n\n/**\n * Creates a Fastify route handler backed by React Router's server runtime.\n *\n * @param options React Router build, mode, and optional load context hook.\n * @returns Fastify route handler.\n */\nexport function createRequestHandler(\n  options: CreateRequestHandlerOptions,\n): RequestHandler {\n  let reactRouterHandler = createReactRouterHandler(\n    options.build,\n    options.mode ?? process.env.NODE_ENV,\n  )\n\n  return async (request, reply) => {\n    let webRequest = createRequest(request, reply)\n    let context = await options.getLoadContext?.(request, reply)\n    let webResponse = await reactRouterHandler(webRequest, context)\n    await sendResponse(reply, webResponse)\n  }\n}\n","import path from \"node:path\"\nimport { pathToFileURL } from \"node:url\"\n\nimport fastifyStatic from \"@fastify/static\"\nimport type { FastifyStaticOptions } from \"@fastify/static\"\nimport type { FastifyInstance, RouteShorthandOptions } from \"fastify\"\nimport type { ServerBuild } from \"react-router\"\nimport type { ViteDevServer } from \"vite\"\n\nimport { createRequestHandler, type GetLoadContextFunction } from \"./handler.ts\"\nimport { importSsrModule } from \"./vite-runtime.ts\"\n\nexport interface FastifyReactRouterOptions {\n  devServer?: ViteDevServer\n  basePath?: string\n  serverBuildPath?: string\n  clientBuildDirectory?: string\n  mode?: string\n  getLoadContext?: GetLoadContextFunction\n  build?: ServerBuild | (() => ServerBuild | Promise<ServerBuild>)\n  staticOptions?: FastifyStaticOptions\n  assetCacheControl?: string\n  fileCacheControl?: string\n  routeOptions?: RouteShorthandOptions\n}\n\n/**\n * Fastify plugin that serves React Router framework builds.\n *\n * @param fastify Fastify instance.\n * @param options Adapter options.\n */\nexport async function fastifyReactRouter(\n  fastify: FastifyInstance,\n  options: FastifyReactRouterOptions,\n): Promise<void> {\n  let {\n    devServer,\n    basePath = \"/\",\n    serverBuildPath = \"build/server/index.js\",\n    clientBuildDirectory = \"build/client\",\n    mode = process.env.NODE_ENV,\n    getLoadContext,\n    build,\n    staticOptions,\n    assetCacheControl = \"public, max-age=31536000, immutable\",\n    fileCacheControl = \"public, max-age=3600\",\n    routeOptions,\n  } = options\n\n  let serverBuild =\n    devServer == null\n      ? build ?? createBuildLoader(devServer, path.resolve(serverBuildPath))\n      : createBuildLoader(devServer, path.resolve(serverBuildPath))\n\n  if (devServer == null) {\n    await registerStaticFiles(fastify, {\n      basePath,\n      clientBuildDirectory: path.resolve(clientBuildDirectory),\n      assetCacheControl,\n      fileCacheControl,\n      staticOptions,\n    })\n  }\n\n  let handler = createRequestHandler({\n    build: serverBuild,\n    getLoadContext,\n    mode,\n  })\n\n  fastify.removeAllContentTypeParsers()\n  fastify.addContentTypeParser(\"*\", (_request, payload, done) => {\n    done(null, payload)\n  })\n\n  if (routeOptions) {\n    fastify.all(\"*\", routeOptions, handler)\n  } else {\n    fastify.all(\"*\", handler)\n  }\n}\n\nfunction createBuildLoader(\n  devServer: ViteDevServer | undefined,\n  serverBuildPath: string,\n): ServerBuild | (() => ServerBuild | Promise<ServerBuild>) {\n  if (devServer != null) {\n    return () =>\n      importSsrModule<ServerBuild>(\n        devServer,\n        \"virtual:react-router/server-build\",\n      )\n  }\n\n  return async () =>\n    import(\n      /* @vite-ignore */ pathToFileURL(serverBuildPath).href\n    ) as Promise<ServerBuild>\n}\n\nasync function registerStaticFiles(\n  fastify: FastifyInstance,\n  options: {\n    basePath: string\n    clientBuildDirectory: string\n    assetCacheControl: string\n    fileCacheControl: string\n    staticOptions?: FastifyStaticOptions\n  },\n): Promise<void> {\n  let assetsDirectory = path.join(options.clientBuildDirectory, \"assets\")\n\n  await fastify.register(fastifyStatic, {\n    root: options.clientBuildDirectory,\n    prefix: options.basePath,\n    wildcard: false,\n    cacheControl: false,\n    dotfiles: \"ignore\",\n    etag: true,\n    lastModified: true,\n    setHeaders(res, filePath) {\n      let isAsset = filePath.startsWith(assetsDirectory)\n      res.setHeader(\n        \"cache-control\",\n        isAsset ? options.assetCacheControl : options.fileCacheControl,\n      )\n    },\n    ...options.staticOptions,\n  })\n}\n"],"mappings":"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"}

package/dist/vite-runtime-Cuj_Fjkd.mjs

@@ -0,0 +1,18 @@
+//#region src/vite-runtime.ts
+/**
+* Imports an SSR module using Vite's current Environment runner, with
+* `ssrLoadModule` as a compatibility fallback.
+*
+* @param vite Vite dev server.
+* @param id Module ID to import.
+* @returns Imported module namespace.
+*/
+async function importSsrModule(vite, id) {
+	let ssr = vite.environments?.ssr;
+	if (typeof ssr?.runner?.import === "function") return ssr.runner.import(id);
+	return vite.ssrLoadModule(id);
+}
+//#endregion
+export { importSsrModule as t };
+
+//# sourceMappingURL=vite-runtime-Cuj_Fjkd.mjs.map

package/dist/vite-runtime-Cuj_Fjkd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-runtime-Cuj_Fjkd.mjs","names":[],"sources":["../src/vite-runtime.ts"],"sourcesContent":["import type { DevEnvironment, ViteDevServer } from \"vite\"\n\ninterface RunnableEnvironment extends DevEnvironment {\n  runner: {\n    import(id: string): Promise<Record<string, unknown>>\n  }\n}\n\n/**\n * Imports an SSR module using Vite's current Environment runner, with\n * `ssrLoadModule` as a compatibility fallback.\n *\n * @param vite Vite dev server.\n * @param id Module ID to import.\n * @returns Imported module namespace.\n */\nexport async function importSsrModule<T = Record<string, unknown>>(\n  vite: ViteDevServer,\n  id: string,\n): Promise<T> {\n  let ssr = vite.environments?.ssr as Partial<RunnableEnvironment> | undefined\n  if (typeof ssr?.runner?.import === \"function\") {\n    return ssr.runner.import(id) as Promise<T>\n  }\n\n  return vite.ssrLoadModule(id) as unknown as Promise<T>\n}\n"],"mappings":";;;;;;;;;AAgBA,eAAsB,gBACpB,MACA,IACY;CACZ,IAAI,MAAM,KAAK,cAAc;CAC7B,IAAI,OAAO,KAAK,QAAQ,WAAW,YACjC,OAAO,IAAI,OAAO,OAAO,EAAE;CAG7B,OAAO,KAAK,cAAc,EAAE;AAC9B"}

package/dist/vite.d.mts

@@ -0,0 +1,33 @@
+import { FastifyInstance } from "fastify";
+import { Plugin, ViteDevServer } from "vite";
+
+//#region src/vite.d.ts
+type FastifyAppFactory = (vite: ViteDevServer) => FastifyInstance | Promise<FastifyInstance>;
+interface FastifyReactRouterDevOptions {
+  /** Server module loaded by Vite during `react-router dev`. */
+  entry?: string;
+  /** Named export that creates the Fastify app. Falls back to `default`. */
+  exportName?: string;
+  /**
+   * Keeps local modules imported by the Fastify server entry external in the
+   * React Router SSR build. This preserves singleton module identity for shared
+   * values such as React Router context tokens.
+   *
+   * Pass an array to externalize explicit import specifiers instead.
+   */
+  externalizeServerEntryImports?: boolean | string[];
+}
+/**
+ * Vite plugin that lets `react-router dev` serve through a Fastify app.
+ *
+ * Vite continues to handle its internal client/HMR/module middleware first.
+ * Fastify receives the remaining requests, including the React Router catch-all
+ * installed by `fastifyReactRouter`.
+ *
+ * @param options Development server entry options.
+ * @returns Vite plugin.
+ */
+declare function fastifyReactRouterDev(options?: FastifyReactRouterDevOptions): Plugin;
+//#endregion
+export { FastifyAppFactory, FastifyReactRouterDevOptions, fastifyReactRouterDev };
+//# sourceMappingURL=vite.d.mts.map