@cosmicdrift/kumiko-bundled-features 0.12.2 → 0.13.0

package/src/custom-fields/__tests__/custom-fields.integration.ts

@@ -0,0 +1,261 @@
+// T1 — full-stack integration tests for the custom-fields bundle.
+//
+// Drives define→set→query→clear→delete-cascade through the real dispatcher +
+// MSP-pipeline + DB. Verifies that the architecture actually works end-to-end:
+//   - r.defineEvent fires + MSP consumes + jsonb-projection lands
+//   - postQuery-entity-hook flattens customFields auf API-root
+//   - fieldDefinition-delete cascade-cleans orphan jsonb-keys
+//   - Multi-tenant isolation
+//
+// Pattern follows cap-counter.integration.ts: probe-feature mit own entity,
+// wired via wireCustomFieldsFor.
+
+import { buildDrizzleTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntity,
+  createEntityExecutor,
+  createTextField,
+  defineEntityListHandler,
+  defineFeature,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { sql } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { z } from "zod";
+import { fieldDefinitionEntity } from "../entity";
+import { createCustomFieldsFeature } from "../feature";
+import { customFieldsField, wireCustomFieldsFor } from "../wire-for-entity";
+
+// --- Probe-Feature: a tenant-owned "property" entity with customFields ---
+
+const propertyEntity = createEntity({
+  table: "read_t1_properties",
+  fields: {
+    name: createTextField({ required: true }),
+    customFields: customFieldsField(),
+  },
+});
+const propertyTable = buildDrizzleTable("property", propertyEntity);
+
+const propertyFeature = defineFeature("property-test", (r) => {
+  r.entity("property", propertyEntity);
+  r.requires("custom-fields");
+  wireCustomFieldsFor(r, "property", propertyTable);
+
+  // Standard CRUD: create + list via entity-handlers. Pure test-probe.
+  const { executor: propertyExecutor } = createEntityExecutor("property", propertyEntity);
+  r.writeHandler({
+    name: "property:create",
+    schema: z.object({ id: z.string(), name: z.string() }),
+    access: { roles: ["TenantAdmin"] },
+    handler: async (event, ctx) => {
+      const payload = event.payload as { id: string; name: string };
+      return propertyExecutor.create(
+        { id: payload.id, name: payload.name, customFields: {} },
+        event.user,
+        ctx.db,
+      );
+    },
+  });
+
+  r.queryHandler(
+    defineEntityListHandler("property", propertyEntity, { access: { roles: ["TenantAdmin"] } }),
+  );
+});
+
+// --- Stack ---
+
+const customFieldsFeature = createCustomFieldsFeature();
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [customFieldsFeature, propertyFeature],
+  });
+
+  await unsafeCreateEntityTable(stack.db, fieldDefinitionEntity);
+  await unsafeCreateEntityTable(stack.db, propertyEntity);
+  await createEventsTable(stack.db);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  // Clean slate per test — event-log + entity-rows.
+  await stack.db.execute(sql`DELETE FROM kumiko_events`);
+  await stack.db.execute(sql`DELETE FROM read_t1_properties`);
+  await stack.db.execute(sql`DELETE FROM read_custom_field_definitions`);
+});
+
+// --- Helpers ---
+
+// TestUsers.admin hat role="Admin"; unsere handlers verlangen "TenantAdmin"
+// (Memory: feedback_role_naming_drift — bundled-features-Convention vs.
+// platform-Convention). Wir bauen einen tenant-admin für die Tests.
+const admin = createTestUser({ roles: ["TenantAdmin"] });
+
+async function defineField(entityName: string, fieldKey: string, type = "text") {
+  return stack.http.writeOk(
+    "custom-fields:write:define-tenant-field",
+    {
+      entityName,
+      fieldKey,
+      serializedField: { type },
+      required: false,
+      searchable: false,
+      displayOrder: 0,
+    },
+    admin,
+  );
+}
+
+async function setCustomField(
+  entityName: string,
+  entityId: string,
+  fieldKey: string,
+  value: unknown,
+) {
+  return stack.http.writeOk(
+    "custom-fields:write:set-custom-field",
+    { entityName, entityId, fieldKey, value },
+    admin,
+  );
+}
+
+async function clearCustomField(entityName: string, entityId: string, fieldKey: string) {
+  return stack.http.writeOk(
+    "custom-fields:write:clear-custom-field",
+    { entityName, entityId, fieldKey },
+    admin,
+  );
+}
+
+async function createProperty(id: string, name: string) {
+  return stack.http.writeOk("property-test:write:property:create", { id, name }, admin);
+}
+
+async function listProperties() {
+  return (await stack.http.queryOk("property-test:query:property:list", {}, admin)) as {
+    rows: Array<Record<string, unknown>>;
+  };
+}
+
+// --- Tests ---
+
+describe("custom-fields integration — define + set + query roundtrip", () => {
+  test("set → MSP → postQuery: customField value lands flat in entity response", async () => {
+    await defineField("property", "internalNumber");
+    await createProperty("11111111-1111-4000-8000-000000000001", "Hofgarten 12");
+    await setCustomField(
+      "property",
+      "11111111-1111-4000-8000-000000000001",
+      "internalNumber",
+      "X-2042",
+    );
+
+    await stack.eventDispatcher?.runOnce();
+
+    const { rows } = await listProperties();
+    const p1 = rows.find((r) => r["id"] === "11111111-1111-4000-8000-000000000001");
+    expect(p1).toBeDefined();
+    expect(p1?.["internalNumber"]).toBe("X-2042");
+  });
+
+  test("clear: fieldKey gone from response after clear-custom-field", async () => {
+    await defineField("property", "vipFlag", "boolean");
+    await createProperty("22222222-2222-4000-8000-000000000002", "BookStore");
+    await setCustomField("property", "22222222-2222-4000-8000-000000000002", "vipFlag", true);
+    await stack.eventDispatcher?.runOnce();
+
+    let p2 = (await listProperties()).rows.find(
+      (r) => r["id"] === "22222222-2222-4000-8000-000000000002",
+    );
+    expect(p2?.["vipFlag"]).toBe(true);
+
+    await clearCustomField("property", "22222222-2222-4000-8000-000000000002", "vipFlag");
+    await stack.eventDispatcher?.runOnce();
+
+    p2 = (await listProperties()).rows.find(
+      (r) => r["id"] === "22222222-2222-4000-8000-000000000002",
+    );
+    expect(p2?.["vipFlag"]).toBeUndefined();
+  });
+
+  test("multiple fields on same entity: all merge flat", async () => {
+    await defineField("property", "vendor");
+    await defineField("property", "tier", "number");
+    await createProperty("33333333-3333-4000-8000-000000000003", "MultiField");
+    await setCustomField("property", "33333333-3333-4000-8000-000000000003", "vendor", "Hetzner");
+    await setCustomField("property", "33333333-3333-4000-8000-000000000003", "tier", 2);
+
+    await stack.eventDispatcher?.runOnce();
+
+    const p3 = (await listProperties()).rows.find(
+      (r) => r["id"] === "33333333-3333-4000-8000-000000000003",
+    );
+    expect(p3?.["vendor"]).toBe("Hetzner");
+    expect(p3?.["tier"]).toBe(2);
+  });
+
+  test("entity without customField values: still queryable (no postQuery breakage)", async () => {
+    await createProperty("44444444-4444-4000-8000-000000000004", "NoCustomFields");
+
+    const p4 = (await listProperties()).rows.find(
+      (r) => r["id"] === "44444444-4444-4000-8000-000000000004",
+    );
+    expect(p4?.["name"]).toBe("NoCustomFields");
+  });
+});
+
+describe("custom-fields integration — fieldDefinition-delete cascade", () => {
+  test("fieldDef-delete: orphan values removed from all entity-rows", async () => {
+    await defineField("property", "ephemeral");
+    await createProperty("55555555-5555-4000-8000-000000000005", "WillLoseField");
+    await setCustomField("property", "55555555-5555-4000-8000-000000000005", "ephemeral", "doomed");
+    await stack.eventDispatcher?.runOnce();
+
+    let p5 = (await listProperties()).rows.find(
+      (r) => r["id"] === "55555555-5555-4000-8000-000000000005",
+    );
+    expect(p5?.["ephemeral"]).toBe("doomed");
+
+    // Delete fieldDef — cascade-MSP entfernt jsonb-key aus allen rows
+    await stack.http.writeOk(
+      "custom-fields:write:delete-tenant-field",
+      { entityName: "property", fieldKey: "ephemeral" },
+      admin,
+    );
+    await stack.eventDispatcher?.runOnce();
+
+    p5 = (await listProperties()).rows.find(
+      (r) => r["id"] === "55555555-5555-4000-8000-000000000005",
+    );
+    expect(p5?.["ephemeral"]).toBeUndefined();
+    expect(p5?.["name"]).toBe("WillLoseField"); // Stammfeld unverändert
+  });
+});
+
+describe("custom-fields integration — Last-Wins on concurrent set", () => {
+  test("two sequential sets on same field: last value wins", async () => {
+    await defineField("property", "status");
+    await createProperty("66666666-6666-4000-8000-000000000006", "StatusEntity");
+
+    await setCustomField("property", "66666666-6666-4000-8000-000000000006", "status", "draft");
+    await setCustomField("property", "66666666-6666-4000-8000-000000000006", "status", "published");
+    await stack.eventDispatcher?.runOnce();
+
+    const p6 = (await listProperties()).rows.find(
+      (r) => r["id"] === "66666666-6666-4000-8000-000000000006",
+    );
+    expect(p6?.["status"]).toBe("published");
+  });
+});

