rsbuild-plugin-react-router 0.7.2 → 0.8.0

package/src/modify-browser-manifest.ts

@@ -1,3 +1,5 @@
+import { BROWSER_MANIFEST_ENTRY_NAME } from './constants.js';
+import { getManifestAssetType, stripAssetQuery } from './manifest-assets.js';
 import { createHash } from 'node:crypto';
 import type { Route, PluginOptions } from './types.js';
 import type { RsbuildPluginAPI, Rspack } from '@rsbuild/core';
@@ -30,6 +32,8 @@ type CompilationAssetWithIntegrity = {
   source?: { source(): string | Buffer };
   info?: {
     integrity?: unknown;
+    assetType?: string;
+    javascriptModule?: boolean;
   };
 };
 
@@ -79,14 +83,10 @@ const toManifestAssetUrl = (assetPrefix: string, assetName: string) => {
 const addIntegrity = (
   sri: Record<string, string>,
   assetPrefix: string,
-  assetName: unknown,
+  assetName: string,
   integrity: unknown
 ) => {
-  if (
-    typeof assetName !== 'string' ||
-    !isManifestJsAsset(assetName) ||
-    typeof integrity !== 'string'
-  ) {
+  if (typeof integrity !== 'string') {
     return;
   }
   sri[toManifestAssetUrl(assetPrefix, assetName)] = integrity;
@@ -111,6 +111,9 @@ export const collectSubresourceIntegrity = (
   const sri: Record<string, string> = {};
 
   for (const asset of stats?.assets ?? []) {
+    if (typeof asset.name !== 'string' || !isManifestJsAsset(asset.name)) {
+      continue;
+    }
     addIntegrity(sri, assetPrefix, asset.name, asset.integrity);
   }
 
@@ -118,7 +121,17 @@ export const collectSubresourceIntegrity = (
     const assets =
       compilation.getAssets() as readonly CompilationAssetWithIntegrity[];
     for (const asset of assets) {
-      if (!isManifestJsAsset(asset.name)) {
+      const assetType =
+        asset.info?.assetType ??
+        (typeof asset.info?.javascriptModule === 'boolean'
+          ? 'javascript'
+          : undefined);
+      if (
+        getManifestAssetType(
+          asset.name,
+          assetType === undefined ? undefined : { [asset.name]: assetType }
+        ) !== 'javascript'
+      ) {
         continue;
       }
       addIntegrity(
@@ -144,13 +157,15 @@ export function registerModifyBrowserManifestAssets(
 ): void {
   const getAssetPrefix =
     typeof assetPrefix === 'function' ? assetPrefix : () => assetPrefix;
-  const manifestChunkNames =
+  const manifestChunkNames = new Set(
     options?.manifestChunkNames ??
-    getReactRouterManifestChunkNames(
-      routes,
-      appDirectory,
-      routeChunkOptions?.splitRouteModules
-    );
+      getReactRouterManifestChunkNames(
+        routes,
+        appDirectory,
+        routeChunkOptions?.splitRouteModules
+      )
+  );
+  manifestChunkNames.add(BROWSER_MANIFEST_ENTRY_NAME);
   const isBuild = Boolean(routeChunkOptions?.isBuild);
   const finalizeSri = Boolean(
     isBuild &&
@@ -165,6 +180,7 @@ export function registerModifyBrowserManifestAssets(
     { assets, sources, compilation }: ManifestProcessAssetsContext,
     { withSri }: { withSri: boolean }
   ): Promise<void> => {
+    if (compilation.errors?.length) return;
     const currentAssetPrefix = getAssetPrefix();
     const stats = createReactRouterManifestStats(
       compilation,
@@ -185,8 +201,17 @@ export function registerModifyBrowserManifestAssets(
     const browserManifest = { ...manifest };
     delete browserManifest.sri;
 
-    const browserManifestAsset = assets[BROWSER_MANIFEST_ASSET];
-    if (browserManifestAsset) {
+    const browserManifestPaths = stats?.assetsByChunkName?.[
+      BROWSER_MANIFEST_ENTRY_NAME
+    ]?.filter(
+      name =>
+        getManifestAssetType(name, stats.assetTypesByName) === 'javascript'
+    ) ?? [BROWSER_MANIFEST_ASSET];
+    // Production consumes the separately emitted versioned manifest. Leave the
+    // placeholder chunk unchanged: its content hash has already been finalized.
+    for (const browserManifestPath of isBuild ? [] : browserManifestPaths) {
+      const browserManifestAsset = assets[browserManifestPath];
+      if (!browserManifestAsset) continue;
       const originalSource = browserManifestAsset.source().toString();
       const serializedManifest = jsesc(browserManifest, { es6: true });
       const newSource = originalSource.replace(
@@ -194,18 +219,22 @@ export function registerModifyBrowserManifestAssets(
         () => serializedManifest
       );
       compilation.updateAsset(
-        BROWSER_MANIFEST_ASSET,
+        browserManifestPath,
         new sources.RawSource(newSource)
       );
     }
 
     if (isBuild) {
       const entryAssets = stats?.assetsByChunkName?.['entry.client'];
-      const entryJsAssets = entryAssets?.filter(isManifestJsAsset) || [];
+      const entryJsAssets =
+        entryAssets?.filter(
+          name =>
+            getManifestAssetType(name, stats?.assetTypesByName) === 'javascript'
+        ) || [];
       const manifestPath = getReactRouterManifestPath({
         version: manifest.version,
         isBuild: true,
-        entryModulePath: entryJsAssets[0],
+        entryModulePath: stripAssetQuery(entryJsAssets[0] ?? ''),
       });
       const manifestSource = `window.__reactRouterManifest=${jsesc(
         browserManifest,

package/src/node-only-manifest.ts

@@ -0,0 +1,52 @@
+import { rspack, type RsbuildPluginAPI, type Rspack } from '@rsbuild/core';
+import { resolve } from 'pathe';
+import type { ReactRouterManifestSnapshot } from './manifest-snapshot.js';
+import type { Route } from './types.js';
+
+// Inspect the compiled graph rather than parsing source: loaders, re-exports,
+// and cached modules must all participate in the compatibility check.
+export const registerNodeOnlyManifestValidation = ({
+  api,
+  routeByFilePath,
+  getSnapshot,
+}: {
+  api: RsbuildPluginAPI;
+  routeByFilePath: ReadonlyMap<string, Route>;
+  getSnapshot: () => ReactRouterManifestSnapshot | null;
+}): void => {
+  api.modifyRspackConfig((config, { environment }) => {
+    if (environment.name !== 'node') return;
+    config.plugins ??= [];
+    config.plugins.push({
+      apply(compiler: Rspack.Compiler) {
+        const name = 'ReactRouterNodeOnlyManifestValidation';
+        compiler.hooks.thisCompilation.tap(name, compilation => {
+          compilation.hooks.afterOptimizeModules.tap(name, modules => {
+            const snapshot = getSnapshot();
+            if (!snapshot) return;
+            for (const module of modules) {
+              if (!(module instanceof rspack.NormalModule)) continue;
+              const route = routeByFilePath.get(
+                resolve(module.resource.split('?')[0])
+              );
+              if (!route) continue;
+              const exports =
+                compilation.moduleGraph.getProvidedExports(module);
+              const saved = snapshot.browser.routes[route.id];
+              if (
+                !Array.isArray(exports) ||
+                !saved ||
+                exports.includes('loader') !== saved.hasLoader ||
+                exports.includes('action') !== saved.hasAction
+              ) {
+                throw new Error(
+                  `Run a full build before building only the node environment: loader/action exports changed for route "${route.id}".`
+                );
+              }
+            }
+          });
+        });
+      },
+    });
+  });
+};

package/src/plugin-utils.ts

@@ -6,10 +6,14 @@ import { JS_EXTENSIONS } from './constants.js';
 const requireFromApp = createRequire(resolve(process.cwd(), 'package.json'));
 
 export const resolveAppPackagePath = (
-  specifier: string
+  specifier: string,
+  rootPath?: string
 ): string | undefined => {
   try {
-    return requireFromApp.resolve(specifier);
+    const require = rootPath
+      ? createRequire(resolve(rootPath, 'package.json'))
+      : requireFromApp;
+    return require.resolve(specifier);
   } catch {
     return undefined;
   }

package/src/prerender-build.ts

@@ -1,14 +1,9 @@
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
 import fsExtra from 'fs-extra';
 import * as Effect from 'effect/Effect';
 import type { RsbuildPluginAPI } from '@rsbuild/core';
-import {
-  createRequestHandler,
-  matchRoutes,
-  type ServerBuild,
-} from 'react-router';
+import { matchRoutes } from 'react-router';
 import { dirname, relative, resolve } from 'pathe';
 import { PLUGIN_NAME, SPA_FALLBACK_HTML_FILE } from './constants.js';
 import { getBuildManifest } from './build-manifest.js';
@@ -31,24 +26,11 @@ import type {
   Config,
   ResolvedReactRouterConfig,
 } from './react-router-config.js';
-import { resolveServerBuildModule } from './server-utils.js';
+import { startServerBuildWorker } from './server-build-worker-client.js';
+import type { ServerBuildDescription } from './server-build-worker-protocol.js';
 import type { PluginOptions, Route } from './types.js';
 import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
 
-type BuildRouteModule = {
-  loader?: unknown;
-  default?: unknown;
-  ErrorBoundary?: unknown;
-};
-
-type PrerenderServerBuild = ServerBuild & {
-  routes: Record<string, { id?: string; module?: BuildRouteModule }>;
-  assets?: {
-    routes?: Record<string, { hasLoader?: boolean }>;
-  };
-  prerender?: string[];
-};
-
 type PrerenderBuildApi = Pick<
   RsbuildPluginAPI,
   'logger' | 'getNormalizedConfig'
@@ -344,7 +326,7 @@ const handleSpaMode = async ({
   api,
 }: {
   handler: (request: Request) => Promise<Response>;
-  build: PrerenderServerBuild;
+  build: ServerBuildDescription;
   clientBuildDir: string;
   basename: string;
   api: PrerenderBuildApi;
@@ -459,7 +441,7 @@ const createPrerenderPathEffect = ({
   options,
 }: {
   path: string;
-  build: PrerenderServerBuild;
+  build: ServerBuildDescription;
   buildRoutes: ReturnType<typeof createPrerenderRoutes>;
   requestHandler: (request: Request) => Promise<Response>;
   clientBuildDir: string;
@@ -596,75 +578,83 @@ export const runReactRouterPrerenderBuild = async (
   await mkdir(clientBuildDir, { recursive: true });
 
   if (!ssr || isPrerenderEnabled) {
-    process.env.IS_RR_BUILD_REQUEST = 'yes';
-    const buildModule = await import(pathToFileURL(serverBuildPath).toString());
-    const build = (await resolveServerBuildModule(
-      buildModule,
-      `Server build ${JSON.stringify(serverBuildPath)}`
-    )) as PrerenderServerBuild;
-    const requestHandler = createRequestHandler(build, 'production');
-
-    if (isPrerenderEnabled) {
-      if (!ssr) {
-        const generated = latestBrowserManifest
-          ? {
-              manifest: latestBrowserManifest,
-              moduleExportsByRouteId: latestBrowserManifestModuleExports,
-            }
-          : await generateReactRouterManifestForDev(
-              routes,
-              pluginOptions,
-              clientStats,
-              appDirectory,
-              assetPrefix,
-              createReactRouterManifestOptions({
-                routeChunks: routeChunkOptions,
-                routeModuleAnalysis,
-              })
-            );
-        assertValidSsrFalsePrerenderExports({
-          routes,
-          manifestRoutes: generated.manifest.routes,
-          routeExports: generated.moduleExportsByRouteId,
-          prerenderPaths,
-          api,
-        });
+    const worker = await startServerBuildWorker({
+      serverBuildPath,
+      mode: 'classic',
+    });
+    try {
+      const build = worker.description;
+      if (!build) {
+        throw new Error(
+          `[${PLUGIN_NAME}] Server build worker returned no build description`
+        );
       }
+      const requestHandler = worker.handler;
+
+      if (isPrerenderEnabled) {
+        if (!ssr) {
+          const generated = latestBrowserManifest
+            ? {
+                manifest: latestBrowserManifest,
+                moduleExportsByRouteId: latestBrowserManifestModuleExports,
+              }
+            : await generateReactRouterManifestForDev(
+                routes,
+                pluginOptions,
+                clientStats,
+                appDirectory,
+                assetPrefix,
+                createReactRouterManifestOptions({
+                  routeChunks: routeChunkOptions,
+                  routeModuleAnalysis,
+                })
+              );
+          assertValidSsrFalsePrerenderExports({
+            routes,
+            manifestRoutes: generated.manifest.routes,
+            routeExports: generated.moduleExportsByRouteId,
+            prerenderPaths,
+            api,
+          });
+        }
+
+        validatePrerenderPathMatches(routes, prerenderPaths);
 
-      validatePrerenderPathMatches(routes, prerenderPaths);
+        if (prerenderPaths.length > 0) {
+          api.logger.info(
+            `Prerender (html): ${prerenderPaths.length} path(s)...`
+          );
+        }
 
-      if (prerenderPaths.length > 0) {
-        api.logger.info(
-          `Prerender (html): ${prerenderPaths.length} path(s)...`
+        const buildRoutes = createPrerenderRoutes(build.routes);
+        await runPluginEffect(
+          createBoundedPrerenderTasksEffect(
+            prerenderPaths,
+            getPrerenderConcurrency(prerenderConfig),
+            path =>
+              createPrerenderPathEffect({
+                path,
+                build,
+                buildRoutes,
+                requestHandler,
+                clientBuildDir,
+                options,
+              })
+          )
         );
       }
 
-      const buildRoutes = createPrerenderRoutes(build.routes);
-      await runPluginEffect(
-        createBoundedPrerenderTasksEffect(
-          prerenderPaths,
-          getPrerenderConcurrency(prerenderConfig),
-          path =>
-            createPrerenderPathEffect({
-              path,
-              build,
-              buildRoutes,
-              requestHandler,
-              clientBuildDir,
-              options,
-            })
-        )
-      );
-    }
-
-    if (!ssr) {
-      await handleSpaMode({
-        handler: requestHandler,
-        build,
-        clientBuildDir,
-        basename,
-        api,
-      });
+      if (!ssr) {
+        await handleSpaMode({
+          handler: requestHandler,
+          build,
+          clientBuildDir,
+          basename,
+          api,
+        });
+      }
+    } finally {
+      await worker.close();
     }
   }