@cosmicdrift/kumiko-dev-server 0.64.0 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.64.0",
+  "version": "0.66.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>",
@@ -30,6 +30,10 @@
       "types": "./src/compose-features.ts",
       "default": "./src/compose-features.ts"
     },
+    "./schema-apply": {
+      "types": "./src/schema-apply.ts",
+      "default": "./src/schema-apply.ts"
+    },
     "./schema-tables-auth-mode": {
       "types": "./src/schema-tables-auth-mode.ts",
       "default": "./src/schema-tables-auth-mode.ts"
@@ -46,8 +50,8 @@
     "kumiko-schema-check": "./bin/kumiko-schema-check.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.57.2",
-    "@cosmicdrift/kumiko-framework": "0.57.2",
+    "@cosmicdrift/kumiko-bundled-features": "0.66.0",
+    "@cosmicdrift/kumiko-framework": "0.66.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

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

@@ -0,0 +1,92 @@
+// Production-Behavior von `kumiko schema apply` (runSchemaApply): der
+// migrate-initContainer ruft das gegen eine frische CNPG-DB. Der riskante,
+// neue Teil gegenüber dem alten per-App-Boilerplate ist der Greenfield-
+// Bootstrap — Infra-Tabellen (event-store + pipeline-state) MÜSSEN vor den
+// App-Migrations idempotent angelegt werden, sonst bricht eine leere DB an
+// `relation "kumiko_events" does not exist`. Dieser Test fährt den echten
+// Pfad gegen eine leere DB + den idempotenten Re-Run.
+
+import { afterAll, beforeAll, 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 {
+  asRawClient,
+  createDbConnection,
+  type DbConnection,
+  tableExists,
+} from "@cosmicdrift/kumiko-framework/db";
+import { createTestDb, type TestDb } from "@cosmicdrift/kumiko-framework/stack";
+import { runSchemaApply } from "../schema-apply";
+
+let testDb: TestDb;
+let conn: { readonly db: DbConnection; readonly close: () => Promise<void> };
+let appCwd: string;
+let migDir: string;
+const savedDbUrl = process.env["DATABASE_URL"];
+
+const APPLY = { features: [], includeBundled: false } as const;
+
+beforeAll(async () => {
+  const base = process.env["TEST_DATABASE_URL"];
+  if (!base) throw new Error("TEST_DATABASE_URL required for schema-apply integration test");
+
+  testDb = await createTestDb();
+  const testUrl = base.replace(/\/[^/]+$/, `/${testDb.dbName}`);
+  process.env["DATABASE_URL"] = testUrl;
+  conn = createDbConnection(testUrl);
+
+  // Greenfield erzwingen: createTestDb legt kumiko_events bereits an —
+  // wegdroppen, damit runSchemaApply den Infra-Bootstrap echt durchläuft.
+  const raw = asRawClient(conn.db);
+  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_events" CASCADE`);
+  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_event_consumers" CASCADE`);
+  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_projections" CASCADE`);
+  await raw.unsafe(`DROP TABLE IF EXISTS "_kumiko_migrations" CASCADE`);
+
+  appCwd = mkdtempSync(join(tmpdir(), "kumiko-schema-apply-"));
+  migDir = join(appCwd, "kumiko", "migrations");
+  mkdirSync(migDir, { recursive: true });
+  writeFileSync(
+    join(migDir, "0001_init.sql"),
+    `CREATE TABLE "read_thing" ("id" text PRIMARY KEY);`,
+  );
+});
+
+afterAll(async () => {
+  await conn?.close();
+  await testDb?.cleanup();
+  if (appCwd) rmSync(appCwd, { recursive: true, force: true });
+  if (savedDbUrl === undefined) delete process.env["DATABASE_URL"];
+  else process.env["DATABASE_URL"] = savedDbUrl;
+});
+
+describe("runSchemaApply", () => {
+  test("Greenfield: leere DB → Infra-Tabellen + App-Migration appliziert → 0", async () => {
+    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
+
+    expect(await tableExists(conn.db, "public.kumiko_events")).toBe(true);
+    expect(await tableExists(conn.db, "public.kumiko_event_consumers")).toBe(true);
+    expect(await tableExists(conn.db, "public.kumiko_projections")).toBe(true);
+    expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
+  });
+
+  test("Re-Run auf Bestands-DB ist idempotent → 0 (Infra no-op, Migrations skipped)", async () => {
+    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
+    expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
+  });
+
+  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0", async () => {
+    writeFileSync(
+      join(migDir, "0002_more.sql"),
+      `CREATE TABLE "read_more" ("id" text PRIMARY KEY);`,
+    );
+    writeFileSync(
+      join(migDir, "0002_more.rebuild.json"),
+      JSON.stringify({ version: 1, tables: ["read_more"] }),
+    );
+
+    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
+    expect(await tableExists(conn.db, "public.read_more")).toBe(true);
+  });
+});