package/src/custom-fields/__tests__/feature.test.ts

@@ -9,7 +9,7 @@ import { defineFieldPayloadSchema, deleteFieldPayloadSchema } from "../schemas";
 // MSP + Read-Pipeline da ist — die testen ES-Loop end-to-end.
 
 describe("createCustomFieldsFeature shape", () => {
-  test("registers field-definition entity + 4 write-handlers + 1 query-handler", () => {
+  test("registers field-definition entity + 6 write-handlers + 1 query-handler", () => {
     const feature = createCustomFieldsFeature();
 
     expect(Object.keys(feature.entities)).toContain("field-definition");
@@ -21,11 +21,18 @@ describe("createCustomFieldsFeature shape", () => {
         expect.stringMatching(/define-system-field/),
         expect.stringMatching(/delete-tenant-field/),
         expect.stringMatching(/delete-system-field/),
+        expect.stringMatching(/set-custom-field/),
+        expect.stringMatching(/clear-custom-field/),
       ]),
     );
 
     expect(Object.keys(feature.queryHandlers)).toHaveLength(1);
   });
+
+  test("registers customFields extension-name via extendsRegistrar (B2 wiring opt-in)", () => {
+    const feature = createCustomFieldsFeature();
+    expect(feature.registrarExtensions["customFields"]).toBeDefined();
+  });
 });
 
 describe("defineFieldPayloadSchema", () => {

package/src/custom-fields/__tests__/field-access.integration.ts

@@ -0,0 +1,268 @@
+// T1.5b — per-field fieldAccess.write enforcement for set/clear handlers.
+//
+// Verifies that when a fieldDefinition carries
+// `serializedField.fieldAccess.write = [<role>, ...]`, the set and clear
+// handlers reject calls whose user lacks any of the listed roles — even
+// when handler-level RBAC (TenantAdmin/TenantMember) admits them.
+//
+// Inverse: when fieldAccess.write is absent or empty, the handlers behave
+// exactly as in B2 (no extra gate) — the existing roundtrip-test suite
+// stays green, and we add an explicit covers-the-no-op-path test here too.
+
+import { buildDrizzleTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntity,
+  createEntityExecutor,
+  createTextField,
+  defineFeature,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createTestUser,
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { sql } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { z } from "zod";
+import { fieldDefinitionEntity } from "../entity";
+import { createCustomFieldsFeature } from "../feature";
+import { customFieldsField, wireCustomFieldsFor } from "../wire-for-entity";
+
+const propertyEntity = createEntity({
+  table: "read_t15b_properties",
+  fields: {
+    name: createTextField({ required: true }),
+    customFields: customFieldsField(),
+  },
+});
+const propertyTable = buildDrizzleTable("property", propertyEntity);
+
+const propertyFeature = defineFeature("property-t15b", (r) => {
+  r.entity("property", propertyEntity);
+  r.requires("custom-fields");
+  wireCustomFieldsFor(r, "property", propertyTable);
+
+  const { executor } = createEntityExecutor("property", propertyEntity);
+  r.writeHandler({
+    name: "property:create",
+    schema: z.object({ id: z.string(), name: z.string() }),
+    access: { roles: ["TenantAdmin", "TenantMember"] },
+    handler: async (event, ctx) =>
+      executor.create(
+        { id: event.payload.id, name: event.payload.name, customFields: {} },
+        event.user,
+        ctx.db,
+      ),
+  });
+});
+
+const customFieldsFeature = createCustomFieldsFeature();
+
+// Two users on the same tenant — both pass handler-level RBAC (which
+// accepts both roles), so the only difference that should matter is the
+// per-field fieldAccess gate.
+const tenantAdmin = createTestUser({ id: 1, roles: ["TenantAdmin"] });
+const tenantMember = createTestUser({ id: 2, roles: ["TenantMember"] });
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [customFieldsFeature, propertyFeature],
+  });
+  await unsafeCreateEntityTable(stack.db, fieldDefinitionEntity);
+  await unsafeCreateEntityTable(stack.db, propertyEntity);
+  await createEventsTable(stack.db);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  await resetEventStore(stack);
+  await stack.db.execute(sql`DELETE FROM read_t15b_properties`);
+  await stack.db.execute(sql`DELETE FROM read_custom_field_definitions`);
+});
+
+async function defineField(fieldKey: string, serializedField: Record<string, unknown>) {
+  return stack.http.writeOk(
+    "custom-fields:write:define-tenant-field",
+    {
+      entityName: "property",
+      fieldKey,
+      serializedField,
+      required: false,
+      searchable: false,
+      displayOrder: 0,
+    },
+    tenantAdmin,
+  );
+}
+
+describe("T1.5b: per-field fieldAccess.write rejects users without required roles", () => {
+  test("set: TenantMember cannot set a field guarded by fieldAccess.write=['TenantAdmin']", async () => {
+    const propertyId = "11111111-1111-4000-8000-000000000001";
+
+    await defineField("adminOnly", {
+      type: "text",
+      fieldAccess: { write: ["TenantAdmin"] },
+    });
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "BookStore" },
+      tenantAdmin,
+    );
+
+    const err = await stack.http.writeErr(
+      "custom-fields:write:set-custom-field",
+      {
+        entityName: "property",
+        entityId: propertyId,
+        fieldKey: "adminOnly",
+        value: "X-42",
+      },
+      tenantMember,
+    );
+
+    expect(err.code).toBe("unprocessable");
+    expect(err.details).toMatchObject({
+      reason: "field_access_denied",
+      fieldKey: "adminOnly",
+      requiredRoles: ["TenantAdmin"],
+    });
+  });
+
+  test("set: TenantAdmin passes the same fieldAccess gate", async () => {
+    const propertyId = "22222222-2222-4000-8000-000000000002";
+
+    await defineField("adminOnly", {
+      type: "text",
+      fieldAccess: { write: ["TenantAdmin"] },
+    });
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "AdminAllowed" },
+      tenantAdmin,
+    );
+
+    const res = await stack.http.writeOk(
+      "custom-fields:write:set-custom-field",
+      {
+        entityName: "property",
+        entityId: propertyId,
+        fieldKey: "adminOnly",
+        value: "X-42",
+      },
+      tenantAdmin,
+    );
+
+    expect(res).toMatchObject({ entityName: "property", entityId: propertyId });
+  });
+
+  test("clear: same gate applies to clear-custom-field", async () => {
+    const propertyId = "33333333-3333-4000-8000-000000000003";
+
+    await defineField("adminOnly", {
+      type: "boolean",
+      fieldAccess: { write: ["TenantAdmin"] },
+    });
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "ClearGated" },
+      tenantAdmin,
+    );
+    await stack.http.writeOk(
+      "custom-fields:write:set-custom-field",
+      { entityName: "property", entityId: propertyId, fieldKey: "adminOnly", value: true },
+      tenantAdmin,
+    );
+
+    const err = await stack.http.writeErr(
+      "custom-fields:write:clear-custom-field",
+      { entityName: "property", entityId: propertyId, fieldKey: "adminOnly" },
+      tenantMember,
+    );
+
+    expect(err.details).toMatchObject({
+      reason: "field_access_denied",
+      fieldKey: "adminOnly",
+    });
+  });
+
+  test("no-op: fields without fieldAccess.write let TenantMember through (back-compat)", async () => {
+    const propertyId = "44444444-4444-4000-8000-000000000004";
+
+    await defineField("openField", { type: "text" });
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "OpenAccess" },
+      tenantAdmin,
+    );
+
+    const res = await stack.http.writeOk(
+      "custom-fields:write:set-custom-field",
+      {
+        entityName: "property",
+        entityId: propertyId,
+        fieldKey: "openField",
+        value: "anyone-can-write-this",
+      },
+      tenantMember,
+    );
+
+    expect(res).toMatchObject({ entityName: "property", entityId: propertyId });
+  });
+
+  test("any role in the list grants access — intersection, not subset", async () => {
+    const propertyId = "55555555-5555-4000-8000-000000000005";
+
+    await defineField("adminOrMember", {
+      type: "text",
+      fieldAccess: { write: ["TenantAdmin", "TenantMember"] },
+    });
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "BothAllowed" },
+      tenantAdmin,
+    );
+
+    const res = await stack.http.writeOk(
+      "custom-fields:write:set-custom-field",
+      {
+        entityName: "property",
+        entityId: propertyId,
+        fieldKey: "adminOrMember",
+        value: "ok-from-member",
+      },
+      tenantMember,
+    );
+
+    expect(res).toMatchObject({ entityName: "property", entityId: propertyId });
+  });
+
+  test("missing fieldDefinition surfaces as not_found (different from access_denied)", async () => {
+    const propertyId = "66666666-6666-4000-8000-000000000006";
+    await stack.http.writeOk(
+      "property-t15b:write:property:create",
+      { id: propertyId, name: "NoSuchField" },
+      tenantAdmin,
+    );
+
+    const err = await stack.http.writeErr(
+      "custom-fields:write:set-custom-field",
+      {
+        entityName: "property",
+        entityId: propertyId,
+        fieldKey: "neverDefined",
+        value: "doesnt-matter",
+      },
+      tenantAdmin,
+    );
+
+    expect(err.code).toBe("not_found");
+  });
+});