@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

package/src/engine/__tests__/registrar-object-form.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import { defineFeature } from "../index";
+
+// Object-Form is the shape the feature-ast renderer emits for Designer/
+// AI-generated code (`r.entity({ name: "item", ... })` instead of
+// `r.entity("item", { ... })`) — see kumiko-framework#1113. The compile
+// checks in feature-ast/__tests__/render-roundtrip.test.ts prove the TYPES
+// line up; they never execute the runtime dispatch that unpacks Object-Form
+// back into the same state mutations as the positional form. These tests
+// cover that: one per distinct dispatch shape, asserting object-form and
+// positional-form produce identical FeatureDefinition state.
+
+describe("registrar Object-Form — runtime parity with positional form", () => {
+  test("requires: array-unwrap ({ features }) matches variadic-string form", () => {
+    const positional = defineFeature("a", (r) => {
+      r.requires("auth", "tenant");
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.requires({ features: ["auth", "tenant"] });
+    });
+    expect(objectForm.requires).toEqual(positional.requires);
+  });
+
+  test("optionalRequires: array-unwrap matches variadic-string form", () => {
+    const positional = defineFeature("a", (r) => {
+      r.optionalRequires("promotions");
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.optionalRequires({ features: ["promotions"] });
+    });
+    expect(objectForm.optionalRequires).toEqual(positional.optionalRequires);
+  });
+
+  test("readsConfig: array-unwrap ({ keys }) matches variadic-string form", () => {
+    const positional = defineFeature("a", (r) => {
+      r.readsConfig("auth.smtpHost");
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.readsConfig({ keys: ["auth.smtpHost"] });
+    });
+    expect(objectForm.configReads).toEqual(positional.configReads);
+  });
+
+  test("entity: split-name ({ name, ...fields }) matches (name, definition) form", () => {
+    const definition = { fields: { title: { type: "text" as const, required: true } } };
+    const positional = defineFeature("a", (r) => {
+      r.entity("item", definition);
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.entity({ name: "item", ...definition });
+    });
+    expect(objectForm.entities).toEqual(positional.entities);
+  });
+
+  test("metric: split-name matches (shortName, options) form", () => {
+    const positional = defineFeature("a", (r) => {
+      r.metric("created", { type: "counter" });
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.metric({ name: "created", type: "counter" });
+    });
+    expect(objectForm.metrics).toEqual(positional.metrics);
+  });
+
+  test("secret: split-name matches (shortName, options) form (same feature name for qualifiedName parity)", () => {
+    const positional = defineFeature("stripe", (r) => {
+      r.secret("apiKey", { label: { en: "Stripe API Key" }, scope: "tenant" });
+    });
+    const objectForm = defineFeature("stripe", (r) => {
+      r.secret({ name: "apiKey", label: { en: "Stripe API Key" }, scope: "tenant" });
+    });
+    expect(objectForm.secretKeys).toEqual(positional.secretKeys);
+  });
+
+  test("relation: two-field ({ entity, name, ...def }) matches (entity, name, definition) form", () => {
+    const definition = { type: "belongsTo" as const, target: "user", foreignKey: "supplierId" };
+    const positional = defineFeature("a", (r) => {
+      r.entity("item", { fields: {} });
+      r.relation("item", "supplier", definition);
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.entity("item", { fields: {} });
+      r.relation({ entity: "item", name: "supplier", ...definition });
+    });
+    expect(objectForm.relations).toEqual(positional.relations);
+  });
+
+  test("referenceData: two-field ({ entity, data, ...opts }) matches (entity, data, options) form", () => {
+    const data = [{ id: "a", label: "A" }];
+    const positional = defineFeature("a", (r) => {
+      r.referenceData("category", data, { upsertKey: "id" });
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.referenceData({ entity: "category", data, upsertKey: "id" });
+    });
+    expect(objectForm.referenceData).toEqual(positional.referenceData);
+  });
+
+  test("useExtension: two-field ({ name, entity, ...opts }) matches (extensionName, entity, options) form", () => {
+    const positional = defineFeature("a", (r) => {
+      r.useExtension("audit-log", "item", { verbose: true });
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.useExtension({ name: "audit-log", entity: "item", verbose: true });
+    });
+    expect(objectForm.extensionUsages).toEqual(positional.extensionUsages);
+  });
+
+  test("claimKey: generic split-name matches (shortName, options) form", () => {
+    const positional = defineFeature("drivers", (r) => {
+      r.claimKey("teamId", { type: "string" });
+    });
+    const objectForm = defineFeature("drivers", (r) => {
+      r.claimKey({ name: "teamId", type: "string" });
+    });
+    expect(objectForm.claimKeys).toEqual(positional.claimKeys);
+  });
+
+  test("job: full-definition object matches (name, options, handler) form", () => {
+    const handler = async () => {};
+    const positional = defineFeature("a", (r) => {
+      r.job("reconcile", { trigger: { manual: true } }, handler);
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.job({ name: "reconcile", trigger: { manual: true }, handler });
+    });
+    expect(objectForm.jobs).toEqual(positional.jobs);
+  });
+
+  test("notification: split-name matches (name, definition) form", () => {
+    const recipient = () => null;
+    const data = () => ({});
+    const positional = defineFeature("a", (r) => {
+      r.notification("itemLowStock", { trigger: { on: "item:lowStock" }, recipient, data });
+    });
+    const objectForm = defineFeature("b", (r) => {
+      r.notification({ name: "itemLowStock", trigger: { on: "item:lowStock" }, recipient, data });
+    });
+    expect(objectForm.notifications).toEqual(positional.notifications);
+  });
+});

