@cosmicdrift/kumiko-framework 0.31.0 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.31.0",
+  "version": "0.32.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__/table-builder-meta-lockstep.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { asEntityTableMeta } from "../../bun-db/query";
+import { createEntity } from "../../engine/factories";
+import type { ColumnMeta, IndexMeta } from "../entity-table-meta";
+import { buildEntityTableMeta } from "../entity-table-meta";
+import { buildEntityTable } from "../table-builder";
+
+// Lock-step-Guard: buildEntityTable (Runtime-/Test-Stack-Pfad, Meta am
+// KUMIKO_META_SYMBOL) und buildEntityTableMeta (Migrations-Pfad) müssen
+// für dieselbe EntityDefinition identische Spalten + Indexes produzieren.
+// Drift hier = Migration und Prod-Tabelle (bzw. collectTableMetas-Output)
+// gehen auseinander — gefunden als #255-Follow-up: select/number/bigInt
+// verloren ihre deklarierten defaults auf dem Builder-Pfad.
+
+const entityWithDefaults = createEntity({
+  table: "read_lockstep_probe",
+  fields: {
+    title: { type: "text", required: true, default: "untitled" },
+    active: { type: "boolean", default: true },
+    status: { type: "select", options: ["open", "done"], required: true, default: "open" },
+    tags: { type: "multiSelect", options: ["a", "b"] },
+    attempt: { type: "number", required: true, default: 1 },
+    bytes: { type: "bigInt", default: 0 },
+    price: { type: "money" },
+    meta: { type: "embedded", fields: {} },
+    startedAt: { type: "timestamp", required: true },
+  },
+});
+
+function byName<T extends { name: string }>(items: readonly T[]): readonly T[] {
+  return [...items].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+describe("buildEntityTable ↔ buildEntityTableMeta lock-step", () => {
+  const fromBuilder = asEntityTableMeta(buildEntityTable("lockstepProbe", entityWithDefaults));
+  const fromMeta = buildEntityTableMeta("lockstepProbe", entityWithDefaults);
+
+  test("builder table carries an EntityTableMeta", () => {
+    expect(fromBuilder).toBeDefined();
+  });
+
+  test("identical columns (incl. declared defaults)", () => {
+    expect(byName<ColumnMeta>(fromBuilder?.columns ?? [])).toEqual(
+      byName<ColumnMeta>(fromMeta.columns),
+    );
+  });
+
+  test("identical indexes", () => {
+    expect(byName<IndexMeta>(fromBuilder?.indexes ?? [])).toEqual(
+      byName<IndexMeta>(fromMeta.indexes),
+    );
+  });
+
+  test("declared defaults survive the builder path", () => {
+    const cols = new Map((fromBuilder?.columns ?? []).map((c) => [c.name, c]));
+    expect(cols.get("status")?.defaultSql).toBe("'open'");
+    expect(cols.get("attempt")?.defaultSql).toBe("1");
+    expect(cols.get("bytes")?.defaultSql).toBe("0");
+    expect(cols.get("title")?.defaultSql).toBe("'untitled'");
+    expect(cols.get("active")?.defaultSql).toBe("true");
+  });
+});

package/src/db/dialect.ts

@@ -272,8 +272,11 @@ export function instant(
 }
 
 // moneyAmount kept as a customType-style API but produces a bigint column.
+// bigintJsMode "bigint" — money cents must round-trip as JS bigint (lock-step
+// with entity-table-meta's money rendering; without it bun-db reads the
+// column as number and loses precision past 2^53).
 export const moneyAmount = (name: string): ColumnBuilder<number> =>
-  buildColumn(name, "bigint") as ColumnBuilder<number>;
+  buildColumn(name, "bigint", { bigintJsMode: "bigint" }) as ColumnBuilder<number>;
 
 // ---- Index + primaryKey helpers ----
 

package/src/db/table-builder.ts

@@ -80,7 +80,12 @@ function fieldToColumns(
               : boolean(snakeName),
       };
     case "select": {
-      const col = text(snakeName);
+      // default() durchreichen — entity-table-meta rendert deklarierte
+      // defaults, dieser Builder MUSS lock-step bleiben (sonst trägt das
+      // Meta am buildEntityTable-Objekt eine andere Spalte als die
+      // Migration, #255-Follow-up-Befund).
+      const base = text(snakeName);
+      const col = field.default !== undefined ? base.default(field.default) : base;
       return { [name]: field.required ? col.notNull() : col };
     }
     case "multiSelect":
@@ -95,7 +100,8 @@ function fieldToColumns(
       // multi-select.
       return { [name]: jsonb(snakeName).default([]).notNull() };
     case "number": {
-      const col = integer(snakeName);
+      const base = integer(snakeName);
+      const col = field.default !== undefined ? base.default(field.default) : base;
       return { [name]: field.required ? col.notNull() : col };
     }
     case "bigInt": {
@@ -104,7 +110,8 @@ function fieldToColumns(
       // JS-`bigint` — JSON-serialisierbar, Frontend-tauglich. Wer >2^53
       // braucht (Astronomie-Astronomie), nutzt einen Text-Field mit
       // eigenem Codec.
-      const col = bigint(snakeName, { mode: "number" });
+      const base = bigint(snakeName, { mode: "number" });
+      const col = field.default !== undefined ? base.default(field.default) : base;
       return { [name]: field.required ? col.notNull() : col };
     }
     case "reference":

package/src/engine/__tests__/boot-validator.test.ts

@@ -1287,6 +1287,7 @@ describe("boot-validator", () => {
         readonly fields: readonly string[];
       }>;
       readonly redirect?: string;
+      readonly cancelTarget?: string | false;
       readonly extraScreens?: readonly string[];
     };
 
@@ -1318,6 +1319,7 @@ describe("boot-validator", () => {
           fields: fields as never,
           layout: { sections: sections as never },
           ...(override.redirect !== undefined && { redirect: override.redirect }),
+          ...(override.cancelTarget !== undefined && { cancelTarget: override.cancelTarget }),
         });
         for (const extra of override.extraScreens ?? []) {
           r.screen({
@@ -1387,6 +1389,22 @@ describe("boot-validator", () => {
       );
     });
 
+    test("cancelTarget → existing screen-id → kein Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ cancelTarget: "after-form", extraScreens: ["after-form"] })]),
+      ).not.toThrow();
+    });
+
+    test("cancelTarget → unknown screen-id → Throw", () => {
+      expect(() => validateBoot([makeFeature({ cancelTarget: "ghost-screen" })])).toThrow(
+        /cancelTarget "ghost-screen" does not resolve to a registered screen/,
+      );
+    });
+
+    test("cancelTarget=false (Button abgeschaltet) → kein Throw", () => {
+      expect(() => validateBoot([makeFeature({ cancelTarget: false })])).not.toThrow();
+    });
+
     test("extension section ohne component → Throw (Parität zu entityEdit)", () => {
       // synthesizeActionFormScreen reicht die layout 1:1 an RenderEdit weiter —
       // eine Extension-Section ohne react/native-Marker rendert sonst stumm leer.

package/src/engine/boot-validator/screens-nav.ts

@@ -210,6 +210,19 @@ export function validateScreens(
           );
         }
       }
+      if (typeof screen.cancelTarget === "string") {
+        // Gleiche Regel wie redirect — `false` (kein Cancel-Button)
+        // braucht keine Validierung.
+        const candidateQn = qualifyEntityName(feature.name, "screen", screen.cancelTarget);
+        if (!allScreenQns.has(candidateQn)) {
+          throw new Error(
+            `[Feature ${feature.name}] Screen "${screenId}" (actionForm) cancelTarget "${screen.cancelTarget}" ` +
+              `does not resolve to a registered screen in this feature. Known screens: ${
+                [...Object.keys(feature.screens)].sort().join(", ") || "(none)"
+              }.`,
+          );
+        }
+      }
       continue;
     }
 

package/src/engine/types/screen.ts

@@ -177,6 +177,11 @@ export type RowActionNavigate = {
   /** Screen-id (kurz, unqualified) zu dem navigiert wird. Boot-
    *  Validator prüft Existenz im selben Feature. */
   readonly screen: string;
+  /** Optional: Entity-Id für entityEdit-Targets — landet als Pfad-
+   *  Segment (`/<workspace>/<screen>/<entityId>`). entityEdit liest die
+   *  Id AUSSCHLIESSLICH aus dem Pfad; ein `?id=`-Search-Param öffnet
+   *  den Create-Mode. ⚠️ Function-Form nur im Monolith-Bundle-Pattern. */
+  readonly entityId?: (row: Readonly<Record<string, unknown>>) => string;
   /** Optional: URL-Search-Params aus row-Context. Wird in actionForm-
    *  Targets als initial values gelesen ("Edit Customer X" → URL hat
    *  `?customerId=row-uuid`, actionForm initial values pre-fillen).
@@ -359,6 +364,13 @@ export type ActionFormScreenDefinition = {
    *  Wenn nicht gesetzt, bleibt der User auf dem Form-Screen. Boot-
    *  Validator prüft dass die ID einen registrierten Screen meint. */
   readonly redirect?: string;
+  /** Ziel des Abbrechen-Buttons. Default: `redirect` (historisches
+   *  Verhalten — Cancel und Submit-Redirect landen dann am selben Ort).
+   *  `false` = kein Abbrechen-Button; richtig für Single-Action-Screens
+   *  ohne verwerfbaren Zustand (z.B. "Test-Mail senden"), wo Abbrechen
+   *  nur ein zweiter Weg zum selben Ziel wäre. Boot-Validator prüft
+   *  String-Targets wie `redirect`. */
+  readonly cancelTarget?: string | false;
   readonly slots?: ScreenSlots;
   readonly access?: AccessRule;
 };