@cosmicdrift/kumiko-dev-server 0.221.0 → 0.223.0

package/bin/kumiko-upgrade.ts

@@ -15,4 +15,5 @@ import { runUpgradeCli } from "@cosmicdrift/kumiko-framework/upgrade-cli";
 const out = { log: (l: string) => console.log(l), err: (l: string) => console.error(l) };
 const appCwd = process.env["INIT_CWD"] ?? process.cwd();
 const code = await runUpgradeCli(process.argv.slice(2), appCwd, out);
-process.exit(code);
+// Let the event loop drain stdout (piped by guard-upgrade-state) before exit.
+process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.221.0",
+  "version": "0.223.0",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Its compose-stacks/env-schema subpaths are consumed at prod boot too — see @cosmicdrift/kumiko-server-runtime for the prod runner itself.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -59,9 +59,9 @@
     "kumiko-upgrade": "./bin/kumiko-upgrade.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.221.0",
-    "@cosmicdrift/kumiko-framework": "0.221.0",
-    "@cosmicdrift/kumiko-server-runtime": "0.221.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.223.0",
+    "@cosmicdrift/kumiko-framework": "0.223.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.223.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

package/src/__tests__/schema-apply.integration.test.ts

@@ -12,11 +12,31 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   asRawClient,
+  buildEntityTable,
   createDbConnection,
+  createEventStoreExecutor,
+  createTenantDb,
   type DbConnection,
+  integer,
+  table as pgTable,
+  selectMany,
   tableExists,
+  uuid,
 } from "@cosmicdrift/kumiko-framework/db";
-import { createTestDb, type TestDb } from "@cosmicdrift/kumiko-framework/stack";
+import {
+  createEntity,
+  createTextField,
+  defineApply,
+  defineFeature,
+  type ProjectionDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createTestDb,
+  type TestDb,
+  TestUsers,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
 import { runSchemaApply } from "../schema-apply";
 
 let testDb: TestDb;
@@ -76,7 +96,7 @@ describe("runSchemaApply", () => {
     expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
   });
 
-  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0, aber laut warnen (522/3)", async () => {
+  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0, aber laut warnen (522/3, #2464)", async () => {
     writeFileSync(
       join(migDir, "0002_more.sql"),
       `CREATE TABLE "read_more" ("id" text PRIMARY KEY);`,
@@ -86,10 +106,86 @@ describe("runSchemaApply", () => {
       JSON.stringify({ version: 1, tables: ["read_more"] }),
     );
 
-    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    // runPendingRebuilds (not the old local helper) owns this warning now —
+    // it logs via createFallbackLogger(...).error(...), not console.warn.
+    const error = spyOn(console, "error").mockImplementation(() => {});
     expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
     expect(await tableExists(conn.db, "public.read_more")).toBe(true);
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Table "read_more"'));
-    warn.mockRestore();
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("read_more"), expect.anything());
+    error.mockRestore();
+  });
+
+  test("failed projection rebuild stays queued and is retried on a later apply with zero new migrations (#2464)", async () => {
+    // Isolate from any pending-rebuild rows the earlier tests in this file left.
+    await asRawClient(conn.db).unsafe(`DROP TABLE IF EXISTS kumiko_pending_rebuilds`);
+
+    const groupId = "00000000-0000-4000-8000-0000000000b1";
+    let failApply = true;
+
+    const failItemEntity = createEntity({
+      table: "read_apply_fail_items",
+      fields: {
+        groupId: createTextField({ required: true }),
+        name: createTextField({ required: true }),
+      },
+    });
+    const failItemTable = buildEntityTable("apply-fail-item", failItemEntity);
+    const failCountsTable = pgTable("read_apply_fail_counts", {
+      groupId: uuid("group_id").primaryKey(),
+      tenantId: uuid("tenant_id").notNull(),
+      itemCount: integer("item_count").notNull().default(0),
+    });
+    const failCountsProjection: ProjectionDefinition = {
+      name: "apply-fail-counts",
+      source: "apply-fail-item",
+      table: failCountsTable,
+      apply: {
+        "apply-fail-item.created": defineApply<{ groupId: string }>(async (event, tx) => {
+          if (failApply) throw new Error("simulated rebuild failure (test)");
+          await asRawClient(tx).unsafe(
+            `INSERT INTO "read_apply_fail_counts" (group_id, tenant_id, item_count) VALUES ($1::uuid, $2::uuid, 1)
+             ON CONFLICT (group_id) DO UPDATE SET item_count = read_apply_fail_counts.item_count + 1`,
+            [event.payload.groupId, event.tenantId],
+          );
+        }),
+      },
+    };
+    const feature = defineFeature("applyfailtest", (r) => {
+      r.entity("apply-fail-item", failItemEntity);
+      r.projection(failCountsProjection);
+    });
+
+    await unsafeCreateEntityTable(conn.db, failItemEntity, "apply-fail-item");
+    await unsafePushTables(conn.db, { readApplyFailCounts: failCountsTable });
+
+    const tdb = createTenantDb(conn.db, TestUsers.admin.tenantId);
+    const executor = createEventStoreExecutor(failItemTable, failItemEntity, {
+      entityName: "apply-fail-item",
+    });
+    await executor.create({ groupId, name: "x" }, TestUsers.admin, tdb);
+
+    writeFileSync(join(migDir, "0003_touch_fail_counts.sql"), "SELECT 1;\n");
+    writeFileSync(
+      join(migDir, "0003_touch_fail_counts.rebuild.json"),
+      JSON.stringify({ version: 1, tables: ["read_apply_fail_counts"] }),
+    );
+
+    const error = spyOn(console, "error").mockImplementation(() => {});
+    const firstRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
+    error.mockRestore();
+    // Fail-loud: a failed rebuild must surface as a non-zero exit, not a
+    // silent 0 — the migration itself is now tracked applied, so without a
+    // persisted queue this table's rebuild would never be retried again.
+    expect(firstRun).toBe(1);
+    const [rowAfterFail] = await selectMany(conn.db, failCountsTable, { groupId });
+    expect(rowAfterFail).toBeUndefined();
+
+    // Second apply: no new migrations (0003 is already tracked), yet the
+    // queued table must still be retried from kumiko_pending_rebuilds.
+    failApply = false;
+    const secondRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
+    expect(secondRun).toBe(0);
+    const [rowAfterRetry] = await selectMany(conn.db, failCountsTable, { groupId });
+    expect(rowAfterRetry?.itemCount).toBe(1);
   });
 });