package/src/engine/__tests__/registry.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
+import { z } from "zod";
 import { createTenantConfig } from "../config-helpers";
 import { defineFeature } from "../define-feature";
+import { createEntity, createTextField } from "../factories";
 import { createRegistry } from "../registry";
 import type { FeatureDefinition } from "../types/feature";
 
@@ -59,6 +61,122 @@ describe("createRegistry slot robustness", () => {
   });
 });
 
+describe("getAllQueryHandlers", () => {
+  test("returns every registered query handler, qualified, across multiple features", () => {
+    const taskEntity = createEntity({
+      table: "registry_test_tasks",
+      fields: { title: createTextField({ required: true }) },
+    });
+    const noteEntity = createEntity({
+      table: "registry_test_notes",
+      fields: { body: createTextField({ required: true }) },
+    });
+    const taskFeature = defineFeature("registry-test-task", (r) => {
+      r.crud("task", taskEntity, {
+        write: { access: { roles: ["Admin"] } },
+        read: { access: { openToAll: true } },
+      });
+    });
+    const noteFeature = defineFeature("registry-test-note", (r) => {
+      r.crud("note", noteEntity, {
+        write: { access: { roles: ["Admin"] } },
+        read: { access: { openToAll: true } },
+      });
+    });
+
+    const registry = createRegistry([taskFeature, noteFeature]);
+    const handlers = registry.getAllQueryHandlers();
+
+    expect(handlers.get("registry-test-task:query:task:list")).toBeDefined();
+    expect(handlers.get("registry-test-note:query:note:list")).toBeDefined();
+    // Same Map instance getQueryHandler reads from, not a copy that can drift.
+    expect(handlers.get("registry-test-task:query:task:list")).toBe(
+      registry.getQueryHandler("registry-test-task:query:task:list"),
+    );
+  });
+
+  test("empty registry returns an empty map, not undefined", () => {
+    const registry = createRegistry([]);
+    expect(registry.getAllQueryHandlers().size).toBe(0);
+  });
+});
+
+describe("getAllStreamHandlers", () => {
+  test("returns every registered stream handler, qualified, across multiple features", () => {
+    const aiFeature = defineFeature("registry-test-ai", (r) => {
+      r.streamHandler("chat:complete", z.object({ prompt: z.string() }), async function* () {}, {
+        access: { openToAll: true },
+      });
+    });
+    const otherFeature = defineFeature("registry-test-other", (r) => {
+      r.streamHandler("chat:complete", z.object({ prompt: z.string() }), async function* () {}, {
+        access: { openToAll: true },
+      });
+    });
+
+    const registry = createRegistry([aiFeature, otherFeature]);
+    const handlers = registry.getAllStreamHandlers();
+
+    expect(handlers.get("registry-test-ai:stream:chat:complete")).toBeDefined();
+    expect(handlers.get("registry-test-other:stream:chat:complete")).toBeDefined();
+    // Same Map instance getStreamHandler reads from, not a copy that can drift.
+    expect(handlers.get("registry-test-ai:stream:chat:complete")).toBe(
+      registry.getStreamHandler("registry-test-ai:stream:chat:complete"),
+    );
+  });
+
+  test("empty registry returns an empty map, not undefined", () => {
+    const registry = createRegistry([]);
+    expect(registry.getAllStreamHandlers().size).toBe(0);
+  });
+
+  test("duplicate stream-handler short-name across features qualifies independently, no collision", () => {
+    const aiFeature = defineFeature("registry-test-dup-a", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    const otherFeature = defineFeature("registry-test-dup-b", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    expect(() => createRegistry([aiFeature, otherFeature])).not.toThrow();
+  });
+
+  test("two distinct feature names that kebab-collide throw on the qualified stream-handler clash", () => {
+    // "registry-test-kebab-dup" and "registryTestKebabDup" are different raw
+    // feature.name values (so the earlier Duplicate-feature guard doesn't
+    // fire) but toKebab() collapses both to the same qualified name.
+    const featureA = defineFeature("registry-test-kebab-dup", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    const featureB = defineFeature("registryTestKebabDup", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    expect(() => createRegistry([featureA, featureB])).toThrow(/Duplicate stream handler/);
+  });
+
+  test("object-form streamHandler registration preserves schema/access/rateLimit", () => {
+    const schema = z.object({ prompt: z.string() });
+    const handlerFn = async function* () {};
+    const feature = defineFeature("registry-test-object-form", (r) => {
+      r.streamHandler({
+        name: "chat:complete",
+        schema,
+        handler: handlerFn,
+        access: { openToAll: true },
+        rateLimit: { per: "ip+handler", limit: 5, windowSeconds: 60 },
+      });
+    });
+
+    const registry = createRegistry([feature]);
+    const registered = registry.getStreamHandler("registry-test-object-form:stream:chat:complete");
+
+    expect(registered).toBeDefined();
+    expect(registered?.schema).toBe(schema);
+    expect(registered?.handler).toBe(handlerFn);
+    expect(registered?.access).toEqual({ openToAll: true });
+    expect(registered?.rateLimit).toEqual({ per: "ip+handler", limit: 5, windowSeconds: 60 });
+  });
+});
+
 describe("extensionSelector boot-validation", () => {
   function foundationFeature() {
     return defineFeature("probe-foundation", (r) => {
@@ -130,4 +248,30 @@ describe("extensionSelector boot-validation", () => {
       }),
     ).toThrow(/declared twice/);
   });
+
+  // 437/2: createRegistry now delegates this check to
+  // validateExtensionPreSaveWiring (shared with validateBoot's standalone
+  // callers) instead of a duplicate inline computation — pins that
+  // createRegistry itself still enforces it, not just validateBoot.
+  test("throws when extension preSave targets entity with no mapped write handlers", () => {
+    const ext = defineFeature("cap-ext", (r) => {
+      r.extendsRegistrar("credit-cap", {
+        hooks: { preSave: async (changes) => changes },
+      });
+    });
+    const consumer = defineFeature("money-horse", (r) => {
+      r.requires("cap-ext");
+      r.entity("credit", createEntity({ table: "Credits", fields: { name: createTextField() } }));
+      r.writeHandler(
+        "doSomething",
+        z.object({}),
+        async () => ({ isSuccess: true as const, data: {} }),
+        { access: { openToAll: true } },
+      );
+      r.useExtension("credit-cap", "credit");
+    });
+    expect(() => createRegistry([ext, consumer])).toThrow(
+      /no write handler is entity-mapped to "credit"/i,
+    );
+  });
 });

package/src/engine/__tests__/schema-builder.test.ts

@@ -113,6 +113,24 @@ describe("buildInsertSchema", () => {
       valid: { age: 25 },
       invalid: { age: "old" },
     },
+    {
+      name: "number field rejects below min",
+      fields: { age: createNumberField({ min: 0 }) },
+      valid: { age: 0 },
+      invalid: { age: -1 },
+    },
+    {
+      name: "number field rejects above max",
+      fields: { age: createNumberField({ max: 100 }) },
+      valid: { age: 100 },
+      invalid: { age: 101 },
+    },
+    {
+      name: "number field min+max bounds",
+      fields: { age: createNumberField({ min: 1, max: 10 }) },
+      valid: { age: 5 },
+      invalid: { age: 11 },
+    },
     {
       name: "date field",
       fields: { born: createDateField() },

package/src/engine/__tests__/screen.test.ts

@@ -1,10 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { validateBoot } from "../boot-validator";
+import { withBootValidatorFixture } from "../../testing/boot-validator-fixture";
+import { validateBoot as validateBootRaw } from "../boot-validator";
 import { defineFeature } from "../define-feature";
 import { createDerivedField, createEntity, createTextField } from "../factories";
 import { createRegistry } from "../registry";
 import type { ScreenDefinition } from "../types/screen";
 
+function validateBoot(features: Parameters<typeof validateBootRaw>[0]): void {
+  validateBootRaw(withBootValidatorFixture(features));
+}
+
 function productEntity() {
   return createEntity({
     table: "products",
@@ -45,6 +50,121 @@ describe("r.screen() — registration", () => {
     expect(feature.screens["product-list"]?.type).toBe("entityList");
   });
 
+  test("stores a projectionList screen bound to an explicit (cross-feature) query", () => {
+    const feature = defineFeature("app", (r) => {
+      r.screen({
+        id: "rent-list",
+        type: "projectionList",
+        query: "ledger:query:schedule:list",
+        columns: [
+          { field: "description", label: "app:col.desc" },
+          {
+            field: "amount",
+            label: "app:col.amount",
+            renderer: { react: { __component: "EuroCell" } },
+          },
+        ],
+      });
+    });
+    const screen = feature.screens["rent-list"];
+    expect(screen?.type).toBe("projectionList");
+    if (screen?.type !== "projectionList") throw new Error("type-narrow failed");
+    expect(screen.query).toBe("ledger:query:schedule:list");
+  });
+
+  test("validateBoot rejects a projectionList with empty columns", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({ id: "x", type: "projectionList", query: "app:query:foo:list", columns: [] });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/empty columns list/i);
+  });
+
+  test("validateBoot rejects a projectionList with an empty query", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({ id: "x", type: "projectionList", query: "", columns: ["name"] });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/empty or non-string query/i);
+  });
+
+  test("stores a projectionDetail screen bound to an explicit query", () => {
+    const feature = defineFeature("app", (r) => {
+      r.screen({
+        id: "rent-detail",
+        type: "projectionDetail",
+        query: "ledger:query:schedule:detail",
+        layout: { sections: [{ title: "app:section.basics", fields: ["description"] }] },
+      });
+    });
+    const screen = feature.screens["rent-detail"];
+    expect(screen?.type).toBe("projectionDetail");
+    if (screen?.type !== "projectionDetail") throw new Error("type-narrow failed");
+    expect(screen.query).toBe("ledger:query:schedule:detail");
+  });
+
+  test("validateBoot rejects a projectionDetail with an empty query", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({
+          id: "x",
+          type: "projectionDetail",
+          query: "",
+          layout: { sections: [{ title: "s", fields: ["name"] }] },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/empty or non-string query/i);
+  });
+
+  test("validateBoot rejects a projectionDetail with empty sections", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({
+          id: "x",
+          type: "projectionDetail",
+          query: "app:query:foo:detail",
+          layout: { sections: [] },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/empty sections list/i);
+  });
+
+  test("validateBoot rejects a projectionDetail section with zero fields", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({
+          id: "x",
+          type: "projectionDetail",
+          query: "app:query:foo:detail",
+          layout: { sections: [{ title: "s", fields: [] }] },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/zero fields/i);
+  });
+
+  test("validateBoot rejects a projectionDetail with an extension section (no entity to persist against)", () => {
+    const features = [
+      defineFeature("app", (r) => {
+        r.screen({
+          id: "x",
+          type: "projectionDetail",
+          query: "app:query:foo:detail",
+          layout: {
+            sections: [
+              { kind: "extension", title: "s", component: { react: { __component: "c" } } },
+            ],
+          },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/extension section/i);
+  });
+
   test("stores an entityEdit screen with sections + conditional fields", () => {
     const feature = defineFeature("shop", (r) => {
       r.entity("product", productEntity());
@@ -219,6 +339,32 @@ describe("createRegistry — screen indexing", () => {
     ]);
   });
 
+  test("getScreensByEntity aggregates screens on the same entity from two different features", () => {
+    const shop = defineFeature("shop", (r) => {
+      r.entity("product", productEntity());
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+      });
+    });
+    const reporting = defineFeature("reporting", (r) => {
+      r.screen({
+        id: "product-stats",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+      });
+    });
+    const registry = createRegistry([shop, reporting]);
+    const byProduct = registry.getScreensByEntity("product");
+    expect(byProduct.map((s) => s.id).sort()).toEqual([
+      "reporting:screen:product-stats",
+      "shop:screen:product-list",
+    ]);
+  });
+
   test("getScreen / getScreensByEntity return stored screens with qualified id", () => {
     const feature = defineFeature("shop", (r) => {
       r.entity("product", productEntity());

package/src/engine/__tests__/soft-delete-cleanup.test.ts

@@ -31,6 +31,9 @@ describe("registry soft-delete auto-wiring", () => {
     const key = registry.getConfigKey(SOFT_DELETE_GRACE_DAYS_KEY);
     expect(key?.type).toBe("number");
     expect(key?.default).toBe(DEFAULT_GRACE_DAYS);
+    // 565/2: min must be 1, not 0 — graceDays: 0 means "hard-delete every
+    // currently soft-deleted row on the next cron run", not "no cleanup".
+    expect(key?.bounds?.min).toBe(1);
   });
 
   test("also injects the system-scope cleanup job (not perTenant)", () => {