@cosmicdrift/kumiko-framework 0.20.0 → 0.21.1

package/src/migrations/__tests__/detect-drift.integration.test.ts

@@ -1,328 +0,0 @@
-// Integration-Test für detectDrift — vergleicht Journal vs.
-// __drizzle_migrations und expected-Tables vs. Reality. Production-
-// Behavior: assertSchemaCurrent ist der Boot-Gate, jeder False-Positive
-// hier blockiert Container-Starts; jeder False-Negative lässt
-// Schema-Drift unentdeckt durch.
-
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
-import { asRawClient } from "../../db/query";
-import { ensureTemporalPolyfill } from "../../time/polyfill";
-import { detectDrift } from "../schema-drift";
-
-let testDb: BunTestDb;
-let migrationsDir: string;
-
-beforeAll(async () => {
-  await ensureTemporalPolyfill();
-  testDb = await createTestDb();
-});
-
-afterAll(async () => {
-  await testDb.cleanup();
-});
-
-beforeEach(() => {
-  migrationsDir = mkdtempSync(join(tmpdir(), "kumiko-drift-"));
-  mkdirSync(join(migrationsDir, "meta"), { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(migrationsDir, { recursive: true, force: true });
-});
-
-function writeJournal(entries: { idx: number; tag: string }[]): void {
-  const journal = {
-    version: "7",
-    dialect: "postgresql",
-    entries: entries.map((e) => ({
-      idx: e.idx,
-      version: "7",
-      when: 1700000000000 + e.idx,
-      tag: e.tag,
-      breakpoints: true,
-    })),
-  };
-  writeFileSync(join(migrationsDir, "meta/_journal.json"), JSON.stringify(journal));
-}
-
-type SnapshotColumn = {
-  readonly name: string;
-  readonly type: string;
-  readonly primaryKey?: boolean;
-  readonly notNull?: boolean;
-};
-
-function writeSnapshot(
-  idx: number,
-  tables: Array<{ name: string; columns?: Record<string, SnapshotColumn> }>,
-): void {
-  const out: Record<string, unknown> = {};
-  for (const t of tables) {
-    out[`public.${t.name}`] = {
-      schema: "",
-      name: t.name,
-      columns: t.columns ?? {
-        id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-      },
-    };
-  }
-  writeFileSync(
-    join(migrationsDir, "meta", `${String(idx).padStart(4, "0")}_snapshot.json`),
-    JSON.stringify({ tables: out }),
-  );
-}
-
-function writeSnapshotSimple(idx: number, tableNames: string[]): void {
-  writeSnapshot(
-    idx,
-    tableNames.map((name) => ({ name })),
-  );
-}
-
-async function ensureDrizzleMigrationsTable(): Promise<void> {
-  await asRawClient(testDb.db).unsafe(`CREATE SCHEMA IF NOT EXISTS drizzle`);
-  await asRawClient(testDb.db).unsafe(`
-    CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-      id serial PRIMARY KEY,
-      hash text NOT NULL,
-      created_at bigint
-    )
-  `);
-}
-
-async function dropDrizzleMigrationsTable(): Promise<void> {
-  await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drizzle.__drizzle_migrations`);
-}
-
-async function insertAppliedMigration(hash: string): Promise<void> {
-  await asRawClient(testDb.db).unsafe(
-    `INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES ($1, $2)`,
-    [hash, Date.now()],
-  );
-}
-
-describe("detectDrift", () => {
-  beforeEach(async () => {
-    await dropDrizzleMigrationsTable();
-    // Cleanup test tables that might still exist from earlier runs
-    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_users`);
-    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_orders`);
-  });
-
-  test("frische DB ohne __drizzle_migrations + 1 Migration im Journal → 1 pending + table missing", async () => {
-    writeJournal([{ idx: 0, tag: "0000_init" }]);
-    writeSnapshotSimple(0, ["drift_test_users"]);
-
-    const report = await detectDrift(testDb.db, migrationsDir);
-    expect(report.ok).toBe(false);
-    expect(report.pendingMigrations).toHaveLength(1);
-    expect(report.pendingMigrations[0]?.tag).toBe("0000_init");
-    expect(report.missingTables).toEqual(["drift_test_users"]);
-  });
-
-  test("alle Migrations applied + alle Tabellen existieren → ok", async () => {
-    writeJournal([{ idx: 0, tag: "0000_init" }]);
-    writeSnapshotSimple(0, ["drift_test_users"]);
-    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    await ensureDrizzleMigrationsTable();
-    await insertAppliedMigration("hash-0000");
-
-    const report = await detectDrift(testDb.db, migrationsDir);
-    expect(report.ok).toBe(true);
-    expect(report.pendingMigrations).toHaveLength(0);
-    expect(report.missingTables).toHaveLength(0);
-  });
-
-  test("partial applied: Journal hat 2, applied hat 1 → 1 pending", async () => {
-    writeJournal([
-      { idx: 0, tag: "0000_init" },
-      { idx: 1, tag: "0001_add_orders" },
-    ]);
-    writeSnapshotSimple(1, ["drift_test_users", "drift_test_orders"]);
-    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_orders (id uuid PRIMARY KEY)`);
-    await ensureDrizzleMigrationsTable();
-    await insertAppliedMigration("hash-0000"); // nur eine applied
-
-    const report = await detectDrift(testDb.db, migrationsDir);
-    expect(report.ok).toBe(false);
-    expect(report.pendingMigrations).toHaveLength(1);
-    expect(report.pendingMigrations[0]?.tag).toBe("0001_add_orders");
-    expect(report.missingTables).toHaveLength(0);
-  });
-
-  test("alle Migrations applied aber Tabelle fehlt manuell → drift", async () => {
-    writeJournal([{ idx: 0, tag: "0000_init" }]);
-    writeSnapshotSimple(0, ["drift_test_users", "drift_test_orders"]);
-    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    // drift_test_orders bewusst NICHT angelegt (simuliert manuellen DROP)
-    await ensureDrizzleMigrationsTable();
-    await insertAppliedMigration("hash-0000");
-
-    const report = await detectDrift(testDb.db, migrationsDir);
-    expect(report.ok).toBe(false);
-    expect(report.pendingMigrations).toHaveLength(0);
-    expect(report.missingTables).toEqual(["drift_test_orders"]);
-  });
-
-  describe("Layer 3 — column-diff", () => {
-    test("snapshot column NOT NULL aber DB nullable → nullability-mismatch", async () => {
-      writeJournal([{ idx: 0, tag: "0000_init" }]);
-      writeSnapshot(0, [
-        {
-          name: "drift_test_users",
-          columns: {
-            id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-            email: { name: "email", type: "text", notNull: true },
-          },
-        },
-      ]);
-      // DB hat email NULLABLE — drift.
-      await asRawClient(testDb.db).unsafe(
-        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, email text)`,
-      );
-      await ensureDrizzleMigrationsTable();
-      await insertAppliedMigration("hash-0000");
-
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(false);
-      expect(report.columnIssues).toHaveLength(1);
-      const issue = report.columnIssues[0];
-      expect(issue?.kind).toBe("nullability-mismatch");
-      expect(issue?.table).toBe("drift_test_users");
-      expect(issue?.column).toBe("email");
-    });
-
-    test("snapshot column im DB nicht da → missing-column", async () => {
-      writeJournal([{ idx: 0, tag: "0000_init" }]);
-      writeSnapshot(0, [
-        {
-          name: "drift_test_users",
-          columns: {
-            id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-            email: { name: "email", type: "text", notNull: true },
-          },
-        },
-      ]);
-      // DB hat KEINE email-Spalte.
-      await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-      await ensureDrizzleMigrationsTable();
-      await insertAppliedMigration("hash-0000");
-
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(false);
-      expect(report.columnIssues).toHaveLength(1);
-      expect(report.columnIssues[0]?.kind).toBe("missing-column");
-      expect(report.columnIssues[0]?.column).toBe("email");
-    });
-
-    test("DB hat extra Spalte die nicht im Snapshot ist → extra-column", async () => {
-      writeJournal([{ idx: 0, tag: "0000_init" }]);
-      writeSnapshot(0, [
-        {
-          name: "drift_test_users",
-          columns: {
-            id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-          },
-        },
-      ]);
-      // DB hat zusätzliche Spalte (z.B. manueller ALTER TABLE in Prod).
-      await asRawClient(testDb.db).unsafe(
-        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, secret_legacy text)`,
-      );
-      await ensureDrizzleMigrationsTable();
-      await insertAppliedMigration("hash-0000");
-
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(false);
-      expect(report.columnIssues).toHaveLength(1);
-      expect(report.columnIssues[0]?.kind).toBe("extra-column");
-      expect(report.columnIssues[0]?.column).toBe("secret_legacy");
-    });
-
-    test("snapshot type vs db type mismatch → type-mismatch", async () => {
-      writeJournal([{ idx: 0, tag: "0000_init" }]);
-      writeSnapshot(0, [
-        {
-          name: "drift_test_users",
-          columns: {
-            id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-            age: { name: "age", type: "integer" },
-          },
-        },
-      ]);
-      // DB hat age als TEXT statt INTEGER.
-      await asRawClient(testDb.db).unsafe(
-        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, age text)`,
-      );
-      await ensureDrizzleMigrationsTable();
-      await insertAppliedMigration("hash-0000");
-
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(false);
-      const typeIssue = report.columnIssues.find((i) => i.kind === "type-mismatch");
-      expect(typeIssue).toBeDefined();
-      if (typeIssue && typeIssue.kind === "type-mismatch") {
-        expect(typeIssue.column).toBe("age");
-        expect(typeIssue.expected).toBe("integer");
-        expect(typeIssue.actual).toBe("text");
-      }
-    });
-
-    test("clean state: alle Spalten matchen Snapshot → ok + columnIssues=[]", async () => {
-      writeJournal([{ idx: 0, tag: "0000_init" }]);
-      writeSnapshot(0, [
-        {
-          name: "drift_test_users",
-          columns: {
-            id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-            email: { name: "email", type: "text", notNull: true },
-            age: { name: "age", type: "integer" },
-          },
-        },
-      ]);
-      await asRawClient(testDb.db).unsafe(`
-        CREATE TABLE drift_test_users (
-          id uuid PRIMARY KEY,
-          email text NOT NULL,
-          age integer
-        )
-      `);
-      await ensureDrizzleMigrationsTable();
-      await insertAppliedMigration("hash-0000");
-
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(true);
-      expect(report.columnIssues).toEqual([]);
-    });
-  });
-
-  test("public.__drizzle_migrations Fallback (Pre-0.20-Drizzle)", async () => {
-    writeJournal([{ idx: 0, tag: "0000_init" }]);
-    writeSnapshotSimple(0, ["drift_test_users"]);
-    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    // Legacy: Tabelle in public-Schema statt drizzle-Schema
-    await dropDrizzleMigrationsTable();
-    await asRawClient(testDb.db).unsafe(`
-      CREATE TABLE public.__drizzle_migrations (
-        id serial PRIMARY KEY,
-        hash text NOT NULL,
-        created_at bigint
-      )
-    `);
-    try {
-      await asRawClient(testDb.db).unsafe(
-        `INSERT INTO public.__drizzle_migrations (hash, created_at) VALUES ('hash-0000', $1)`,
-        [Date.now()],
-      );
-      const report = await detectDrift(testDb.db, migrationsDir);
-      expect(report.ok).toBe(true);
-    } finally {
-      await asRawClient(testDb.db).unsafe(`DROP TABLE public.__drizzle_migrations`);
-    }
-  });
-});

package/src/migrations/__tests__/detect-projections-to-rebuild.integration.test.ts

@@ -1,134 +0,0 @@
-// Integration-Test für detectProjectionsToRebuild — die Brücke zwischen
-// Snapshot-Diff (Welle 2) und ImplicitProjection (Sprint G). Beweist dass
-// `kumiko migrate generate` das richtige Marker-File schreibt: ein
-// Spalten-Add auf einer r.entity-Tabelle muss als
-// `<feature>:projection:<entity>-entity` rebuild-Kandidat erkannt werden.
-//
-// Production-Behavior: ohne diese Brücke würden die Welle-2- und
-// Sprint-G-Pieces nebeneinander leben aber sich nicht treffen — Marker
-// wäre leer, kein Rebuild würde ausgelöst.
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createBooleanField, createEntity, createTextField, defineFeature } from "../../engine";
-import { createRegistry } from "../../engine/registry";
-import { detectProjectionsToRebuild } from "../projection-detection";
-
-let migrationsDir: string;
-
-beforeEach(() => {
-  migrationsDir = mkdtempSync(join(tmpdir(), "kumiko-detect-"));
-  mkdirSync(join(migrationsDir, "meta"), { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(migrationsDir, { recursive: true, force: true });
-});
-
-function writeJournal(entries: { idx: number; tag: string }[]): void {
-  writeFileSync(
-    join(migrationsDir, "meta/_journal.json"),
-    JSON.stringify({
-      version: "7",
-      dialect: "postgresql",
-      entries: entries.map((e) => ({
-        idx: e.idx,
-        version: "7",
-        when: 1700000000000 + e.idx,
-        tag: e.tag,
-        breakpoints: true,
-      })),
-    }),
-  );
-}
-
-function writeSnapshot(idx: number, tableName: string, columnNames: string[]): void {
-  const columns: Record<string, unknown> = {};
-  for (const name of columnNames) {
-    columns[name] = { name, type: "text" };
-  }
-  // Plus base-columns die jede Entity-Tabelle hat, damit wir nicht mit
-  // dem Test-Compare versehentlich kompletten neue Tabellen markieren.
-  columns["id"] = { name: "id", type: "uuid", primaryKey: true, notNull: true };
-  columns["tenant_id"] = { name: "tenant_id", type: "uuid", notNull: true };
-  columns["version"] = { name: "version", type: "integer", default: 1, notNull: true };
-  writeFileSync(
-    join(migrationsDir, "meta", `${String(idx).padStart(4, "0")}_snapshot.json`),
-    JSON.stringify({
-      tables: {
-        [`public.${tableName}`]: {
-          schema: "",
-          name: tableName,
-          columns,
-        },
-      },
-    }),
-  );
-}
-
-const widgetEntity = createEntity({
-  table: "test_widgets",
-  fields: {
-    name: createTextField({ required: true }),
-    isEnabled: createBooleanField({ default: true }),
-  },
-});
-
-const widgetFeature = defineFeature("detecttest", (r) => {
-  r.entity("widget", widgetEntity);
-});
-
-describe("detectProjectionsToRebuild", () => {
-  test("Spalten-Add auf r.entity-Tabelle → ImplicitProjection als Rebuild-Kandidat", () => {
-    // Initial-Migration: 2 Spalten
-    writeSnapshot(0, "test_widgets", ["name", "is_enabled"]);
-    // Folge-Migration: 3 Spalten (description dazu)
-    writeSnapshot(1, "test_widgets", ["name", "is_enabled", "description"]);
-    writeJournal([
-      { idx: 0, tag: "0000_init" },
-      { idx: 1, tag: "0001_add_description" },
-    ]);
-
-    const registry = createRegistry([widgetFeature]);
-    const projections = detectProjectionsToRebuild(registry, migrationsDir);
-
-    expect(projections).toEqual(["detecttest:projection:widget-entity"]);
-  });
-
-  test("identische Snapshots → keine Rebuild-Kandidaten", () => {
-    writeSnapshot(0, "test_widgets", ["name", "is_enabled"]);
-    writeSnapshot(1, "test_widgets", ["name", "is_enabled"]);
-    writeJournal([
-      { idx: 0, tag: "0000_init" },
-      { idx: 1, tag: "0001_no_op" },
-    ]);
-
-    const registry = createRegistry([widgetFeature]);
-    expect(detectProjectionsToRebuild(registry, migrationsDir)).toEqual([]);
-  });
-
-  test("Initial-Migration (nur ein Snapshot) → leer (keine historischen Events)", () => {
-    writeSnapshot(0, "test_widgets", ["name"]);
-    writeJournal([{ idx: 0, tag: "0000_init" }]);
-
-    const registry = createRegistry([widgetFeature]);
-    expect(detectProjectionsToRebuild(registry, migrationsDir)).toEqual([]);
-  });
-
-  test("Spalten-Add auf einer Tabelle die KEINE Projection ist → leer", () => {
-    // Tabelle "unrelated" ist nicht als Projection registriert (kein
-    // r.entity, keine r.projection). Schema-Change soll keinen
-    // Rebuild-Marker erzeugen.
-    writeSnapshot(0, "unrelated", ["a"]);
-    writeSnapshot(1, "unrelated", ["a", "b"]);
-    writeJournal([
-      { idx: 0, tag: "0000_init" },
-      { idx: 1, tag: "0001_add_b" },
-    ]);
-
-    const registry = createRegistry([widgetFeature]);
-    expect(detectProjectionsToRebuild(registry, migrationsDir)).toEqual([]);
-  });
-});

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

@@ -1,79 +0,0 @@
-// Unit-Tests für die Marker-File-IO. Production-Behavior:
-//   - Generate-Step schreibt Marker mit kanonischer Struktur
-//   - Apply-Step liest Marker zurück (oder null wenn keiner)
-//   - schemaVersion-Mismatch wirft (verhindert dass alte Markers gegen
-//     neue Lese-Logik fahren)
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { readRebuildMarker, writeRebuildMarker } from "../rebuild-marker";
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "kumiko-marker-"));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe("writeRebuildMarker / readRebuildMarker round-trip", () => {
-  test("schreibt File mit kanonischer Struktur", () => {
-    writeRebuildMarker(tmpDir, "0042_brave_taskmaster", [
-      "publicstatus:projection:incident-entity",
-      "publicstatus:projection:component-entity",
-    ]);
-    const raw = readFileSync(join(tmpDir, "0042_brave_taskmaster__rebuild.json"), "utf-8");
-    const parsed = JSON.parse(raw);
-    expect(parsed).toEqual({
-      schemaVersion: 1,
-      migrationTag: "0042_brave_taskmaster",
-      // sortiert — Reihenfolge der projections im Output ist deterministisch
-      projections: [
-        "publicstatus:projection:component-entity",
-        "publicstatus:projection:incident-entity",
-      ],
-    });
-  });
-
-  test("read returns parsed marker", () => {
-    writeRebuildMarker(tmpDir, "0001_foo", ["app:projection:bar-entity"]);
-    const marker = readRebuildMarker(tmpDir, "0001_foo");
-    expect(marker?.migrationTag).toBe("0001_foo");
-    expect(marker?.projections).toEqual(["app:projection:bar-entity"]);
-  });
-
-  test("leere Projection-Liste schreibt KEIN File (Noise-Reduktion)", () => {
-    writeRebuildMarker(tmpDir, "0003_only_index", []);
-    expect(readRebuildMarker(tmpDir, "0003_only_index")).toBeNull();
-  });
-
-  test("read returns null wenn File nicht existiert", () => {
-    expect(readRebuildMarker(tmpDir, "0099_never_written")).toBeNull();
-  });
-
-  test("schemaVersion-Mismatch wirft mit klarer Message", () => {
-    const path = join(tmpDir, "0042_future__rebuild.json");
-    writeFileSync(
-      path,
-      JSON.stringify({ schemaVersion: 999, migrationTag: "0042_future", projections: [] }),
-    );
-    expect(() => readRebuildMarker(tmpDir, "0042_future")).toThrow(/schemaVersion/);
-  });
-
-  test("korrupte JSON wirft (kein silent-null)", () => {
-    const path = join(tmpDir, "0050_corrupt__rebuild.json");
-    writeFileSync(path, "{ this is not json");
-    expect(() => readRebuildMarker(tmpDir, "0050_corrupt")).toThrow();
-  });
-
-  test("Idempotenz: zweiter write überschreibt", () => {
-    writeRebuildMarker(tmpDir, "0010_x", ["a:projection:one-entity"]);
-    writeRebuildMarker(tmpDir, "0010_x", ["a:projection:two-entity"]);
-    const marker = readRebuildMarker(tmpDir, "0010_x");
-    expect(marker?.projections).toEqual(["a:projection:two-entity"]);
-  });
-});