rsbuild-plugin-react-router 0.7.2 → 0.8.0

package/src/server-build-worker-protocol.ts

@@ -0,0 +1,69 @@
+// Messages between the build process and `server-build-worker`.
+
+/** Headers as a structured-cloneable list (the DOM lib's Headers is not iterable here). */
+export const headerEntries = (headers: Headers): [string, string][] => {
+  const entries: [string, string][] = [];
+  headers.forEach((value, key) => entries.push([key, value]));
+  return entries;
+};
+
+export type ServerBuildWorkerData = {
+  serverBuildPath: string;
+  mode: 'classic' | 'rsc';
+};
+
+export type ServerBuildWorkerRequest =
+  | { type: 'close' }
+  | {
+      id: number;
+      type: 'request';
+      url: string;
+      method: string;
+      headers: [string, string][];
+      body?: Uint8Array<ArrayBuffer>;
+    }
+  /** Consume a response body only when the parent asks for it. */
+  | { id: number; type: 'read' }
+  /** The parent released the request, possibly without reading its body. */
+  | { id: number; type: 'abort' };
+
+export type SerializedResponse = {
+  status: number;
+  statusText: string;
+  headers: [string, string][];
+  hasBody: boolean;
+};
+
+export type SerializedError = {
+  message: string;
+  stack?: string;
+  name?: string;
+};
+
+export type ServerBuildWorkerResponse =
+  | { type: 'closed' }
+  /** Sent once the bundle is evaluated; carries the classic build description. */
+  | { type: 'ready'; description?: ServerBuildDescription }
+  | { type: 'reply'; id: number; ok: true; response: SerializedResponse }
+  | { type: 'body'; id: number; ok: true; body: Uint8Array<ArrayBuffer> }
+  | { type: 'reply'; id: number; ok: false; error: SerializedError };
+
+/**
+ * The parts of a classic React Router server build that build-time rendering
+ * reads, as plain data: route module exports are reported by presence only.
+ */
+export type ServerBuildDescription = {
+  prerender?: string[];
+  routes: Record<
+    string,
+    {
+      id?: string;
+      parentId?: string;
+      path?: string;
+      index?: boolean;
+      caseSensitive?: boolean;
+      module: { default: boolean; ErrorBoundary: boolean; loader: boolean };
+    }
+  >;
+  assets: { routes: Record<string, { hasLoader?: boolean }> };
+};

package/src/server-build-worker.ts

