rsbuild-plugin-react-router 0.3.0 → 0.4.0

package/src/prerender-build.ts

@@ -2,6 +2,7 @@ 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,
@@ -22,7 +23,6 @@ import {
   getPrerenderConcurrency,
   getSsrFalsePrerenderExportErrors,
   normalizePrerenderMatchPath,
-  withBuildRequest,
 } from './prerender.js';
 import type {
   Config,
@@ -30,6 +30,7 @@ import type {
 } from './react-router-config.js';
 import { resolveServerBuildModule } from './server-utils.js';
 import type { PluginOptions, Route } from './types.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
 
 type ReactRouterManifest = Awaited<
   ReturnType<typeof getReactRouterManifestForDev>
@@ -131,6 +132,34 @@ const createDataRequestPath = (
     : `${prerenderPath.replace(/\/$/, '')}.data`;
 };
 
+export const createBuildRequestEffect = <T>(
+  input: string | URL,
+  init: RequestInit | undefined,
+  handle: (request: Request) => Promise<T>
+): Effect.Effect<T, Error, never> =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => new AbortController()),
+    controller =>
+      tryPluginPromise(() =>
+        handle(
+          new Request(input, {
+            ...init,
+            signal: controller.signal,
+          })
+        )
+      ),
+    controller =>
+      Effect.sync(() => {
+        controller.abort();
+      })
+  );
+
+export const withBuildRequest = <T>(
+  input: string | URL,
+  init: RequestInit | undefined,
+  handle: (request: Request) => Promise<T>
+): Promise<T> => runPluginEffect(createBuildRequestEffect(input, init, handle));
+
 const prerenderData = async ({
   handler,
   prerenderPath,
@@ -150,11 +179,21 @@ const prerenderData = async ({
   api: PrerenderBuildApi;
   requestInit?: RequestInit;
 }): Promise<string> => {
-  const dataRequestPath = createDataRequestPath(
+  const dataOutputPath = createDataRequestPath(
     prerenderPath,
     trailingSlashAwareDataRequests
   );
+  // The handler always serves the root route's data at /_root.data, even when
+  // trailing-slash-aware naming writes the root output to /_.data.
+  const dataRequestPath =
+    trailingSlashAwareDataRequests && prerenderPath === '/'
+      ? '/_root.data'
+      : dataOutputPath;
   const normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/');
+  const outputNormalizedPath =
+    dataOutputPath === dataRequestPath
+      ? normalizedPath
+      : `${basename}${dataOutputPath}`.replace(/\/\/+/g, '/');
   const url = new URL(`http://localhost${normalizedPath}`);
   if (onlyRoutes?.length) {
     url.searchParams.set('_routes', onlyRoutes.join(','));
@@ -172,7 +211,10 @@ const prerenderData = async ({
       );
     }
 
-    const outputPath = resolve(clientBuildDir, ...normalizedPath.split('/'));
+    const outputPath = resolve(
+      clientBuildDir,
+      ...outputNormalizedPath.split('/')
+    );
     await mkdir(dirname(outputPath), { recursive: true });
     await writeFile(outputPath, data);
     api.logger.info(
@@ -401,23 +443,30 @@ const validatePrerenderPathMatches = (
   }
 };
 
-const runPrerenderPaths = async ({
+export const createBoundedPrerenderTasksEffect = (
+  prerenderPaths: string[],
+  concurrency: number,
+  renderPath: (path: string) => Effect.Effect<void, Error, never>
+): Effect.Effect<void, Error, never> =>
+  Effect.forEach(prerenderPaths, renderPath, { concurrency, discard: true });
+
+const createPrerenderPathEffect = ({
+  path,
   build,
+  buildRoutes,
   requestHandler,
   clientBuildDir,
   options,
 }: {
+  path: string;
   build: PrerenderServerBuild;
+  buildRoutes: ReturnType<typeof createPrerenderRoutes>;
   requestHandler: (request: Request) => Promise<Response>;
   clientBuildDir: string;
   options: RunReactRouterPrerenderBuildOptions;
-}): Promise<void> => {
-  const { api, basename, future, prerenderConfig, prerenderPaths } = options;
-  const buildRoutes = createPrerenderRoutes(build.routes);
-  const concurrency = getPrerenderConcurrency(prerenderConfig);
-  const pending = new Set<Promise<void>>();
-
-  const enqueue = async (path: string) => {
+}): Effect.Effect<void, Error, never> =>
+  Effect.gen(function* () {
+    const { api, basename, future } = options;
     const matches = matchRoutes(buildRoutes, normalizePrerenderMatchPath(path));
     if (!matches) {
       return;
@@ -431,27 +480,33 @@ const runPrerenderPaths = async ({
 
     if (isResourceRoute) {
       if (manifestRoute.loader && routeId) {
-        await prerenderData({
-          handler: requestHandler,
-          prerenderPath: path,
-          onlyRoutes: [routeId],
-          clientBuildDir,
-          basename,
-          trailingSlashAwareDataRequests:
-            future.unstable_trailingSlashAwareDataRequests,
-          api,
-        });
-        await prerenderResourceRoute({
-          handler: requestHandler,
-          prerenderPath: path,
-          clientBuildDir,
-          basename,
-          api,
-        });
-      } else {
-        api.logger.warn(
-          `⚠️ Skipping prerendering for resource route without a loader: ${routeId}`
+        yield* tryPluginPromise(() =>
+          prerenderData({
+            handler: requestHandler,
+            prerenderPath: path,
+            onlyRoutes: [routeId],
+            clientBuildDir,
+            basename,
+            trailingSlashAwareDataRequests:
+              future.unstable_trailingSlashAwareDataRequests,
+            api,
+          })
+        );
+        yield* tryPluginPromise(() =>
+          prerenderResourceRoute({
+            handler: requestHandler,
+            prerenderPath: path,
+            clientBuildDir,
+            basename,
+            api,
+          })
         );
+      } else {
+        yield* Effect.sync(() => {
+          api.logger.warn(
+            `⚠️ Skipping prerendering for resource route without a loader: ${routeId}`
+          );
+        });
       }
       return;
     }
@@ -463,44 +518,73 @@ const runPrerenderPaths = async ({
       }
       return build.assets?.routes?.[matchedRouteId]?.hasLoader;
     });
-    let data: string | undefined;
-    if (hasLoaders) {
-      data = await prerenderData({
+    const data = hasLoaders
+      ? yield* tryPluginPromise(() =>
+          prerenderData({
+            handler: requestHandler,
+            prerenderPath: path,
+            onlyRoutes: null,
+            clientBuildDir,
+            basename,
+            trailingSlashAwareDataRequests:
+              future.unstable_trailingSlashAwareDataRequests,
+            api,
+          })
+        )
+      : undefined;
+
+    yield* tryPluginPromise(() =>
+      prerenderRoute({
         handler: requestHandler,
         prerenderPath: path,
-        onlyRoutes: null,
         clientBuildDir,
         basename,
-        trailingSlashAwareDataRequests:
-          future.unstable_trailingSlashAwareDataRequests,
         api,
-      });
-    }
-    await prerenderRoute({
-      handler: requestHandler,
-      prerenderPath: path,
-      clientBuildDir,
-      basename,
-      api,
-      requestInit: data
-        ? {
-            headers: {
-              'X-React-Router-Prerender-Data': encodeURI(data),
-            },
-          }
-        : undefined,
-    });
-  };
+        requestInit: data ? createPrerenderDataRequestInit(data) : undefined,
+      })
+    );
+  });
 
-  for (const path of prerenderPaths) {
-    const task = enqueue(path);
-    pending.add(task);
-    task.finally(() => pending.delete(task));
-    if (pending.size >= concurrency) {
-      await Promise.race(pending);
-    }
-  }
-  await Promise.all(pending);
+const createPrerenderDataRequestInit = (
+  data: string
+): RequestInit | undefined => {
+  const encodedData = encodeURI(data);
+  return encodedData.length < 8 * 1024
+    ? {
+        headers: {
+          'X-React-Router-Prerender-Data': encodedData,
+        },
+      }
+    : undefined;
+};
+
+const runPrerenderPaths = async ({
+  build,
+  requestHandler,
+  clientBuildDir,
+  options,
+}: {
+  build: PrerenderServerBuild;
+  requestHandler: (request: Request) => Promise<Response>;
+  clientBuildDir: string;
+  options: RunReactRouterPrerenderBuildOptions;
+}): Promise<void> => {
+  const { prerenderConfig, prerenderPaths } = options;
+  const buildRoutes = createPrerenderRoutes(build.routes);
+  const concurrency = getPrerenderConcurrency(prerenderConfig);
+
+  await runPluginEffect(
+    createBoundedPrerenderTasksEffect(prerenderPaths, concurrency, path =>
+      createPrerenderPathEffect({
+        path,
+        build,
+        buildRoutes,
+        requestHandler,
+        clientBuildDir,
+        options,
+      })
+    )
+  );
 };
 
 export const runReactRouterPrerenderBuild = async (

package/src/prerender.ts

@@ -92,24 +92,6 @@ export const createPrerenderRoutes = (
 export const normalizePrerenderMatchPath = (path: string): string =>
   `/${path}/`.replace(/^\/\/+/, '/');
 
-export const withBuildRequest = async <T>(
-  input: string | URL,
-  init: RequestInit | undefined,
-  handle: (request: Request) => Promise<T>
-): Promise<T> => {
-  const controller = new AbortController();
-  try {
-    return await handle(
-      new Request(input, {
-        ...init,
-        signal: controller.signal,
-      })
-    );
-  } finally {
-    controller.abort();
-  }
-};
-
 export const getSsrFalsePrerenderExportErrors = ({
   routes,
   manifestRoutes,
@@ -267,7 +249,7 @@ export const resolvePrerenderPaths = async (
         [
           'Warning: Paths with dynamic/splat params cannot be prerendered when using `prerender: true`.',
           'You may want to use the `prerender()` API to prerender the following paths:',
-          ...paramRoutes.map(path => `  - ${path}`),
+          ...paramRoutes.map(path => `  - ${path.replace(/^\/(?=[:*])/, '')}`),
         ].join('\n')
       );
     }

package/src/react-router-config.ts

@@ -4,6 +4,9 @@ import type {
 } from '@react-router/dev/config';
 import type { NormalizedConfig } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
+import * as Effect from 'effect/Effect';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
 
 export type BuildEndHook = {
   bivarianceHack(args: {
@@ -45,6 +48,12 @@ type RouteManifestEntry = {
 
 type RouteManifest = Record<string, RouteManifestEntry>;
 
+type ResolveReactRouterConfigResult = {
+  resolved: ResolvedReactRouterConfig;
+  presets: NonNullable<Config['presets']>;
+  hasConfiguredServerModuleFormat: boolean;
+};
+
 export type ResolvedReactRouterConfig = Readonly<{
   appDirectory: string;
   basename: string;
@@ -102,10 +111,15 @@ const mergeReactRouterConfig = (...configs: Config[]): Config => {
             buildEnd: async (
               ...args: Parameters<NonNullable<Config['buildEnd']>>
             ) => {
-              await Promise.all([
-                configA.buildEnd?.(...args),
-                configB.buildEnd?.(...args),
-              ]);
+              await runPluginEffect(
+                Effect.all(
+                  [
+                    tryPluginPromise(() => configA.buildEnd?.(...args)),
+                    tryPluginPromise(() => configB.buildEnd?.(...args)),
+                  ],
+                  { discard: true }
+                )
+              );
             },
           }
         : {}),
@@ -145,76 +159,87 @@ const normalizeSubResourceIntegrity = (config: Config): Config => {
   };
 };
 
-export const resolveReactRouterConfig = async (
+export const resolveReactRouterConfigEffect = (
   reactRouterUserConfig: Config
-): Promise<{
-  resolved: ResolvedReactRouterConfig;
-  presets: NonNullable<Config['presets']>;
-  hasConfiguredServerModuleFormat: boolean;
-}> => {
-  const presets = await Promise.all(
-    (reactRouterUserConfig.presets ?? []).map(async preset => {
-      if (!preset.name) {
-        throw new Error(
-          'React Router presets must have a `name` property defined.'
-        );
-      }
-      if (!preset.reactRouterConfig) {
-        return null;
-      }
-      const { buildEnd: _buildEnd, ...reactRouterUserConfigForPreset } =
-        reactRouterUserConfig;
-      const presetConfig = await preset.reactRouterConfig({
-        reactRouterUserConfig: reactRouterUserConfigForPreset,
-      });
-      if (!presetConfig) return null;
-      const { presets: _presets, ...rest } = presetConfig as Config;
-      return rest;
-    })
-  );
-
-  const userAndPresetConfigs = mergeReactRouterConfig(
-    ...(presets.filter(Boolean) as Config[]).map(normalizeSubResourceIntegrity),
-    normalizeSubResourceIntegrity(reactRouterUserConfig)
-  );
+): Effect.Effect<ResolveReactRouterConfigResult, Error, never> =>
+  Effect.gen(function* () {
+    const presets = yield* Effect.forEach(
+      reactRouterUserConfig.presets ?? [],
+      preset =>
+        Effect.gen(function* () {
+          if (!preset.name) {
+            return yield* Effect.fail(
+              new Error(
+                'React Router presets must have a `name` property defined.'
+              )
+            );
+          }
+          if (!preset.reactRouterConfig) {
+            return null;
+          }
+          const { buildEnd: _buildEnd, ...reactRouterUserConfigForPreset } =
+            reactRouterUserConfig;
+          const presetConfig = yield* tryPluginPromise(() =>
+            preset.reactRouterConfig?.({
+              reactRouterUserConfig: reactRouterUserConfigForPreset,
+            })
+          );
+          if (!presetConfig) return null;
+          const { presets: _presets, ...rest } = presetConfig as Config;
+          return rest;
+        }),
+      { concurrency: getCappedPluginConcurrency() }
+    );
+
+    const userAndPresetConfigs = mergeReactRouterConfig(
+      ...(presets.filter(Boolean) as Config[]).map(
+        normalizeSubResourceIntegrity
+      ),
+      normalizeSubResourceIntegrity(reactRouterUserConfig)
+    );
+
+    const subResourceIntegrity =
+      userAndPresetConfigs.subResourceIntegrity ??
+      userAndPresetConfigs.future?.unstable_subResourceIntegrity ??
+      DEFAULT_CONFIG.subResourceIntegrity;
+    const resolvedFuture: FutureConfig = {
+      ...DEFAULT_CONFIG.future,
+      ...(userAndPresetConfigs.future ?? {}),
+      unstable_subResourceIntegrity: subResourceIntegrity,
+    };
+    const splitRouteModules =
+      userAndPresetConfigs.splitRouteModules ??
+      userAndPresetConfigs.future?.v8_splitRouteModules ??
+      DEFAULT_CONFIG.splitRouteModules;
+
+    let resolved: ResolvedReactRouterConfig = {
+      ...DEFAULT_CONFIG,
+      ...userAndPresetConfigs,
+      future: resolvedFuture,
+      splitRouteModules,
+      subResourceIntegrity,
+      allowedActionOrigins:
+        userAndPresetConfigs.allowedActionOrigins ??
+        DEFAULT_CONFIG.allowedActionOrigins,
+      routes: DEFAULT_CONFIG.routes,
+      unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
+    };
+    if (!resolved.ssr) {
+      resolved = {
+        ...resolved,
+        serverBundles: undefined,
+      };
+    }
 
-  const subResourceIntegrity =
-    userAndPresetConfigs.subResourceIntegrity ??
-    userAndPresetConfigs.future?.unstable_subResourceIntegrity ??
-    DEFAULT_CONFIG.subResourceIntegrity;
-  const resolvedFuture: FutureConfig = {
-    ...DEFAULT_CONFIG.future,
-    ...(userAndPresetConfigs.future ?? {}),
-    unstable_subResourceIntegrity: subResourceIntegrity,
-  };
-  const splitRouteModules =
-    userAndPresetConfigs.splitRouteModules ??
-    userAndPresetConfigs.future?.v8_splitRouteModules ??
-    DEFAULT_CONFIG.splitRouteModules;
-
-  let resolved: ResolvedReactRouterConfig = {
-    ...DEFAULT_CONFIG,
-    ...userAndPresetConfigs,
-    future: resolvedFuture,
-    splitRouteModules,
-    subResourceIntegrity,
-    allowedActionOrigins:
-      userAndPresetConfigs.allowedActionOrigins ??
-      DEFAULT_CONFIG.allowedActionOrigins,
-    routes: DEFAULT_CONFIG.routes,
-    unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
-  };
-  if (!resolved.ssr) {
-    resolved = {
-      ...resolved,
-      serverBundles: undefined,
+    return {
+      resolved,
+      presets: reactRouterUserConfig.presets ?? [],
+      hasConfiguredServerModuleFormat:
+        userAndPresetConfigs.serverModuleFormat !== undefined,
     };
-  }
+  });
 
-  return {
-    resolved,
-    presets: reactRouterUserConfig.presets ?? [],
-    hasConfiguredServerModuleFormat:
-      userAndPresetConfigs.serverModuleFormat !== undefined,
-  };
-};
+export const resolveReactRouterConfig = (
+  reactRouterUserConfig: Config
+): Promise<ResolveReactRouterConfigResult> =>
+  runPluginEffect(resolveReactRouterConfigEffect(reactRouterUserConfig));