rsbuild-plugin-react-router 0.2.0 → 0.3.1

package/src/dev-runtime-artifacts.ts

@@ -0,0 +1,239 @@
+import { isAbsolute, relative } from 'node:path';
+import type { RsbuildDevServer, Rspack } from '@rsbuild/core';
+import * as Effect from 'effect/Effect';
+import type { ServerBuild } from 'react-router';
+import type { ReactRouterManifestForDev } from './manifest.js';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
+import { resolveServerBuildModuleEffect } from './server-build-resolution.js';
+
+export type ReactRouterDevManifest = ReactRouterManifestForDev;
+
+export type ReactRouterDevBuildPlan = {
+  defaultEntryName: string;
+  entryNames: readonly string[];
+};
+
+export type ReactRouterDevManifestSet = Readonly<
+  Record<string, ReactRouterDevManifest>
+>;
+
+export type ReactRouterServerBuilds = Readonly<Record<string, ServerBuild>>;
+
+export type PairedDevStats = {
+  web: Rspack.Stats;
+  node: Rspack.Stats;
+};
+
+export type DevRuntimeStats = Rspack.Stats | Rspack.MultiStats | PairedDevStats;
+
+export type DependencySnapshot = {
+  files: ReadonlySet<string>;
+  contexts: ReadonlySet<string>;
+  missing: ReadonlySet<string>;
+};
+
+export type DevChangedFiles = {
+  known: boolean;
+  files: ReadonlySet<string>;
+};
+
+export type DevGraphChanges = {
+  web: DevChangedFiles;
+  node: DevChangedFiles;
+};
+
+export type DevCompilationIdentity = symbol;
+export type DevCompileAttemptIdentity = symbol;
+
+export type DevGraphIdentity = {
+  web: DevCompilationIdentity | undefined;
+  node: DevCompilationIdentity | undefined;
+  nodeWeb: DevCompilationIdentity | undefined;
+  attempt: DevCompileAttemptIdentity | undefined;
+};
+
+export type WebArtifact = {
+  manifestsByEntryName: ReactRouterDevManifestSet;
+  dependencies: DependencySnapshot;
+};
+
+export const snapshotDevChangedFiles = (
+  compiler: Pick<Rspack.Compiler, 'modifiedFiles' | 'removedFiles'> | undefined
+): DevChangedFiles => {
+  if (!compiler) {
+    return { known: false, files: new Set() };
+  }
+  return {
+    known:
+      compiler.modifiedFiles !== undefined ||
+      compiler.removedFiles !== undefined,
+    files: new Set([
+      ...(compiler.modifiedFiles ?? []),
+      ...(compiler.removedFiles ?? []),
+    ]),
+  };
+};
+
+export const snapshotDependencies = (
+  compilation: Rspack.Compilation
+): DependencySnapshot => ({
+  files: new Set([
+    ...compilation.fileDependencies,
+    ...(compilation.buildDependencies ?? []),
+  ]),
+  contexts: new Set(compilation.contextDependencies),
+  missing: new Set(compilation.missingDependencies),
+});
+
+const isWithinDirectory = (directory: string, file: string): boolean => {
+  const relativePath = relative(directory, file);
+  return (
+    relativePath === '' ||
+    (!relativePath.startsWith('..') && !isAbsolute(relativePath))
+  );
+};
+
+export const isSafeOneSidedChange = (
+  changes: DevChangedFiles,
+  dependencies: DependencySnapshot
+): boolean => {
+  if (!changes.known || changes.files.size === 0) {
+    return false;
+  }
+  for (const file of changes.files) {
+    if (dependencies.files.has(file) || dependencies.missing.has(file)) {
+      return false;
+    }
+    for (const directory of dependencies.contexts) {
+      if (isWithinDirectory(directory, file)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+export const isPairedDevStats = (
+  stats: DevRuntimeStats
+): stats is PairedDevStats => 'web' in stats && 'node' in stats;
+
+export const getEnvironmentStats = (
+  stats: DevRuntimeStats,
+  name: 'web' | 'node'
+): Rspack.Stats | undefined => {
+  if (isPairedDevStats(stats)) {
+    return stats[name];
+  }
+  const children = Array.isArray((stats as Rspack.MultiStats).stats)
+    ? (stats as Rspack.MultiStats).stats
+    : [stats as Rspack.Stats];
+  return children.find(child => {
+    const compilation = child.compilation;
+    return compilation.name === name || compilation.compiler?.name === name;
+  });
+};
+
+const startServerBuildEvaluationEffect = (
+  server: RsbuildDevServer,
+  entryName: string
+): Effect.Effect<ServerBuild, Error, never> =>
+  tryPluginPromise(() => server.environments.node.loadBundle(entryName)).pipe(
+    Effect.flatMap(buildModule =>
+      resolveServerBuildModuleEffect(
+        buildModule,
+        `Server entry ${JSON.stringify(entryName)}`
+      )
+    )
+  );
+
+const evaluateServerBuildsEffect = (
+  server: RsbuildDevServer,
+  entryNames: readonly string[]
+): Effect.Effect<ReactRouterServerBuilds, Error, never> =>
+  Effect.forEach(
+    entryNames.map(entryName =>
+      startServerBuildEvaluationEffect(server, entryName).pipe(
+        Effect.map(build => [entryName, build] as const)
+      )
+    ),
+    evaluation => evaluation,
+    { concurrency: getCappedPluginConcurrency() }
+  ).pipe(
+    Effect.map(
+      evaluated => Object.fromEntries(evaluated) as Record<string, ServerBuild>
+    )
+  );
+
+export const evaluateServerBuilds = (
+  server: RsbuildDevServer,
+  entryNames: readonly string[]
+): Promise<ReactRouterServerBuilds> =>
+  runPluginEffect(evaluateServerBuildsEffect(server, entryNames));
+
+const assertBuildMatchesManifest = (
+  entryName: string,
+  build: ServerBuild,
+  manifest: ReactRouterDevManifest
+): void => {
+  for (const [routeId, manifestRoute] of Object.entries(manifest.routes)) {
+    const routeModule = build.routes[routeId]?.module;
+    if (!routeModule) {
+      throw new Error(
+        `[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} is missing from the evaluated server build.`
+      );
+    }
+    if (
+      Boolean(manifestRoute.hasLoader) !==
+      (typeof routeModule.loader === 'function')
+    ) {
+      throw new Error(
+        `[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} loader export does not match its web manifest.`
+      );
+    }
+    if (
+      Boolean(manifestRoute.hasAction) !==
+      (typeof routeModule.action === 'function')
+    ) {
+      throw new Error(
+        `[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} action export does not match its web manifest.`
+      );
+    }
+  }
+};
+
+const pinBuildToManifest = (
+  entryName: string,
+  build: ServerBuild,
+  manifest: ReactRouterDevManifest
+): ServerBuild => {
+  assertBuildMatchesManifest(entryName, build, manifest);
+  return {
+    ...build,
+    assets: structuredClone(manifest) as ServerBuild['assets'],
+  };
+};
+
+export const pinServerBuildsToManifests = (
+  builds: ReactRouterServerBuilds,
+  entryNames: readonly string[],
+  manifestsByEntryName: ReactRouterDevManifestSet
+): ReactRouterServerBuilds => {
+  const pinned: Record<string, ServerBuild> = {};
+  for (const entryName of entryNames) {
+    const build = builds[entryName];
+    if (!build) {
+      throw new Error(
+        `[rsbuild-plugin-react-router] Expected server build ${JSON.stringify(entryName)} was not evaluated.`
+      );
+    }
+    const manifest = manifestsByEntryName[entryName];
+    if (!manifest) {
+      throw new Error(
+        `[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} has no matching web manifest.`
+      );
+    }
+    pinned[entryName] = pinBuildToManifest(entryName, build, manifest);
+  }
+  return pinned;
+};

package/src/dev-runtime-compilation.ts

@@ -0,0 +1,171 @@
+import type { Rspack } from '@rsbuild/core';
+import type {
+  DevCompileAttemptIdentity,
+  DevCompilationIdentity,
+  DevRuntimeStats,
+  DevGraphChanges,
+  DevGraphIdentity,
+} from './dev-runtime-artifacts.js';
+
+export type DevCompilerPair = {
+  web: Rspack.Compiler;
+  node: Rspack.Compiler;
+  settledCompilations: WeakSet<Rspack.Compilation>;
+  pendingAttempt?: PendingDevCompilation;
+  currentAttemptIdentity?: DevCompileAttemptIdentity;
+  latestCompletedWebIdentity?: DevCompilationIdentity;
+  latestCompletedWebStats?: Rspack.Stats;
+  latestCompletedNodeStats?: Rspack.Stats;
+  latestWebStart?: CompilationStart;
+  latestNodeStart?: CompilationStart;
+};
+
+export type PendingDevCompilation = {
+  stats: DevRuntimeStats;
+  changes: DevGraphChanges;
+  identity: DevGraphIdentity;
+  webCompilation: Rspack.Compilation;
+  nodeCompilation: Rspack.Compilation;
+};
+
+export type CompilationStart =
+  | { status: 'pending' }
+  | { status: 'started'; identity: DevCompilationIdentity };
+
+type CompilerPairStartSide = 'latestWebStart' | 'latestNodeStart';
+
+export const createDevCompilerPair = ({
+  web,
+  node,
+}: {
+  web: Rspack.Compiler;
+  node: Rspack.Compiler;
+}): DevCompilerPair => ({
+  web,
+  node,
+  settledCompilations: new WeakSet(),
+});
+
+export const resetDevCompilerPair = (pair: DevCompilerPair): void => {
+  pair.pendingAttempt = undefined;
+  pair.currentAttemptIdentity = undefined;
+  pair.latestCompletedWebIdentity = undefined;
+  pair.latestCompletedWebStats = undefined;
+  pair.latestCompletedNodeStats = undefined;
+  pair.latestWebStart = undefined;
+  pair.latestNodeStart = undefined;
+};
+
+export const isLatestStartedCompilation = (
+  identity: DevCompilationIdentity | undefined,
+  start: CompilationStart | undefined
+): boolean =>
+  !identity || (start?.status === 'started' && start.identity === identity);
+
+export const hasPendingCompilation = (pair: DevCompilerPair): boolean =>
+  pair.latestWebStart?.status === 'pending' ||
+  pair.latestNodeStart?.status === 'pending';
+
+export const beginDevCompilerAttempt = (pair: DevCompilerPair): void => {
+  pair.pendingAttempt = undefined;
+  pair.currentAttemptIdentity = Symbol();
+};
+
+export const markDevCompilerPending = (
+  pair: DevCompilerPair,
+  side: CompilerPairStartSide
+): boolean => {
+  const attemptAlreadyPending = hasPendingCompilation(pair);
+  pair[side] = { status: 'pending' };
+  pair.pendingAttempt = undefined;
+  if (!attemptAlreadyPending) {
+    pair.currentAttemptIdentity = Symbol();
+  }
+  return !attemptAlreadyPending;
+};
+
+export const clearDevCompilerStart = (
+  pair: DevCompilerPair,
+  side: CompilerPairStartSide
+): void => {
+  pair[side] = undefined;
+  pair.pendingAttempt = undefined;
+};
+
+export type CompilationIdentityTracker = {
+  getCompilationIdentity(
+    compilation: Rspack.Compilation
+  ): DevCompilationIdentity;
+  getWebIdentityForNodeCompilation(
+    compilation: Rspack.Compilation
+  ): DevCompilationIdentity | undefined;
+  getAttemptIdentityForCompilation(
+    compilation: Rspack.Compilation
+  ): DevCompileAttemptIdentity | undefined;
+  setAttemptIdentityForCompilation(
+    compilation: Rspack.Compilation,
+    identity: DevCompileAttemptIdentity
+  ): void;
+  setWebIdentityForNodeCompilation(
+    compilation: Rspack.Compilation,
+    identity: DevCompilationIdentity
+  ): void;
+};
+
+export const createCompilationIdentityTracker =
+  (): CompilationIdentityTracker => {
+    const identityByCompilation = new WeakMap<
+      Rspack.Compilation,
+      DevCompilationIdentity
+    >();
+    const webIdentityByNodeCompilation = new WeakMap<
+      Rspack.Compilation,
+      DevCompilationIdentity
+    >();
+    const attemptIdentityByCompilation = new WeakMap<
+      Rspack.Compilation,
+      DevCompileAttemptIdentity
+    >();
+
+    return {
+      getCompilationIdentity(
+        compilation: Rspack.Compilation
+      ): DevCompilationIdentity {
+        const existing = identityByCompilation.get(compilation);
+        if (existing) {
+          return existing;
+        }
+        const identity = Symbol();
+        // Keep compact lineage tokens in committed state without retaining entire
+        // Rspack compilation graphs across failed rebuilds.
+        identityByCompilation.set(compilation, identity);
+        return identity;
+      },
+
+      getWebIdentityForNodeCompilation(
+        compilation: Rspack.Compilation
+      ): DevCompilationIdentity | undefined {
+        return webIdentityByNodeCompilation.get(compilation);
+      },
+
+      getAttemptIdentityForCompilation(
+        compilation: Rspack.Compilation
+      ): DevCompileAttemptIdentity | undefined {
+        return attemptIdentityByCompilation.get(compilation);
+      },
+
+      setAttemptIdentityForCompilation(
+        compilation: Rspack.Compilation,
+        identity: DevCompileAttemptIdentity
+      ): void {
+        attemptIdentityByCompilation.set(compilation, identity);
+      },
+
+      setWebIdentityForNodeCompilation(
+        compilation: Rspack.Compilation,
+        identity: DevCompilationIdentity
+      ): void {
+        webIdentityByNodeCompilation.set(compilation, identity);
+      },
+    };
+  };