package/src/create-kumiko-server.ts

@@ -173,6 +173,11 @@ export type CreateKumikoServerOptions = {
    *  Handler `roles: ["anonymous"]` deklariert. Tenant-Resolution per
    *  Header/Cookie/Default; siehe AnonymousAccessConfig. */
   readonly anonymousAccess?: TestStackOptions["anonymousAccess"];
+  /** File-Storage-Provider — durchgereicht an setupTestStack. Wenn gesetzt,
+   *  mountet der Stack die Upload-Routes (POST/GET/DELETE /api/files) +
+   *  `ctx.files` und legt die file_refs-Tabelle an. Für Demos:
+   *  `{ storageProvider: createInMemoryFileProvider() }`. */
+  readonly files?: TestStackOptions["files"];
   /** Feature-toggle resolver — durchgereicht an setupTestStack. Wenn
    *  gesetzt, konsultiert der dispatcher-feature-gate, hook-filter, MSP-
    *  filter den callback; absent = alle features always-on. Erforderlich
@@ -660,6 +665,7 @@ export async function createKumikoServer(
     ...(options.auth !== undefined && { authConfig: options.auth }),
     ...(options.extraContext !== undefined && { extraContext: options.extraContext }),
     ...(options.anonymousAccess !== undefined && { anonymousAccess: options.anonymousAccess }),
+    ...(options.files !== undefined && { files: options.files }),
     ...(options.effectiveFeatures !== undefined && {
       effectiveFeatures: options.effectiveFeatures,
     }),

package/src/run-dev-app.ts

@@ -163,6 +163,9 @@ export type RunDevAppOptions = {
    *  als Pseudo-User mit Rolle `anonymous` durch, wenn der Handler die
    *  Rolle in `access.roles` führt. */
   readonly anonymousAccess?: CreateKumikoServerOptions["anonymousAccess"];
+  /** File-Storage-Provider — aktiviert die Upload-Routes (/api/files) +
+   *  `ctx.files`. Demos: `{ storageProvider: createInMemoryFileProvider() }`. */
+  readonly files?: CreateKumikoServerOptions["files"];
   /** App-eigene HTTP-Routes (z.B. /feed.xml, /sitemap.xml) — wird ans
    *  Hono-app gehängt, läuft VOR dem static-asset-Pfad. Symmetrisch zur
    *  gleichnamigen Option in runProdApp. */
@@ -187,6 +190,13 @@ export async function runDevApp(options: RunDevAppOptions): Promise<KumikoServer
     ...(composeAuthOptions && { authOptions: composeAuthOptions }),
   });
 
+  // Ein explizit gewireter File-Provider (options.files) erfüllt das
+  // FILE_STORAGE_PROVIDER-Boot-Gate — der Provider IST konfiguriert, nur
+  // nicht über die env-Bridge. Setzen bevor validateBoot greift.
+  if (options.files !== undefined && process.env["FILE_STORAGE_PROVIDER"] === undefined) {
+    process.env["FILE_STORAGE_PROVIDER"] = "configured";
+  }
+
   // Boot-Validation als allererstes — vor fs-Watcher und Server. Dieselbe
   // Fehlerklasse (unqualifizierte nav-/handler-QNs, screen-access etc.),
   // die früher nur runProdApp fing und sonst erst den Prod-Pod im
@@ -298,6 +308,7 @@ export async function runDevApp(options: RunDevAppOptions): Promise<KumikoServer
     }),
     ...(extraContext !== undefined && { extraContext }),
     ...(options.anonymousAccess !== undefined && { anonymousAccess: options.anonymousAccess }),