@@ -0,0 +1,192 @@
+// Worker entry: evaluates a built server bundle and serves requests to it for
+// build-time rendering; see `startServerBuildWorker` for why this is a worker.
+// `IS_RR_BUILD_REQUEST` is set for this module graph only.
+import { parentPort, workerData } from 'node:worker_threads';
+import { pathToFileURL } from 'node:url';
+import { createRequestHandler, type ServerBuild } from 'react-router';
+import { PLUGIN_NAME } from './constants.js';
+import { resolveServerBuildModule } from './server-build-resolution.js';
+import {
+  headerEntries,
+  type ServerBuildWorkerData,
+  type ServerBuildWorkerRequest,
+  type ServerBuildWorkerResponse,
+  type ServerBuildDescription,
+  type SerializedError,
+} from './server-build-worker-protocol.js';
+
+const port = parentPort;
+if (!port) {
+  throw new Error('server-build-worker must run as a worker thread');
+}
+
+const { serverBuildPath, mode } = workerData as ServerBuildWorkerData;
+process.env.IS_RR_BUILD_REQUEST = 'yes';
+
+const post = (
+  message: ServerBuildWorkerResponse,
+  transfer: ArrayBuffer[] = []
+): void => {
+  port.postMessage(message, transfer);
+};
+
+const serializeError = (error: unknown): SerializedError => {
+  const value = error as { message?: unknown; stack?: unknown; name?: unknown };
+  return {
+    message: String(value?.message ?? error),
+    stack: typeof value?.stack === 'string' ? value.stack : undefined,
+    name: typeof value?.name === 'string' ? value.name : undefined,
+  };
+};
+
+const describeClassicBuild = (build: ServerBuild): ServerBuildDescription => ({
+  prerender: build.prerender,
+  routes: Object.fromEntries(
+    Object.entries(build.routes).flatMap(([id, route]) =>
+      route
+        ? [
+            [
+              id,
+              {
+                id: route.id,
+                parentId: route.parentId,
+                path: route.path,
+                index: route.index,
+                caseSensitive: route.caseSensitive,
+                module: {
+                  default: route.module.default !== undefined,
+                  ErrorBoundary: route.module.ErrorBoundary !== undefined,
+                  loader: route.module.loader !== undefined,
+                },
+              },
+            ],
+          ]
+        : []
+    )
+  ),
+  assets: {
+    routes: Object.fromEntries(
+      Object.entries(build.assets.routes).flatMap(([id, route]) =>
+        route ? [[id, { hasLoader: route.hasLoader }]] : []
+      )
+    ),
+  },
+});
+
+const resolveRscFetch = (
+  buildModule: unknown
+): ((request: Request) => Promise<Response>) => {
+  const moduleRecord = buildModule as
+    | { default?: { fetch?: unknown; default?: { fetch?: unknown } } }
+    | undefined;
+  const fetch =
+    typeof moduleRecord?.default?.fetch === 'function'
+      ? moduleRecord.default.fetch
+      : typeof moduleRecord?.default?.default?.fetch === 'function'
+        ? moduleRecord.default.default.fetch
+        : null;
+  if (!fetch) {
+    throw new Error(
+      `[${PLUGIN_NAME}] RSC server build ${JSON.stringify(
+        serverBuildPath
+      )} must default-export an object with a fetch function.`
+    );
+  }
+  return fetch as (request: Request) => Promise<Response>;
+};
+
+const buildModule = await import(pathToFileURL(serverBuildPath).href);
+let description: ServerBuildDescription | undefined;
+let handler: (request: Request) => Promise<Response>;
+if (mode === 'classic') {
+  const build = await resolveServerBuildModule(
+    buildModule,
+    `Server build ${JSON.stringify(serverBuildPath)}`
+  );
+  description = describeClassicBuild(build);
+  handler = createRequestHandler(build, 'production');
+} else {
+  handler = resolveRscFetch(buildModule);
+}
+
+// One AbortController per in-flight request, so the Request the app receives
+// is aborted when the parent releases it (`createBuildRequestEffect`) or once
+// its response has been consumed here, mirroring the in-process contract.
+const controllers = new Map<number, AbortController>();
+const responses = new Map<number, Response>();
+const release = (id: number): void => {
+  controllers.get(id)?.abort();
+  controllers.delete(id);
+  responses.delete(id);
+};
+
+port.on('message', async (message: ServerBuildWorkerRequest) => {
+  if (message.type === 'close') {
+    for (const id of controllers.keys()) release(id);
+    post({ type: 'closed' });
+    return;
+  }
+  if (message.type === 'abort') {
+    // Cancellation can itself stay pending in application streams. It must
+    // not prevent request cleanup or worker shutdown.
+    void responses
+      .get(message.id)
+      ?.body?.cancel()
+      .catch(() => {});
+    release(message.id);
+    return;
+  }
+  if (message.type === 'read') {
+    try {
+      const response = responses.get(message.id);
+      if (!response) throw new Error('Server build response was released');
+      const body = new Uint8Array(await response.arrayBuffer());
+      release(message.id);
+      post({ type: 'body', id: message.id, ok: true, body }, [body.buffer]);
+    } catch (error) {
+      release(message.id);
+      post({
+        type: 'reply',
+        id: message.id,
+        ok: false,
+        error: serializeError(error),
+      });
+    }
+    return;
+  }
+  const controller = new AbortController();
+  controllers.set(message.id, controller);
+  try {
+    const response = await handler(
+      new Request(message.url, {
+        method: message.method,
+        headers: message.headers,
+        body: message.body,
+        signal: controller.signal,
+      })
+    );
+    if (response.body) responses.set(message.id, response);
+    else release(message.id);
+    post({
+      type: 'reply',
+      id: message.id,
+      ok: true,
+      response: {
+        status: response.status,
+        statusText: response.statusText,
+        headers: headerEntries(response.headers),
+        hasBody: response.body !== null,
+      },
+    });
+  } catch (error) {
+    release(message.id);
+    post({
+      type: 'reply',
+      id: message.id,
+      ok: false,
+      error: serializeError(error),
+    });
+  }
+});
+
+post({ type: 'ready', description });

package/src/server-utils.ts

@@ -88,8 +88,6 @@ export function generateServerBuild(
   `;
 }
 
-export { resolveServerBuildModule };
-
 export function resolveReactRouterServerBuild(
   buildModule: unknown
 ): Promise<ServerBuild> {

package/src/types.ts

@@ -11,6 +11,13 @@ export type Route = {
 };
 
 export type PluginOptions = {
+  /**
+   * Generate React Router route types during development and builds.
+   * Set to false when type generation is managed separately.
+   * @default true
+   */
+  typegen?: boolean;
+
   /**
    * Whether to disable automatic middleware setup for custom server implementation.
    * Use this when you want to handle server setup manually.