@cosmicdrift/kumiko-framework 0.19.1 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",

package/src/db/__tests__/rebuild-marker.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { EntityTableMeta } from "../entity-table-meta";
+import { diffSnapshots, snapshotFromMetas } from "../migrate-generator";
+import { readRebuildMarker, rebuildTablesFromDiff, writeRebuildMarker } from "../rebuild-marker";
+
+function meta(
+  tableName: string,
+  extraColumn?: EntityTableMeta["columns"][number],
+): EntityTableMeta {
+  return {
+    tableName,
+    source: "unmanaged",
+    indexes: [],
+    columns: [
+      { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+      ...(extraColumn ? [extraColumn] : []),
+    ],
+  };
+}
+
+function tmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "rebuild-marker-"));
+}
+
+describe("rebuildTablesFromDiff", () => {
+  test("includes new + changed tables, excludes dropped, sorted + unique", () => {
+    const prev = snapshotFromMetas([meta("read_a"), meta("read_c")]);
+    const next = snapshotFromMetas([
+      meta("read_a", { name: "title", pgType: "text", notNull: true }),
+      meta("read_b"),
+    ]);
+    const diff = diffSnapshots(prev, next);
+    expect(rebuildTablesFromDiff(diff)).toEqual(["read_a", "read_b"]);
+  });
+
+  test("no schema change → empty", () => {
+    const snap = snapshotFromMetas([meta("read_a")]);
+    expect(rebuildTablesFromDiff(diffSnapshots(snap, snap))).toEqual([]);
+  });
+});
+
+describe("write/read marker", () => {
+  test("roundtrip: write tables → read them back via migration-id", () => {
+    const dir = tmpDir();
+    try {
+      writeRebuildMarker(dir, "0002_add_locale.sql", ["read_users", "read_text_blocks"]);
+      expect(existsSync(join(dir, "0002_add_locale.rebuild.json"))).toBe(true);
+      expect(readRebuildMarker(dir, "0002_add_locale")).toEqual(["read_users", "read_text_blocks"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("empty table list → no marker file written, read returns []", () => {
+    const dir = tmpDir();
+    try {
+      writeRebuildMarker(dir, "0003_noop.sql", []);
+      expect(existsSync(join(dir, "0003_noop.rebuild.json"))).toBe(false);
+      expect(readRebuildMarker(dir, "0003_noop")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("missing marker → []", () => {
+    const dir = tmpDir();
+    try {
+      expect(readRebuildMarker(dir, "9999_absent")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("corrupt marker file → [] (does not throw)", () => {
+    const dir = tmpDir();
+    try {
+      writeFileSync(join(dir, "0004_broken.rebuild.json"), "{ not json");
+      expect(readRebuildMarker(dir, "0004_broken")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/db/index.ts

@@ -95,6 +95,11 @@ export {
   transaction,
   updateMany,
 } from "./query-api";
+export {
+  readRebuildMarker,
+  rebuildTablesFromDiff,
+  writeRebuildMarker,
+} from "./rebuild-marker";
 export { seedReferenceData } from "./reference-data";
 export { renderTableDdl, renderTablesDdl } from "./render-ddl";
 export { tableExists } from "./schema-inspection";

package/src/db/rebuild-marker.ts

@@ -0,0 +1,75 @@
+// Rebuild-Marker für den drizzle-freien Migrations-Pfad.
+//
+// `kumiko schema generate` schreibt neben jedes `NNNN_<name>.sql` einen
+// Sibling-Marker `NNNN_<name>.rebuild.json`, der die in dieser Migration
+// geänderten/neu angelegten Tabellen listet. `kumiko schema apply` liest den
+// Marker für jede frisch applizierte Migration und rebuildet die betroffenen
+// Projektionen.
+//
+// Bewusst nur **Tabellennamen** (kein Projection-Name): der Generator ist
+// registry-frei (kennt die App-Projektionen nicht). Die Auflösung
+// Tabelle→Projection passiert app-seitig beim Apply via
+// `buildProjectionTableIndex(registry)`. Tabellen ohne zugehörige Projektion
+// werden dort einfach übersprungen.
+//
+// Marker werden zum generate-Zeitpunkt aus dem strukturierten `SchemaDiff`
+// geschrieben — nicht beim Apply aus dem (ggf. hand-editierten) SQL
+// re-derived.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { SchemaDiff } from "./migrate-generator";
+
+const MARKER_VERSION = 1 as const;
+
+type RebuildMarker = {
+  readonly version: typeof MARKER_VERSION;
+  readonly tables: readonly string[];
+};
+
+function markerPathFor(migrationsDir: string, migrationId: string): string {
+  return join(migrationsDir, `${migrationId}.rebuild.json`);
+}
+
+// Tabellen die nach dieser Migration einen Projection-Rebuild brauchen können:
+// neu angelegte + spalten-/index-geänderte. Gelöschte Tabellen NICHT (die
+// Projektion ist mit der Tabelle weg). Sortiert + dedupliziert für stabilen
+// PR-Diff.
+export function rebuildTablesFromDiff(diff: SchemaDiff): readonly string[] {
+  const names = new Set<string>();
+  for (const t of diff.changedTables) names.add(t.tableName);
+  for (const t of diff.newTables) names.add(t.tableName);
+  return [...names].sort();
+}
+
+// Schreibt `<sqlFilename ohne .sql>.rebuild.json`. Leere Tabellen-Liste →
+// kein Marker (z.B. reine Drop-Migration).
+export function writeRebuildMarker(
+  migrationsDir: string,
+  sqlFilename: string,
+  tables: readonly string[],
+): void {
+  // skip: leere Tabellen-Liste → kein Marker (z.B. reine Drop-Migration).
+  if (tables.length === 0) return;
+  const migrationId = sqlFilename.replace(/\.sql$/, "");
+  const marker: RebuildMarker = { version: MARKER_VERSION, tables };
+  writeFileSync(markerPathFor(migrationsDir, migrationId), `${JSON.stringify(marker, null, 2)}\n`);
+}
+
+// Liest die Tabellen-Liste für eine applizierte Migration. Kein Marker /
+// kaputtes File → leere Liste (Migration ohne Projection-Impact).
+export function readRebuildMarker(migrationsDir: string, migrationId: string): readonly string[] {
+  const path = markerPathFor(migrationsDir, migrationId);
+  if (!existsSync(path)) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null || !("tables" in parsed)) return [];
+  const { tables } = parsed;
+  if (!Array.isArray(tables)) return [];
+  return tables.filter((t): t is string => typeof t === "string");
+}

package/src/schema-cli.ts

@@ -17,8 +17,10 @@ import {
   generateMigration,
   loadMigrationsFromDir,
   loadSnapshotJson,
+  rebuildTablesFromDiff,
   type renderTablesDdl,
   runMigrationsFromDir,
+  writeRebuildMarker,
   writeSnapshotJson,
 } from "./db";
 
@@ -105,11 +107,22 @@ export async function runSchemaCli(
       writeFileSync(join(migrationsDir, result.filename), result.sqlContent);
       writeSnapshotJson(snapshotPath, result.snapshot);
 
+      // Rebuild-Marker nur für inkrementelle Migrationen — die Init-Migration
+      // (prevSnapshot===null) legt nur Tabellen an, es gibt keine historischen
+      // Events zum Replayen.
+      const rebuildTables = prevSnapshot === null ? [] : rebuildTablesFromDiff(result.diff);
+      writeRebuildMarker(migrationsDir, result.filename, rebuildTables);
+
       out.log("");
       out.log(`  ✓ ${result.filename}`);
       out.log(
         `    new tables: ${result.diff.newTables.length}, changed: ${result.diff.changedTables.length}, dropped: ${result.diff.droppedTables.length}`,
       );
+      if (rebuildTables.length > 0) {
+        out.log(
+          `    rebuild-marker: ${result.filename.replace(/\.sql$/, ".rebuild.json")} (${rebuildTables.length} table(s))`,
+        );
+      }
       out.log("");
       out.log("  Review + ggf. hand-edit + git add + commit. Apply via: kumiko-schema apply");
       out.log("");