+    ...(options.files !== undefined && { files: options.files }),
     ...(options.extraRoutes !== undefined && { extraRoutes: options.extraRoutes }),
     ...(finalEffectiveFeatures !== undefined && {
       effectiveFeatures: finalEffectiveFeatures,

package/src/schema-apply.ts

@@ -0,0 +1,127 @@
+// Standalone `kumiko schema apply` für Production-Bundles. Apps bündeln ein
+// dünnes bin/kumiko.ts das nur runStandaloneSchemaCli mit den App-Features
+// aufruft — die ganze Orchestrierung (Infra-Bootstrap, Migrations,
+// Projection-Rebuild) lebt hier statt als ~100-Zeilen-Boilerplate pro App.
+//
+// Der Pulumi-migrate-initContainer ruft `bun /app/kumiko.js schema apply`;
+// kumiko-build entdeckt das App-bin via findRepoRoot() und bündelt es.
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  createDbConnection,
+  type DbConnection,
+  readRebuildMarker,
+  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 {
+  createEventConsumerStateTable,
+  createProjectionStateTable,
+  rebuildProjection,
+} from "@cosmicdrift/kumiko-framework/pipeline";
+import { type ComposeFeaturesOptions, composeFeatures } from "./compose-features";
+
+export type SchemaApplyOptions = ComposeFeaturesOptions & {
+  /** App-Features (z.B. APP_FEATURES aus run-config) — composed mit den
+   *  bundled-Features für den Projection-Rebuild-Registry. */
+  readonly features: readonly FeatureDefinition[];
+  /** Default INIT_CWD ?? process.cwd(); Migrations unter <appCwd>/kumiko/migrations. */
+  readonly appCwd?: string;
+};
+
+export async function runSchemaApply(opts: SchemaApplyOptions): Promise<number> {
+  const dbUrl = process.env["DATABASE_URL"];
+  if (!dbUrl) {
+    console.error("\n  DATABASE_URL not set.\n");
+    return 1;
+  }
+
+  const appCwd = opts.appCwd ?? process.env["INIT_CWD"] ?? process.cwd();
+  const migrationsDir = join(appCwd, "kumiko/migrations");
+  if (!existsSync(migrationsDir)) {
+    console.error(`\n  ${migrationsDir} fehlt — kumiko/migrations/ muss im Image liegen.\n`);
+    return 1;
+  }
+
+  const { db, close } = createDbConnection(dbUrl);
+  try {
+    // Infra-Tabellen (event-store + pipeline-state) zuerst, alle
+    // tableExists-gated idempotent: auf einer Bestands-DB no-op, auf einer
+    // leeren Greenfield-DB legen sie kumiko_events/_consumers/_projections an
+    // bevor die App-Migrations dagegen laufen. Ohne das bricht eine leere DB
+    // (z.B. cashcolt auf frischem CNPG) an `relation "kumiko_events" does not exist`.
+    console.log("\n  Lege Framework-Infra-Tabellen an (idempotent)…");
+    await createEventsTable(db);
+    await createEventConsumerStateTable(db);
+    await createProjectionStateTable(db);
+
+    console.log(`  Wende kumiko-Migrations an (${migrationsDir})…`);
+    const result = await runMigrationsFromDir(db, migrationsDir);
+    if (result.applied.length === 0) {
+      console.log(`\n  ✓ All ${result.skipped.length} migrations already applied.\n`);
+    } else {
+      console.log(`\n  ✓ Applied ${result.applied.length}:`);
+      for (const id of result.applied) console.log(`    + ${id}`);
+      if (result.skipped.length > 0) console.log(`  (${result.skipped.length} already applied)`);
+      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);
+    }
+    if (changedTables.size > 0) {
+      await rebuildAffectedProjections(db, [...changedTables], opts);
+    }
+
+    return 0;
+  } catch (e) {
+    console.error(`\n  ✗ ${e instanceof Error ? e.message : String(e)}\n`);
+    return 1;
+  } finally {
+    await close();
+  }
+}
+
+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);
+  }
+  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];
+
+  if (cmd === "schema" && sub === "apply") {
+    process.exit(await runSchemaApply(opts));
+  }
+
+  console.error(
+    `\n  Unbekannt: kumiko ${cmd ?? ""} ${sub ?? ""}\n  Nur 'kumiko schema apply' im Standalone-Bundle.\n`,
+  );
+  process.exit(1);
+}