@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

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

@@ -0,0 +1,237 @@
+import { describe, expect, test } from "bun:test";
+import { requiredKeysFromScreen } from "../../i18n/required-surface-keys";
+import { validateBoot } from "../boot-validator";
+import { defineFeature } from "../define-feature";
+import type { DashboardScreenDefinition } from "../types/screen";
+
+const STAT_PANEL = {
+  kind: "stat",
+  id: "open-incidents",
+  label: "demo:dashboard:panel:open-incidents",
+  query: "demo:query:incident:open-count",
+  valueField: "count",
+} as const;
+
+function dashboardFeature(
+  panels: DashboardScreenDefinition["panels"],
+  filter?: DashboardScreenDefinition["filter"],
+) {
+  return defineFeature("demo", (r) => {
+    r.screen({
+      id: "overview",
+      type: "dashboard",
+      panels,
+      ...(filter !== undefined && { filter }),
+    });
+    r.translations({
+      keys: {
+        "screen:overview.title": { de: "Übersicht", en: "Overview" },
+        "demo:dashboard:panel:open-incidents": { de: "Offene Vorfälle", en: "Open incidents" },
+        "demo:dashboard:panel:latest": { de: "Neueste", en: "Latest" },
+        "demo:dashboard:col:name": { de: "Name", en: "Name" },
+        "demo:dashboard:group:net-worth": { de: "Net Worth", en: "Net Worth" },
+        "demo:dashboard:filter:region": { de: "Region", en: "Region" },
+      },
+    });
+  });
+}
+
+describe("validateBoot — dashboard screens", () => {
+  test("accepts a valid stat + list panel set", () => {
+    const feature = dashboardFeature([
+      STAT_PANEL,
+      {
+        kind: "list",
+        id: "latest",
+        label: "demo:dashboard:panel:latest",
+        query: "demo:query:incident:latest",
+        columns: [{ field: "name", label: "demo:dashboard:col:name" }],
+      },
+    ]);
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("rejects an empty panels list", () => {
+    const feature = dashboardFeature([]);
+    expect(() => validateBoot([feature])).toThrow(/empty panels list/);
+  });
+
+  test("rejects duplicate panel ids", () => {
+    const feature = dashboardFeature([STAT_PANEL, STAT_PANEL]);
+    expect(() => validateBoot([feature])).toThrow(/duplicate panel id/);
+  });
+
+  test("rejects a stat panel with empty valueField", () => {
+    const feature = dashboardFeature([{ ...STAT_PANEL, valueField: "" }]);
+    expect(() => validateBoot([feature])).toThrow(/empty valueField/);
+  });
+
+  test("rejects a list panel without columns", () => {
+    const feature = dashboardFeature([
+      {
+        kind: "list",
+        id: "latest",
+        label: "demo:dashboard:panel:latest",
+        query: "demo:query:incident:latest",
+        columns: [],
+      },
+    ]);
+    expect(() => validateBoot([feature])).toThrow(/empty columns list/);
+  });
+
+  test("requiredKeysFromScreen sammelt Panel- und Column-Labels", () => {
+    const screen: DashboardScreenDefinition = {
+      id: "overview",
+      type: "dashboard",
+      panels: [
+        STAT_PANEL,
+        {
+          kind: "list",
+          id: "latest",
+          label: "demo:dashboard:panel:latest",
+          query: "demo:query:incident:latest",
+          columns: [{ field: "name", label: "demo:dashboard:col:name" }],
+        },
+      ],
+    };
+    const keys = requiredKeysFromScreen("demo", screen);
+    expect(keys).toContain("screen:overview.title");
+    expect(keys).toContain("demo:dashboard:panel:open-incidents");
+    expect(keys).toContain("demo:dashboard:panel:latest");
+    expect(keys).toContain("demo:dashboard:col:name");
+  });
+
+  test("accepts a stat-group, feed, progress-list and custom panel", () => {
+    const feature = dashboardFeature(
+      [
+        {
+          kind: "stat-group",
+          id: "net-worth",
+          label: "demo:dashboard:group:net-worth",
+          stats: [STAT_PANEL],
+        },
+        {
+          kind: "feed",
+          id: "upcoming",
+          label: "demo:dashboard:panel:latest",
+          query: "demo:query:incident:latest",
+        },
+        {
+          kind: "progress-list",
+          id: "progress",
+          label: "demo:dashboard:panel:latest",
+          query: "demo:query:incident:latest",
+        },
+        {
+          kind: "custom",
+          id: "custom-panel",
+          component: { react: { __component: "demo-custom" } },
+        },
+      ],
+      {
+        id: "region",
+        label: "demo:dashboard:filter:region",
+        kind: "select",
+        options: [{ value: "eu", label: "demo:dashboard:filter:region" }],
+      },
+    );
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("rejects a stat-group with an empty stats list", () => {
+    const feature = dashboardFeature([
+      { kind: "stat-group", id: "net-worth", label: "demo:dashboard:group:net-worth", stats: [] },
+    ]);
+    expect(() => validateBoot([feature])).toThrow(/empty stats list/);
+  });
+
+  test("rejects a duplicate id nested inside a stat-group", () => {
+    const feature = dashboardFeature([
+      STAT_PANEL,
+      {
+        kind: "stat-group",
+        id: "net-worth",
+        label: "demo:dashboard:group:net-worth",
+        stats: [STAT_PANEL],
+      },
+    ]);
+    expect(() => validateBoot([feature])).toThrow(/duplicate panel id/);
+  });
+
+  test("rejects a custom panel without a react/native component", () => {
+    const feature = dashboardFeature([{ kind: "custom", id: "custom-panel", component: {} }]);
+    expect(() => validateBoot([feature])).toThrow(/has no component/);
+  });
+
+  test("rejects a filter that sets neither options nor optionsQuery", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+    });
+    expect(() => validateBoot([feature])).toThrow(/exactly one of/);
+  });
+
+  test("rejects a filter that sets both options and optionsQuery", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+      options: [{ value: "eu", label: "demo:dashboard:filter:region" }],
+      optionsQuery: "demo:query:folder:list",
+    });
+    expect(() => validateBoot([feature])).toThrow(/exactly one of/);
+  });
+
+  test("rejects a filter with an empty options list", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+      options: [],
+    });
+    expect(() => validateBoot([feature])).toThrow(/filter.options is empty/);
+  });
+
+  test("rejects a filter with an empty optionsQuery", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+      optionsQuery: "",
+    });
+    expect(() => validateBoot([feature])).toThrow(/filter.optionsQuery is empty/);
+  });
+
+  test("requiredKeysFromScreen sammelt stat-group-Kinder- und Filter-Labels, aber keine custom-Panel-Keys", () => {
+    const screen: DashboardScreenDefinition = {
+      id: "overview",
+      type: "dashboard",
+      filter: {
+        id: "region",
+        label: "demo:dashboard:filter:region",
+        kind: "select",
+        options: [{ value: "eu", label: "demo:dashboard:col:name" }],
+      },
+      panels: [
+        {
+          kind: "stat-group",
+          id: "net-worth",
+          label: "demo:dashboard:group:net-worth",
+          stats: [STAT_PANEL],
+        },
+        {
+          kind: "custom",
+          id: "custom-panel",
+          component: { react: { __component: "demo-custom" } },
+        },
+      ],
+    };
+    const keys = requiredKeysFromScreen("demo", screen);
+    expect(keys).toContain("demo:dashboard:group:net-worth");
+    expect(keys).toContain("demo:dashboard:panel:open-incidents");
+    expect(keys).toContain("demo:dashboard:filter:region");
+    expect(keys).toContain("demo:dashboard:col:name");
+    expect(keys).not.toContain("custom-panel");
+  });
+});

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

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import { validateBoot } from "../boot-validator";
+import { defineFeature } from "../define-feature";
+import { createEntity, createTextField } from "../factories";
+
+describe("validateBoot — entityList screens", () => {
+  test("requires defaultSort when searchable", () => {
+    const feature = defineFeature("demo", (r) => {
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ sortable: true }) },
+        }),
+      );
+      r.screen({
+        id: "item-list",
+        type: "entityList",
+        entity: "item",
+        columns: ["name"],
+      });
+      r.translations({
+        keys: {
+          "screen:item-list.title": { de: "Liste", en: "List" },
+          "demo:entity:item:field:name": { de: "Name", en: "Name" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/defaultSort required/);
+  });
+
+  test("rejects searchable:false on operator lists not on whitelist", () => {
+    const feature = defineFeature("demo", (r) => {
+      r.entity("item", createEntity({ table: "Items", fields: { name: createTextField() } }));
+      r.screen({
+        id: "item-list",
+        type: "entityList",
+        entity: "item",
+        columns: ["name"],
+        searchable: false,
+      });
+      r.translations({
+        keys: {
+          "screen:item-list.title": { de: "Liste", en: "List" },
+          "demo:entity:item:field:name": { de: "Name", en: "Name" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/searchable defaults to true/);
+  });
+
+  test("allows searchable:false on download-attempt-list whitelist", () => {
+    const feature = defineFeature("demo", (r) => {
+      r.entity("attempt", createEntity({ table: "Attempts", fields: { id: createTextField() } }));
+      r.screen({
+        id: "download-attempt-list",
+        type: "entityList",
+        entity: "attempt",
+        columns: ["id"],
+        searchable: false,
+      });
+      r.translations({
+        keys: {
+          "screen:download-attempt-list.title": { de: "Liste", en: "List" },
+          "demo:entity:attempt:field:id": { de: "ID", en: "ID" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("requires navigate rowAction when entityEdit exists", () => {
+    const feature = defineFeature("demo", (r) => {
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ sortable: true }) },
+        }),
+      );
+      r.screen({
+        id: "item-list",
+        type: "entityList",
+        entity: "item",
+        columns: ["name"],
+        defaultSort: { field: "name", dir: "asc" },
+      });
+      r.screen({
+        id: "item-edit",
+        type: "entityEdit",
+        entity: "item",
+        layout: { sections: [{ fields: ["name"] }] },
+      });
+      r.translations({
+        keys: {
+          "screen:item-list.title": { de: "Liste", en: "List" },
+          "screen:item-edit.title": { de: "Edit", en: "Edit" },
+          "demo:entity:item:field:name": { de: "Name", en: "Name" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/navigate rowAction/);
+  });
+});

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

@@ -1,14 +1,15 @@
 // V1 — GDPR storage-persistence boot guard. Catches the prod failure class:
 // user-data-rights mounted but exports land in an ephemeral / missing store,
 // and s3-env selected as the GDPR store without its env vars set.
-// V2 — export-without-erase guard. Catches features that register an export
-// hook but no delete hook (Art.17 violation).
+//
+// V2-V4 (export-without-erase / PII-entity-without-hook / tenantOwned-entity-
+// without-hook) moved off this framework-internal validator onto
+// `r.bootCheck()` calls declared by user-data-rights / user-data-rights-
+// defaults (#1314) — see boot-checks.test.ts in the bundled-features package
+// for their coverage.
 
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import {
-  validateGdprHookCompleteness,
-  validateGdprStoragePersistence,
-} from "../boot-validator/gdpr-storage";
+import { validateGdprStoragePersistence } from "../boot-validator/gdpr-storage";
 import { defineFeature } from "../define-feature";
 
 const udr = () => defineFeature("user-data-rights", () => {});
@@ -77,66 +78,3 @@ describe("validateGdprStoragePersistence (V1)", () => {
     expect(warnSpy).not.toHaveBeenCalled();
   });
 });
-
-describe("validateGdprHookCompleteness (V2)", () => {
-  let warnSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    warnSpy.mockRestore();
-  });
-
-  const exportFn = async () => null;
-  const deleteFn = async () => {};
-
-  test("export + delete hooks → no warn", () => {
-    const f = defineFeature("my-feature", (r) => {
-      r.useExtension("userData", "myEntity", { export: exportFn, delete: deleteFn });
-    });
-    validateGdprHookCompleteness([f]);
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  test("export hook without delete hook → Art.17 warn", () => {
-    const f = defineFeature("my-feature", (r) => {
-      r.useExtension("userData", "myEntity", { export: exportFn });
-    });
-    validateGdprHookCompleteness([f]);
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-    const msg = String(warnSpy.mock.calls[0]?.[0]);
-    expect(msg).toContain("my-feature");
-    expect(msg).toContain("myEntity");
-    expect(msg).toContain("Art.17");
-  });
-
-  test("delete hook only (no export) → no warn", () => {
-    const f = defineFeature("my-feature", (r) => {
-      r.useExtension("userData", "myEntity", { delete: deleteFn });
-    });
-    validateGdprHookCompleteness([f]);
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  test("no EXT_USER_DATA hooks at all → no warn", () => {
-    const f = defineFeature("my-feature", (r) => {
-      r.useExtension("fileProvider", "s3");
-    });
-    validateGdprHookCompleteness([f]);
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  test("multiple features, one missing delete → one warn per missing hook", () => {
-    const good = defineFeature("good", (r) => {
-      r.useExtension("userData", "entityA", { export: exportFn, delete: deleteFn });
-    });
-    const bad = defineFeature("bad", (r) => {
-      r.useExtension("userData", "entityB", { export: exportFn });
-    });
-    validateGdprHookCompleteness([good, bad]);
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-    expect(String(warnSpy.mock.calls[0]?.[0])).toContain("entityB");
-  });
-});

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

@@ -6,12 +6,19 @@ import { createEntity, createTextField } from "../factories";
 describe("validateBoot — i18n surface keys", () => {
   test("passes when screen-derived keys are in r.translations", () => {
     const feature = defineFeature("demo", (r) => {
-      r.entity("item", createEntity({ table: "Items", fields: { name: createTextField() } }));
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ sortable: true }) },
+        }),
+      );
       r.screen({
         id: "item-list",
         type: "entityList",
         entity: "item",
         columns: ["name"],
+        defaultSort: { field: "name", dir: "asc" },
       });
       r.translations({
         keys: {
@@ -25,12 +32,19 @@ describe("validateBoot — i18n surface keys", () => {
 
   test("throws when screen title key is missing", () => {
     const feature = defineFeature("demo", (r) => {
-      r.entity("item", createEntity({ table: "Items", fields: { name: createTextField() } }));
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ sortable: true }) },
+        }),
+      );
       r.screen({
         id: "item-list",
         type: "entityList",
         entity: "item",
         columns: ["name"],
+        defaultSort: { field: "name", dir: "asc" },
       });
       r.translations({
         keys: {
@@ -43,17 +57,24 @@ describe("validateBoot — i18n surface keys", () => {
     );
   });
 
-  test("skips features with no r.translations", () => {
+  test("throws when feature has screens but no r.translations", () => {
     const feature = defineFeature("legacy", (r) => {
-      r.entity("item", createEntity({ table: "Items", fields: { name: createTextField() } }));
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ sortable: true }) },
+        }),
+      );
       r.screen({
         id: "item-list",
         type: "entityList",
         entity: "item",
         columns: ["name"],
+        defaultSort: { field: "name", dir: "asc" },
       });
     });
-    expect(() => validateBoot([feature])).not.toThrow();
+    expect(() => validateBoot([feature])).toThrow(/required translation key missing/);
   });
 
   test("throws when de/en locale is missing", () => {

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

@@ -7,25 +7,9 @@
 import { describe, expect, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
-import { createEntity, createTimestampField, createTzField, locatedTimestamp } from "../factories";
+import { createEntity, createTimestampField, createTzField } from "../factories";
 
 describe("validateBoot — locatedBy markers", () => {
-  test("locatedTimestamp(name) Helper-Pair passiert validiert (positive case)", () => {
-    const feature = defineFeature("test", (r) => {
-      r.entity(
-        "order",
-        createEntity({
-          fields: {
-            ...locatedTimestamp("pickup"),
-            ...locatedTimestamp("delivery"),
-          },
-        }),
-      );
-    });
-
-    expect(() => validateBoot([feature])).not.toThrow();
-  });
-
   test("manuelle Konstruktion mit korrektem Pair passiert (positive case)", () => {
     const feature = defineFeature("test", (r) => {
       r.entity(
@@ -75,7 +59,7 @@ describe("validateBoot — locatedBy markers", () => {
     expect(() => validateBoot([feature])).toThrow(/expected "tz"/);
   });
 
-  test("Fehlermeldung verweist auf locatedTimestamp-Helper als Fix", () => {
+  test("Fehlermeldung verweist auf createLocatedTimestampField als Fix", () => {
     const feature = defineFeature("test", (r) => {
       r.entity(
         "order",
@@ -87,7 +71,7 @@ describe("validateBoot — locatedBy markers", () => {
       );
     });
 
-    expect(() => validateBoot([feature])).toThrow(/locatedTimestamp\("pickup"\)/);
+    expect(() => validateBoot([feature])).toThrow(/createLocatedTimestampField/);
   });
 
   test("Timestamp ohne locatedBy ist OK (reiner UTC-Instant)", () => {