package/src/schema-apply.ts

@@ -8,19 +8,16 @@
 
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import {
-  createDbConnection,
-  type DbConnection,
-  readRebuildMarker,
-  runMigrationsFromDir,
-} from "@cosmicdrift/kumiko-framework/db";
+import { createDbConnection, runMigrationsFromDir } from "@cosmicdrift/kumiko-framework/db";
 import { createRegistry, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
 import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
-import { buildProjectionTableIndex } from "@cosmicdrift/kumiko-framework/migrations";
+import {
+  queueRebuildsFromMarkers,
+  runPendingRebuilds,
+} from "@cosmicdrift/kumiko-framework/migrations";
 import {
   createEventConsumerStateTable,
   createProjectionStateTable,
-  rebuildProjection,
 } from "@cosmicdrift/kumiko-framework/pipeline";
 import {
   type ComposeFeaturesOptions,
@@ -72,15 +69,34 @@ export async function runSchemaApply(opts: SchemaApplyOptions): Promise<number>
       console.log("");
     }
 
-    // Projection-Rebuild für Tabellen die in frisch applizierten Migrations
-    // geändert wurden (Marker NNNN_<name>.rebuild.json von `schema generate`).
-    // Ohne das blieben read_*-Projektionen nach einem Schema-Change stale.
-    const changedTables = new Set<string>();
-    for (const id of result.applied) {
-      for (const table of readRebuildMarker(migrationsDir, id)) changedTables.add(table);
+    // Projection rebuild: persistent queue instead of "only this run's
+    // result.applied" — otherwise a failed rebuild stays silently stuck
+    // forever, since the migration is already tracked applied and gets
+    // skipped on the next apply (#2464). queueRebuildsFromMarkers persists
+    // the marker tables BEFORE the rebuild; runPendingRebuilds unconditionally
+    // also picks up open entries from earlier, failed runs — not just the
+    // ones this run freshly applied.
+    const thisRunTables = await queueRebuildsFromMarkers(db, {
+      migrationsDir,
+      appliedIds: result.applied,
+    });
+    const registry = createRegistry(composeFeatures([...opts.features], opts));
+    const rebuildRun = await runPendingRebuilds(db, registry, { thisRunTables });
+    if (rebuildRun.rebuilt.length > 0) {
+      console.log(`  Rebuild ${rebuildRun.rebuilt.length} Projection(s)…`);
+      for (const r of rebuildRun.rebuilt) {
+        console.log(`    ↻ ${r.projection} (${r.eventsProcessed} events)`);
+      }
+      console.log("");
     }
-    if (changedTables.size > 0) {
-      await rebuildAffectedProjections(db, [...changedTables], opts);
+    if (rebuildRun.failed.length > 0) {
+      throw new Error(
+        `Projection rebuild failed for: ${rebuildRun.failed
+          .map((f) => `${f.projection} (${f.error})`)
+          .join(
+            "; ",
+          )}. Table(s) stay queued in kumiko_pending_rebuilds — retried on the next apply.`,
+      );
     }
 
     return 0;
@@ -92,39 +108,6 @@ export async function runSchemaApply(opts: SchemaApplyOptions): Promise<number>
   }
 }
 
-async function rebuildAffectedProjections(
-  db: DbConnection,
-  changedTables: readonly string[],
-  opts: SchemaApplyOptions,
-): Promise<void> {
-  const registry = createRegistry(composeFeatures([...opts.features], opts));
-  const tableToProjection = buildProjectionTableIndex(registry);
-
-  const projections = new Set<string>();
-  for (const table of changedTables) {
-    const name = tableToProjection.get(table);
-    if (name) {
-      projections.add(name);
-    } else {
-      // 522/3: a table in a .rebuild.json marker that no longer matches any
-      // registered projection would otherwise rebuild nothing and exit 0 —
-      // indistinguishable from "nothing needed a rebuild".
-      console.warn(
-        `  ⚠ Table "${table}" is in a rebuild marker but matches no registered projection — skipped.`,
-      );
-    }
-  }
-  // skip: no projections matched the changed tables, nothing to rebuild
-  if (projections.size === 0) return;
-
-  console.log(`  Rebuild ${projections.size} Projection(s)…`);
-  for (const name of projections) {
-    const r = await rebuildProjection(name, { db, registry });
-    console.log(`    ↻ ${name} (${r.eventsProcessed} events, ${r.durationMs}ms)`);
-  }
-  console.log("");
-}
-
 export async function runStandaloneSchemaCli(opts: SchemaApplyOptions): Promise<never> {
   const cmd = Bun.argv[2];
   const sub = Bun.argv[3];