@cosmicdrift/kumiko-dev-server 0.19.1 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "Development server bootstrap for Kumiko apps. Bundles the client, mints dev-JWTs, injects the resolved AppSchema, and seeds an admin. Not for production.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",

package/src/__tests__/build-server-bundle.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildServerBundle } from "../build-server-bundle";
+
+// Baut ein Mini-App-Fixture (bin/main.ts + bin/kumiko.ts teilen ein Modul) und
+// prüft das Variante-B-Verhalten: ein Bun.build-Call → server.js + kumiko.js als
+// Entries + geteilter chunk statt zwei vollen Bundles.
+function makeFixture(): string {
+  const dir = mkdtempSync(join(tmpdir(), "server-bundle-"));
+  mkdirSync(join(dir, "bin"));
+  mkdirSync(join(dir, "src"));
+  writeFileSync(join(dir, "package.json"), `${JSON.stringify({ name: "fixture-app" })}\n`);
+  writeFileSync(join(dir, "src/shared.ts"), "export function shared(): number { return 42; }\n");
+  // main.ts → wird zu server.js umbenannt; kumiko.ts macht findRepoRoot zum
+  // repoRoot dieses Fixtures, also wird kumiko.js gebaut.
+  writeFileSync(
+    join(dir, "bin/main.ts"),
+    `import { shared } from "../src/shared";\nconsole.log("server", shared());\n`,
+  );
+  writeFileSync(
+    join(dir, "bin/kumiko.ts"),
+    `import { shared } from "../src/shared";\nconsole.log("migrate", shared());\n`,
+  );
+  return dir;
+}
+
+describe("buildServerBundle (multi-entry + splitting)", () => {
+  test("produces server.js + kumiko.js as entries + a shared chunk", async () => {
+    const dir = makeFixture();
+    try {
+      const result = await buildServerBundle({ cwd: dir, outDir: join(dir, "dist-server") });
+      const outDir = result.outDir;
+
+      // main.ts wurde zu server.js umbenannt.
+      expect(existsSync(join(outDir, "server.js"))).toBe(true);
+      expect(existsSync(join(outDir, "main.js"))).toBe(false);
+      expect(existsSync(join(outDir, "kumiko.js"))).toBe(true);
+
+      const entryFiles = result.entries.map((e) => e.file).sort();
+      expect(entryFiles).toEqual(["kumiko.js", "server.js"]);
+
+      // Das geteilte Modul liegt in einem chunk, nicht in beiden Entries inlined.
+      expect(result.chunks.length).toBeGreaterThanOrEqual(1);
+      const serverSrc = readFileSync(join(outDir, "server.js"), "utf8");
+      expect(serverSrc).toContain("chunk-");
+
+      // Kein Legacy-Drizzle-Output mehr.
+      expect(existsSync(join(outDir, "migration-hooks.js"))).toBe(false);
+      expect(existsSync(join(outDir, "drizzle.config.ts"))).toBe(false);
+
+      // Runtime-package.json mit start-Script, ohne drizzle-deps.
+      const pkg = JSON.parse(readFileSync(join(outDir, "package.json"), "utf8"));
+      expect(pkg.scripts.start).toBe("bun run server.js");
+      expect(Object.keys(pkg.dependencies)).not.toContain("drizzle-kit");
+      expect(Object.keys(pkg.dependencies)).not.toContain("drizzle-orm");
+
+      expect(result.totalBytes).toBeGreaterThan(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/build-server-bundle.ts

@@ -1,37 +1,27 @@
-// buildServerBundle — Production-Server-Bundle für Kumiko-Apps. Pendant
-// zu buildProdBundle (Client). Convention-Driven Discovery liest
-// bin/main.ts + optional drizzle/migration-hooks.ts und produziert ein
-// runtime-self-contained dist-server/ aus dem ein Bun-Alpine-Container
-// ohne Monorepo bootet.
+// buildServerBundle — Production-Server-Bundle für Kumiko-Apps. Pendant zu
+// buildProdBundle (Client). Convention-Driven Discovery liest bin/main.ts
+// (+ optional <repo>/bin/kumiko.ts) und produziert ein runtime-self-contained
+// dist-server/ aus dem ein Bun-Alpine-Container ohne Monorepo bootet.
 //
 // Convention:
 //
-//   bin/main.ts                      →  dist-server/server.js
-//                                       (App-Boot, ruft runProdApp)
-//   <repo>/bin/kumiko.ts             →  dist-server/kumiko.js
-//                                       (Migrate-CLI für Pre-Deploy-Step,
-//                                        gefunden durch walk-up bis bin/kumiko.ts)
-//   drizzle/migration-hooks.ts       →  dist-server/migration-hooks.js
-//                                       (optional — Projection-Rebuild-Marker-
-//                                        Reader, wird via KUMIKO_MIGRATION_HOOKS
-//                                        env-var von der CLI gefunden)
-//   drizzle.config.ts                →  dist-server/drizzle.config.ts
-//                                       (drizzle-kit lädt's per Convention.
-//                                        kumikoDrizzleConfig-Helper-Imports
-//                                        werden inlined damit der Container
-//                                        kein @cosmicdrift/kumiko-dev-server-Paket
-//                                        installiert haben muss.)
-//   dist-server/package.json         →  generiert mit Versionen aus framework +
-//                                       bundled-features package.json
+//   bin/main.ts            →  dist-server/server.js   (App-Boot, ruft runProdApp)
+//   <repo>/bin/kumiko.ts   →  dist-server/kumiko.js   (Migrate-CLI: `schema apply`,
+//                             gefunden via walk-up bis bin/kumiko.ts)
+//   dist-server/package.json → runtime-deps mit gepinnten Versionen
+//
+// Beide Entries werden in EINEM Bun.build-Call mit `splitting` gebaut: das
+// Framework landet als geteilte chunk-*.js, server.js + kumiko.js sind schlanke
+// Entries die sie importieren — statt das Framework pro Entry neu zu inlinen
+// (vorher ~14 MB × N separate Bundles).
 //
 // Output:
 //
 //   dist-server/
-//     server.js                      ← App-Boot-Entry (~1 MB)
-//     kumiko.js                      ← Migrate-CLI (~1 MB)
-//     migration-hooks.js             ← Rebuild-Marker-Reader (optional, ~1 MB)
-//     drizzle.config.ts              ← gebundelter drizzle-kit-Config (~10 KB)
-//     package.json                   ← runtime-deps mit gepinnten Versionen
+//     server.js            ← App-Boot-Entry
+//     kumiko.js            ← Migrate-CLI-Entry (wenn bin/kumiko.ts gefunden)
+//     chunk-*.js           ← geteilte Framework-Chunks
+//     package.json         ← runtime-deps mit gepinnten Versionen
 //
 // Externals — Pakete die NICHT ins Bundle gebakt werden, sondern via
 // `bun install` im Runtime-Container nachgeholt werden:
@@ -41,52 +31,34 @@
 //                       dist-server/package.json#dependencies.
 //
 //   BUILD_ONLY_EXTERNALS — referenziert nur transitiv im Framework, vom
-//                          App-Code aber nie. Tree-Shake wirft sie aus
-//                          dem Bundle, der external-Marker schaltet nur
-//                          das resolution-during-build ab. NICHT in
-//                          runtime-deps.
-//
-// Beide Listen leben hier zentral statt pro-App. Wenn eine App ein neues
-// natively-bound Paket nutzt, fällt es heute in die App-eigene Boilerplate
-// (oder via opts.extraRuntimeExternals) — das wird sich mit
-// auto-Detection entwickeln.
+//                          App-Code aber nie. Tree-Shake wirft sie aus dem
+//                          Bundle, der external-Marker schaltet nur das
+//                          resolution-during-build ab. NICHT in runtime-deps.
 
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 
 const hasBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
 
-// Pakete die das Bundle zur Laufzeit weiter referenziert (`from "<pkg>"`
-// nach Tree-Shake). Native bindings (argon2), worker-thread-Loader (bullmq,
-// ioredis), dynamic-require (postgres, temporal-polyfill) — alles was
-// unter Bun-bundling bricht.
-//
-// `drizzle-kit` + `drizzle-orm` sind im Bundle 0 Refs (drizzle-orm wird
-// inline gebakt), liegen aber in runtime-deps damit der Pre-Deploy-
-// Migrate-Step (`bun /app/kumiko.js migrate apply`) drizzle-kit als CLI
-// findet. drizzle-kit prüft beim Start ob drizzle-orm separat installiert
-// ist und exit'tet sonst mit "Please install latest version of drizzle-orm".
+// Pakete die das Bundle zur Laufzeit weiter referenziert (`from "<pkg>"` nach
+// Tree-Shake). Native bindings (argon2), worker-thread-Loader (bullmq,
+// ioredis), dynamic-require (postgres, temporal-polyfill) — alles was unter
+// Bun-bundling bricht. (drizzle-kit/drizzle-orm sind raus: der Migrate-Pfad
+// nutzt jetzt den framework-eigenen runMigrationsFromDir, kein drizzle-kit.)
 const RUNTIME_EXTERNALS = [
   "@node-rs/argon2",
   "bullmq",
-  "drizzle-kit",
-  "drizzle-orm",
   "ioredis",
   "postgres",
   "temporal-polyfill",
 ] as const;
 
-// Pakete die nur im Build-Stack erscheinen (transitive Imports im
-// Framework), aber vom App-Code nicht referenziert werden. Ohne external-
-// Markierung scheitert bun build an dynamic-imports (z.B. drizzle-kit →
-// @libsql/client). Tree-Shake wirft sie eh aus dem Bundle — der Marker
-// schaltet nur das resolution-during-build ab. NICHT in runtime-deps.
-//
-// drizzle-kit's dialect-resolver macht dynamic-imports zu allen DB-driver-
-// packages (planetscale/libsql/sqlite/neon/vercel/mysql2). Wir nutzen nur
-// postgres → diese werden never-loaded zur Runtime, aber der Bundler will
-// sie resolven. Aufgedeckt durch C1 Empfehlung 4 (bundle-smoke).
+// Pakete die nur im Build-Stack erscheinen (transitive Imports im Framework),
+// aber vom App-Code nicht referenziert werden. Ohne external-Markierung
+// scheitert bun build an dynamic-imports. Tree-Shake wirft sie eh aus dem
+// Bundle — der Marker schaltet nur das resolution-during-build ab. NICHT in
+// runtime-deps.
 const BUILD_ONLY_EXTERNALS = [
   "meilisearch",
   "pino",
@@ -121,12 +93,20 @@ export type BuildServerBundleEntry = {
 
 export type BuildServerBundleResult = {
   readonly outDir: string;
+  /** Benannte Entry-Files (server.js, ggf. kumiko.js). */
   readonly entries: readonly BuildServerBundleEntry[];
+  /** Geteilte Framework-Chunks (von splitting). */
+  readonly chunks: readonly BuildServerBundleEntry[];
+  /** Gesamt-Größe aller Outputs (entries + chunks) in Bytes. */
+  readonly totalBytes: number;
   readonly runtimeDeps: Readonly<Record<string, string>>;
-  /** undefined wenn keine drizzle/migration-hooks.ts existiert. */
-  readonly migrationHooks: BuildServerBundleEntry | undefined;
 };
 
+// Bun benennt Entries nach Source-Basename (bin/main.ts → main.js). server.js
+// ist die Runtime-Convention; der Entry wird von nichts importiert (nur die
+// chunks werden referenziert, per relativem Pfad), darum ist der Rename sicher.
+const ENTRY_RENAMES: Readonly<Record<string, string>> = { "main.js": "server.js" };
+
 export async function buildServerBundle(
   options: BuildServerBundleOptions = {},
 ): Promise<BuildServerBundleResult> {
@@ -151,8 +131,6 @@ export async function buildServerBundle(
       `[buildServerBundle] Repo-Root erkannt (${repoRoot}), aber bin/kumiko.ts fehlt — kann Migrate-CLI nicht bündeln.`,
     );
   }
-  const migrationHooks = discoverMigrationHooks(cwd);
-  const drizzleConfig = discoverDrizzleConfig(cwd);
 
   const externals = [
     ...RUNTIME_EXTERNALS,
@@ -164,29 +142,42 @@ export async function buildServerBundle(
   await rm(outDir, { recursive: true, force: true });
   await mkdir(outDir, { recursive: true });
 
-  const entries: BuildServerBundleEntry[] = [];
-  entries.push(await bundleEntry(serverEntry, outDir, "server.js", externals));
-  if (kumikoCli) {
-    entries.push(await bundleEntry(kumikoCli, outDir, "kumiko.js", externals));
-  }
-  let migrationHooksEntry: BuildServerBundleEntry | undefined;
-  if (migrationHooks) {
-    migrationHooksEntry = await bundleEntry(
-      migrationHooks,
-      outDir,
-      "migration-hooks.js",
-      externals,
-    );
-    entries.push(migrationHooksEntry);
+  // Ein Bun.build-Call mit allen Entries + splitting → das Framework wird
+  // einmal als shared chunk abgelegt statt pro Entry inlined.
+  const entrypoints = kumikoCli ? [serverEntry, kumikoCli] : [serverEntry];
+  const result = await Bun.build({
+    entrypoints,
+    outdir: outDir,
+    target: "bun",
+    external: externals as string[],
+    splitting: true,
+    sourcemap: "none",
+    naming: { entry: "[name].js", chunk: "chunk-[hash].js" },
+    minify: false,
+  });
+  if (!result.success) {
+    const logs = result.logs.map(String).join("\n");
+    throw new Error(`[buildServerBundle] build FAILED:\n${logs}`);
   }
-  // drizzle.config.ts wird mit-bundelt damit drizzle-kit migrate im
-  // Runtime-Container den kumikoDrizzleConfig-Helper nicht via
-  // @cosmicdrift/kumiko-dev-server resolven muss (das Paket ist nicht installiert).
-  // Output behält die .ts-Endung — drizzle-kit's TS-Loader akzeptiert
-  // bundled JavaScript.
-  if (drizzleConfig) {
-    entries.push(await bundleEntry(drizzleConfig, outDir, "drizzle.config.ts", externals));
+
+  // Größe von Disk lesen, nicht aus out.size — letzteres ist für gesplittete
+  // Entry-Points unzuverlässig (meldet teils ~0 für den Entry-Stub).
+  const entries: BuildServerBundleEntry[] = [];
+  const chunks: BuildServerBundleEntry[] = [];
+  for (const out of result.outputs) {
+    const base = out.path.split("/").pop() ?? out.path;
+    if (out.kind === "entry-point") {
+      const desired = ENTRY_RENAMES[base] ?? base;
+      if (desired !== base) {
+        await rename(join(outDir, base), join(outDir, desired));
+      }
+      entries.push({ file: desired, sizeBytes: statSync(join(outDir, desired)).size });
+    } else if (out.kind === "chunk") {
+      chunks.push({ file: base, sizeBytes: statSync(join(outDir, base)).size });
+    }
   }
+  entries.sort((a, b) => a.file.localeCompare(b.file));
+  const totalBytes = [...entries, ...chunks].reduce((sum, e) => sum + e.sizeBytes, 0);
 
   const runtimeDeps = await resolveRuntimeDepsVersions(repoRoot, [
     ...RUNTIME_EXTERNALS,
@@ -202,32 +193,7 @@ export async function buildServerBundle(
   };
   await writeFile(join(outDir, "package.json"), `${JSON.stringify(runtimePkg, null, 2)}\n`);
 
-  return { outDir, entries, runtimeDeps, migrationHooks: migrationHooksEntry };
-}
-
-async function bundleEntry(
-  entry: string,
-  outDir: string,
-  naming: string,
-  externals: readonly string[],
-): Promise<BuildServerBundleEntry> {
-  const result = await Bun.build({
-    entrypoints: [entry],
-    outdir: outDir,
-    target: "bun",
-    external: externals as string[],
-    naming,
-    minify: false,
-  });
-  if (!result.success) {
-    const logs = result.logs.map(String).join("\n");
-    throw new Error(`[buildServerBundle] Bundle ${naming} FAILED:\n${logs}`);
-  }
-  const out = result.outputs[0];
-  if (!out) {
-    throw new Error(`[buildServerBundle] Bundle ${naming}: no output produced.`);
-  }
-  return { file: naming, sizeBytes: out.size };
+  return { outDir, entries, chunks, totalBytes, runtimeDeps };
 }
 
 export function discoverServerEntry(cwd: string): string | undefined {
@@ -238,20 +204,9 @@ export function discoverServerEntry(cwd: string): string | undefined {
   return undefined;
 }
 
-export function discoverDrizzleConfig(cwd: string): string | undefined {
-  const path = join(cwd, "drizzle.config.ts");
-  return existsSync(path) ? path : undefined;
-}
-
-export function discoverMigrationHooks(cwd: string): string | undefined {
-  const path = join(cwd, "drizzle/migration-hooks.ts");
-  return existsSync(path) ? path : undefined;
-}
-
-// Walking up vom App-cwd bis ein Verzeichnis mit `bin/kumiko.ts` und einer
-// monorepo-package.json (workspaces[]) gefunden wird. Failsafe: nach 8
-// Levels aufgeben — nichts gefunden, kein Repo-Root, dann liefert die
-// Funktion undefined und der Caller skippt das CLI-Bundle.
+// Walking up vom App-cwd bis ein Verzeichnis mit `bin/kumiko.ts` gefunden wird.
+// Failsafe: nach 8 Levels aufgeben — nichts gefunden, kein Repo-Root, dann
+// liefert die Funktion undefined und der Caller skippt das CLI-Bundle.
 function findRepoRoot(start: string): string | undefined {
   let cur = start;
   for (let i = 0; i < 8; i++) {
@@ -313,14 +268,22 @@ export function formatServerBuildResult(
   const dim = "\x1b[2m";
   const green = "\x1b[32m";
   const reset = "\x1b[0m";
+  const mb = (bytes: number): string => (bytes / 1024 / 1024).toFixed(2);
   const lines: string[] = [];
   lines.push("");
   lines.push(`  ${green}✓${reset} server bundle ${dim}(${durationMs}ms)${reset}`);
   for (const entry of result.entries) {
-    const sizeMb = (entry.sizeBytes / 1024 / 1024).toFixed(2);
-    lines.push(`    ${cyan}→${reset} ${entry.file}  ${sizeMb} MB`);
+    lines.push(`    ${cyan}→${reset} ${entry.file}  ${mb(entry.sizeBytes)} MB`);
+  }
+  if (result.chunks.length > 0) {
+    const chunkBytes = result.chunks.reduce((sum, c) => sum + c.sizeBytes, 0);
+    lines.push(
+      `    ${cyan}→${reset} ${result.chunks.length} shared chunk(s)  ${mb(chunkBytes)} MB`,
+    );
   }
   const depCount = Object.keys(result.runtimeDeps).length;
-  lines.push(`    ${dim}runtime-deps: ${depCount} packages${reset}`);
+  lines.push(
+    `    ${dim}total: ${mb(result.totalBytes)} MB · runtime-deps: ${depCount} packages${reset}`,
+  );
   return lines.join("\n");
 }

package/src/build.ts

@@ -21,8 +21,6 @@ export {
   type BuildServerBundleOptions,
   type BuildServerBundleResult,
   buildServerBundle,
-  discoverDrizzleConfig,
-  discoverMigrationHooks,
   discoverServerEntry,
   formatServerBuildResult,
 } from "./build-server-bundle";