react-bun-ssr 0.1.1 → 0.2.0

package/framework/cli/commands.ts

@@ -1,18 +1,23 @@
-import { watch, type FSWatcher } from "node:fs";
 import path from "node:path";
 import {
   buildRouteManifest,
   bundleClientEntries,
   copyDirRecursive,
   createBuildManifest,
-  discoverFileSignature,
   ensureCleanDirectory,
   generateClientEntries,
 } from "../runtime/build-tools";
 import { loadUserConfig, resolveConfig } from "../runtime/config";
-import { ensureDir, existsPath, listEntries, removePath, writeText } from "../runtime/io";
-import { createServer } from "../runtime/server";
-import type { BuildRouteAsset, FrameworkConfig, ResolvedConfig } from "../runtime/types";
+import { ensureDir, existsPath, writeText, writeTextIfChanged } from "../runtime/io";
+import type { FrameworkConfig, ResolvedConfig } from "../runtime/types";
+import {
+  createDevHotEntrypointSource,
+  createProductionServerEntrypointSource,
+  createTestCommands,
+  createTypecheckCommand,
+  parseFlags,
+  RBSSR_DEV_RESTART_EXIT_CODE,
+} from "./internal";
 import { scaffoldApp } from "./scaffold";
 
 function log(message: string): void {
@@ -20,12 +25,6 @@ function log(message: string): void {
   console.log(`[rbssr] ${message}`);
 }
 
-function parseFlags(args: string[]): { force: boolean } {
-  return {
-    force: args.includes("--force"),
-  };
-}
-
 async function getConfig(cwd: string): Promise<{ userConfig: FrameworkConfig; resolved: ResolvedConfig }> {
   const userConfig = await loadUserConfig(cwd);
   const resolved = resolveConfig(userConfig, cwd);
@@ -37,29 +36,7 @@ async function writeProductionServerEntrypoint(options: { distDir: string }): Pr
   await ensureDir(serverDir);
 
   const serverEntryPath = path.join(serverDir, "server.mjs");
-  const content = `import path from "node:path";
-import config from "../../rbssr.config.ts";
-import { startHttpServer } from "../../framework/runtime/index.ts";
-
-const rootDir = path.resolve(path.dirname(Bun.fileURLToPath(import.meta.url)), "../..");
-process.chdir(rootDir);
-
-const manifestPath = path.resolve(rootDir, "dist/manifest.json");
-const manifest = await Bun.file(manifestPath).json();
-
-startHttpServer({
-  config: {
-    ...(config ?? {}),
-    mode: "production",
-  },
-  runtimeOptions: {
-    dev: false,
-    buildManifest: manifest,
-  },
-});
-`;
-
-  await writeText(serverEntryPath, content);
+  await writeText(serverEntryPath, createProductionServerEntrypointSource());
 }
 
 export async function runInit(args: string[], cwd = process.cwd()): Promise<void> {
@@ -109,200 +86,64 @@ export async function runBuild(cwd = process.cwd()): Promise<void> {
 }
 
 export async function runDev(cwd = process.cwd()): Promise<void> {
-  const { userConfig, resolved } = await getConfig(cwd);
-  const generatedDir = path.resolve(cwd, ".rbssr/generated/client-entries");
-  const devClientDir = path.resolve(cwd, ".rbssr/dev/client");
-  const serverSnapshotsRoot = path.resolve(cwd, ".rbssr/dev/server-snapshots");
-  const docsSourceDir = path.resolve(cwd, "docs");
-  const docsSnapshotDir = path.join(serverSnapshotsRoot, "docs");
-
-  await Promise.all([
-    ensureDir(generatedDir),
-    ensureDir(devClientDir),
-    ensureCleanDirectory(serverSnapshotsRoot),
-  ]);
-
-  let routeAssets: Record<string, BuildRouteAsset> = {};
-  let signature = "";
-  let version = 0;
-  let currentServerSnapshotDir = resolved.appDir;
-  const reloadListeners = new Set<(nextVersion: number) => void>();
-  const docsDir = path.resolve(cwd, "docs");
-
-  const watchedRoots = [resolved.appDir];
-  if (await existsPath(docsDir)) {
-    watchedRoots.push(docsDir);
-  }
-
-  const getSourceSignature = async (): Promise<string> => {
-    const signatures = await Promise.all(
-      watchedRoots.map(root => discoverFileSignature(root)),
-    );
-    return signatures.join(":");
+  await getConfig(cwd);
+
+  const generatedDevDir = path.resolve(cwd, ".rbssr/generated/dev");
+  const generatedEntryPath = path.join(generatedDevDir, "entry.ts");
+  await ensureDir(generatedDevDir);
+  await writeTextIfChanged(generatedEntryPath, createDevHotEntrypointSource({
+    cwd,
+    runtimeModulePath: path.resolve(import.meta.dir, "dev-runtime.ts"),
+  }));
+
+  let activeChild: Bun.Subprocess<"inherit", "inherit", "inherit"> | null = null;
+  let shuttingDown = false;
+
+  const forwardSignal = (signal: NodeJS.Signals): void => {
+    shuttingDown = true;
+    activeChild?.kill(signal);
   };
 
-  const notifyReload = (): void => {
-    for (const listener of reloadListeners) {
-      listener(version);
-    }
-  };
-
-  const rebuildIfNeeded = async (force = false): Promise<void> => {
-    const nextSignature = await getSourceSignature();
-    if (!force && nextSignature === signature) {
-      return;
-    }
-
-    signature = nextSignature;
-
-    const snapshotDir = path.join(serverSnapshotsRoot, `v${version + 1}`);
-    const hasDocsSourceDir = await existsPath(docsSourceDir);
-    await Promise.all([
-      (async () => {
-        await ensureCleanDirectory(snapshotDir);
-        await copyDirRecursive(resolved.appDir, snapshotDir);
-      })(),
-      hasDocsSourceDir
-        ? (async () => {
-            await ensureCleanDirectory(docsSnapshotDir);
-            await copyDirRecursive(docsSourceDir, docsSnapshotDir);
-          })()
-        : removePath(docsSnapshotDir),
-    ]);
-
-    const snapshotConfig: ResolvedConfig = {
-      ...resolved,
-      appDir: snapshotDir,
-      routesDir: path.join(snapshotDir, "routes"),
-      rootModule: path.join(snapshotDir, "root.tsx"),
-      middlewareFile: path.join(snapshotDir, "middleware.ts"),
-    };
-
-    const manifest = await buildRouteManifest(snapshotConfig);
-    const entries = await generateClientEntries({
-      config: snapshotConfig,
-      manifest,
-      generatedDir,
-    });
-
-    await ensureCleanDirectory(devClientDir);
-
-    routeAssets = await bundleClientEntries({
-      entries,
-      outDir: devClientDir,
-      dev: true,
-      publicPrefix: "/__rbssr/client/",
-    });
+  process.once("SIGINT", () => {
+    forwardSignal("SIGINT");
+  });
 
-    currentServerSnapshotDir = snapshotDir;
-
-    const staleVersions = (await listEntries(serverSnapshotsRoot))
-      .filter(entry => entry.isDirectory && /^v\d+$/.test(entry.name))
-      .map(entry => entry.name)
-      .sort((a, b) => {
-        const aNum = Number(a.slice(1));
-        const bNum = Number(b.slice(1));
-        return bNum - aNum;
-      })
-      .slice(3);
-    await Promise.all(staleVersions.map(stale => removePath(path.join(serverSnapshotsRoot, stale))));
-
-    version += 1;
-    notifyReload();
-    log(`rebuilt client assets (version ${version})`);
-  };
+  process.once("SIGTERM", () => {
+    forwardSignal("SIGTERM");
+  });
 
-  let rebuildQueue: Promise<void> = Promise.resolve();
-  const enqueueRebuild = (force = false): Promise<void> => {
-    const task = rebuildQueue.then(() => rebuildIfNeeded(force));
-    rebuildQueue = task.catch(error => {
-      // eslint-disable-next-line no-console
-      console.error("[rbssr] rebuild failed", error);
+  while (true) {
+    activeChild = Bun.spawn({
+      cmd: ["bun", "--hot", generatedEntryPath],
+      cwd,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: {
+        ...process.env,
+        RBSSR_DEV_LAUNCHER: "1",
+        RBSSR_DEV_CHILD: "1",
+      },
     });
-    return task;
-  };
 
-  await enqueueRebuild(true);
+    const exitCode = await activeChild.exited;
+    activeChild = null;
 
-  let rebuildTimer: ReturnType<typeof setTimeout> | undefined;
-  const scheduleRebuild = (): void => {
-    if (rebuildTimer) {
-      clearTimeout(rebuildTimer);
+    if (shuttingDown) {
+      return;
     }
 
-    rebuildTimer = setTimeout(() => {
-      rebuildTimer = undefined;
-      void enqueueRebuild(false);
-    }, 75);
-  };
-
-  const watchers: FSWatcher[] = [];
-  for (const root of watchedRoots) {
-    try {
-      const watcher = watch(root, { recursive: true }, () => {
-        scheduleRebuild();
-      });
-      watchers.push(watcher);
-    } catch {
-      log(`recursive file watching unavailable for ${root}; relying on request-time rebuild checks`);
+    if (exitCode === RBSSR_DEV_RESTART_EXIT_CODE) {
+      log("restarting dev child after config change");
+      continue;
     }
-  }
 
-  const cleanup = (): void => {
-    if (rebuildTimer) {
-      clearTimeout(rebuildTimer);
-      rebuildTimer = undefined;
-    }
-    for (const watcher of watchers) {
-      watcher.close();
+    if (exitCode !== 0) {
+      process.exit(exitCode);
     }
-  };
-
-  process.once("SIGINT", () => {
-    cleanup();
-    process.exit(0);
-  });
 
-  process.once("SIGTERM", () => {
-    cleanup();
-    process.exit(0);
-  });
-
-  const server = createServer(
-    {
-      ...userConfig,
-      mode: "development",
-    },
-    {
-      dev: true,
-      getDevAssets: () => routeAssets,
-      reloadVersion: () => version,
-      subscribeReload: listener => {
-        reloadListeners.add(listener);
-        return () => {
-          reloadListeners.delete(listener);
-        };
-      },
-      resolvePaths: () => ({
-        appDir: currentServerSnapshotDir,
-        routesDir: path.join(currentServerSnapshotDir, "routes"),
-        rootModule: path.join(currentServerSnapshotDir, "root.tsx"),
-        middlewareFile: path.join(currentServerSnapshotDir, "middleware.ts"),
-      }),
-      onBeforeRequest: () => {
-        return enqueueRebuild(false);
-      },
-    },
-  );
-
-  const bunServer = Bun.serve({
-    hostname: resolved.host,
-    port: resolved.port,
-    fetch: server.fetch,
-    development: true,
-  });
-
-  log(`dev server listening on ${bunServer.url}`);
+    return;
+  }
 }
 
 export async function runStart(cwd = process.cwd()): Promise<void> {
@@ -328,16 +169,11 @@ function runSubprocess(cmd: string[]): void {
 }
 
 export async function runTypecheck(): Promise<void> {
-  runSubprocess(["bun", "x", "tsc", "--noEmit"]);
+  runSubprocess(createTypecheckCommand());
 }
 
 export async function runTest(extraArgs: string[]): Promise<void> {
-  if (extraArgs.length > 0) {
-    runSubprocess(["bun", "test", ...extraArgs]);
-    return;
+  for (const cmd of createTestCommands(extraArgs)) {
+    runSubprocess(cmd);
   }
-
-  runSubprocess(["bun", "test", "./tests/unit"]);
-  runSubprocess(["bun", "test", "./tests/integration"]);
-  runSubprocess(["bun", "x", "playwright", "test"]);
 }

package/framework/cli/dev-client-watch.ts

@@ -0,0 +1,281 @@
+import path from "node:path";
+import {
+  createClientEntrySetSignature,
+  listBuildOutputFiles,
+  mapBuildOutputsFromMetafile,
+  type ClientEntryFile,
+} from "../runtime/build-tools";
+import { ensureDir, readText, removePath, statPath } from "../runtime/io";
+import type { BuildRouteAsset } from "../runtime/types";
+
+export interface DevClientBuildSnapshot {
+  entrySetSignature: string;
+  routeAssets: Record<string, BuildRouteAsset>;
+  outputFiles: string[];
+  buildCount: number;
+}
+
+export interface DevClientWatchHandle {
+  syncEntries(entries: ClientEntryFile[]): Promise<{ restarted: boolean; entrySetSignature: string }>;
+  getBuildCount(): number;
+  waitForBuildAfter(buildCount: number): Promise<void>;
+  waitUntilReady(): Promise<void>;
+  stop(): Promise<void>;
+}
+
+interface DevClientWatchState {
+  buildCount: number;
+  entrySetSignature: string;
+  entries: ClientEntryFile[];
+  readyPromise: Promise<void>;
+  resolveReady: () => void;
+  rejectReady: (error: unknown) => void;
+  outputFiles: Set<string>;
+  process: Bun.Subprocess<"ignore", "inherit", "inherit"> | null;
+  stopped: boolean;
+  waiters: Array<{
+    minBuildCount: number;
+    resolve: () => void;
+    reject: (error: unknown) => void;
+  }>;
+}
+
+function createDeferred(): {
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (error: unknown) => void;
+} {
+  let resolve!: () => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<void>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return {
+    promise,
+    resolve,
+    reject,
+  };
+}
+
+export function createDevClientWatch(options: {
+  cwd: string;
+  outDir: string;
+  metafilePath: string;
+  entries: ClientEntryFile[];
+  publicPrefix: string;
+  onBuild: (snapshot: DevClientBuildSnapshot) => void | Promise<void>;
+  onLog?: (message: string) => void;
+}): DevClientWatchHandle {
+  const state: DevClientWatchState = {
+    buildCount: 0,
+    entrySetSignature: createClientEntrySetSignature(options.entries),
+    entries: [...options.entries],
+    ...(() => {
+      const deferred = createDeferred();
+      return {
+        readyPromise: deferred.promise,
+        resolveReady: deferred.resolve,
+        rejectReady: deferred.reject,
+      };
+    })(),
+    outputFiles: new Set<string>(),
+    process: null,
+    stopped: false,
+    waiters: [],
+  };
+
+  let metafilePoller: ReturnType<typeof setInterval> | undefined;
+  let lastMetafileMtime = "";
+
+  const stopPolling = (): void => {
+    if (metafilePoller) {
+      clearInterval(metafilePoller);
+      metafilePoller = undefined;
+    }
+  };
+
+  const parseMetafile = async (): Promise<void> => {
+    const stat = await statPath(options.metafilePath);
+    if (!stat?.isFile()) {
+      return;
+    }
+
+    const nextMtime = stat.mtime.toISOString();
+    if (nextMtime === lastMetafileMtime) {
+      return;
+    }
+
+    let metafile: Bun.BuildMetafile;
+    try {
+      metafile = JSON.parse(await readText(options.metafilePath)) as Bun.BuildMetafile;
+    } catch {
+      return;
+    }
+
+    lastMetafileMtime = nextMtime;
+
+    const nextOutputFiles = new Set(listBuildOutputFiles(metafile));
+    const staleOutputFiles = [...state.outputFiles].filter((filePath) => !nextOutputFiles.has(filePath));
+
+    await Promise.all(
+      staleOutputFiles.map((filePath) => removePath(path.resolve(options.cwd, filePath))),
+    );
+
+    state.outputFiles = nextOutputFiles;
+    state.buildCount += 1;
+
+    const readyWaiters = state.waiters.filter((waiter) => state.buildCount > waiter.minBuildCount);
+    state.waiters = state.waiters.filter((waiter) => state.buildCount <= waiter.minBuildCount);
+    for (const waiter of readyWaiters) {
+      waiter.resolve();
+    }
+
+    await options.onBuild({
+      entrySetSignature: state.entrySetSignature,
+      routeAssets: mapBuildOutputsFromMetafile({
+        metafile,
+        entries: state.entries,
+        publicPrefix: options.publicPrefix,
+      }),
+      outputFiles: [...nextOutputFiles].sort(),
+      buildCount: state.buildCount,
+    });
+
+    state.resolveReady();
+  };
+
+  const startProcess = async (): Promise<void> => {
+    await ensureDir(path.dirname(options.metafilePath));
+    await ensureDir(options.outDir);
+    await removePath(options.metafilePath);
+
+    const previousOutputFiles = [...state.outputFiles];
+    const deferred = createDeferred();
+    state.readyPromise = deferred.promise;
+    state.resolveReady = deferred.resolve;
+    state.rejectReady = deferred.reject;
+    state.buildCount = 0;
+    state.outputFiles = new Set<string>();
+    lastMetafileMtime = "";
+
+    if (state.entries.length === 0) {
+      await Promise.all(
+        previousOutputFiles.map((filePath) => removePath(path.resolve(options.cwd, filePath))),
+      );
+      state.resolveReady();
+      return;
+    }
+
+    const cmd = [
+      "bun",
+      "build",
+      "--watch",
+      "--no-clear-screen",
+      "--target=browser",
+      "--format=esm",
+      "--splitting",
+      "--sourcemap=inline",
+      "--outdir",
+      options.outDir,
+      `--metafile=${options.metafilePath}`,
+      "--entry-naming",
+      "[name].[ext]",
+      "--chunk-naming",
+      "[name]-[hash].[ext]",
+      "--asset-naming",
+      "[name]-[hash].[ext]",
+      ...state.entries.map((entry) => entry.entryFilePath),
+    ];
+
+    state.process = Bun.spawn({
+      cmd,
+      cwd: options.cwd,
+      stdin: "ignore",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: process.env,
+    });
+
+    void state.process.exited.then((exitCode) => {
+      if (state.stopped || exitCode === 0) {
+        return;
+      }
+      for (const waiter of state.waiters) {
+        waiter.reject(new Error(`bun build --watch exited with code ${exitCode}`));
+      }
+      state.waiters = [];
+      state.rejectReady(new Error(`bun build --watch exited with code ${exitCode}`));
+    });
+
+    metafilePoller = setInterval(() => {
+      void parseMetafile();
+    }, 75);
+  };
+
+  const stopProcess = async (): Promise<void> => {
+    stopPolling();
+
+    if (!state.process) {
+      return;
+    }
+
+    const active = state.process;
+    state.process = null;
+    active.kill();
+    await active.exited;
+  };
+
+  void startProcess();
+
+  return {
+    async syncEntries(entries) {
+      const nextEntrySetSignature = createClientEntrySetSignature(entries);
+      const restarted = nextEntrySetSignature !== state.entrySetSignature;
+      state.entries = [...entries];
+
+      if (!restarted) {
+        options.onLog?.("kept Bun client watch hot");
+        return {
+          restarted: false,
+          entrySetSignature: state.entrySetSignature,
+        };
+      }
+
+      state.entrySetSignature = nextEntrySetSignature;
+      await stopProcess();
+      await startProcess();
+      options.onLog?.("restarted Bun client watch after entry set change");
+
+      return {
+        restarted: true,
+        entrySetSignature: state.entrySetSignature,
+      };
+    },
+    getBuildCount() {
+      return state.buildCount;
+    },
+    waitForBuildAfter(buildCount) {
+      if (state.buildCount > buildCount || state.entries.length === 0) {
+        return Promise.resolve();
+      }
+
+      return new Promise<void>((resolve, reject) => {
+        state.waiters.push({
+          minBuildCount: buildCount,
+          resolve,
+          reject,
+        });
+      });
+    },
+    waitUntilReady() {
+      return state.readyPromise;
+    },
+    async stop() {
+      state.stopped = true;
+      stopPolling();
+      await stopProcess();
+    },
+  };
+}

package/framework/cli/dev-route-table.ts

@@ -0,0 +1,71 @@
+import { statPath } from "../runtime/io";
+import type { RouteManifest } from "../runtime/types";
+import { ensureWithin } from "../runtime/utils";
+
+export const RBSSR_DEV_RELOAD_TOPIC = "rbssr:reload";
+export const RBSSR_DEV_WS_PATH = "/__rbssr/ws";
+
+export type DevReloadReason =
+  | "client-build"
+  | "route-structure"
+  | "server-runtime"
+  | "markdown-route"
+  | "config-restart";
+
+export interface DevReloadMessage {
+  token: number;
+  reason: DevReloadReason;
+}
+
+function normalizeApiRoutePath(routePath: string): string {
+  return routePath.replace(/\*[A-Za-z0-9_]+/g, "*");
+}
+
+async function serveDevClientAsset(devClientDir: string, request: Request): Promise<Response> {
+  const url = new URL(request.url);
+  const relativePath = url.pathname.replace(/^\/__rbssr\/client\//, "");
+  const resolvedPath = ensureWithin(devClientDir, relativePath);
+  if (!resolvedPath) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  const stat = await statPath(resolvedPath);
+  if (!stat?.isFile()) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  return new Response(Bun.file(resolvedPath), {
+    headers: {
+      "cache-control": "no-store",
+    },
+  });
+}
+
+export function createDevRouteTable(options: {
+  devClientDir: string;
+  manifest: RouteManifest;
+  handleFrameworkFetch: (request: Request) => Promise<Response>;
+}): Record<string, Response | ((request: Request, server: Bun.Server<undefined>) => Response | Promise<Response> | void)> {
+  const routes: Record<
+    string,
+    Response | ((request: Request, server: Bun.Server<undefined>) => Response | Promise<Response> | void)
+  > = {
+    [RBSSR_DEV_WS_PATH]: (request, server) => {
+      const upgraded = server.upgrade(request);
+      if (!upgraded) {
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+    },
+    "/__rbssr/client/*": (request) => {
+      return serveDevClientAsset(options.devClientDir, request);
+    },
+  };
+
+  for (const apiRoute of options.manifest.api) {
+    routes[normalizeApiRoutePath(apiRoute.routePath)] = (request) => {
+      return options.handleFrameworkFetch(request);
+    };
+  }
+
+  return routes;
+}