@cosmicdrift/kumiko-framework 0.257.0 → 0.258.1

package/src/db/__tests__/event-store-executor-reference-search.integration.test.ts

@@ -23,7 +23,7 @@ import { createTenantDb, type TenantDb } from "../tenant-db";
 const customerEntity = createEntity({
   table: "read_ref_search_customers",
   fields: {
-    name: createTextField({ required: true }),
+    name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
 });
 const customerTable = buildEntityTable("refSearchCustomer", customerEntity);
@@ -31,7 +31,7 @@ const customerTable = buildEntityTable("refSearchCustomer", customerEntity);
 const orderEntity = createEntity({
   table: "read_ref_search_orders",
   fields: {
-    note: createTextField({ searchable: true }),
+    note: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
     customerId: {
       type: "reference",
       entity: "refSearchCustomer",
@@ -48,7 +48,7 @@ const orderTable = buildEntityTable("refSearchOrder", orderEntity);
 const restrictedOrderEntity = createEntity({
   table: "read_ref_search_restricted_orders",
   fields: {
-    note: createTextField({ searchable: true }),
+    note: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
     customerId: {
       type: "reference",
       entity: "refSearchCustomer",
@@ -66,7 +66,7 @@ const restrictedOrderTable = buildEntityTable("refSearchRestrictedOrder", restri
 // (LIST_ROW_META_REFERENCES) is what's under test, not tenant's full schema.
 const tenantMetaEntity = createEntity({
   table: "read_tenants",
-  fields: { name: createTextField({ required: true }) },
+  fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 const tenantMetaTable = buildEntityTable("tenant", tenantMetaEntity);
 

package/src/db/__tests__/event-store-executor-reference-sort.integration.test.ts

@@ -19,14 +19,14 @@ import { createTenantDb, type TenantDb } from "../tenant-db";
 
 const customerEntity = createEntity({
   table: "read_ref_sort_customers",
-  fields: { name: createTextField({ required: true }) },
+  fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 const customerTable = buildEntityTable("refSortCustomer", customerEntity);
 
 const orderEntity = createEntity({
   table: "read_ref_sort_orders",
   fields: {
-    note: createTextField(),
+    note: createTextField({ personal: false, reason: "test_fixture" }),
     customerId: {
       type: "reference",
       entity: "refSortCustomer",
@@ -43,7 +43,7 @@ const orderTable = buildEntityTable("refSortOrder", orderEntity);
 const restrictedOrderEntity = createEntity({
   table: "read_ref_sort_restricted_orders",
   fields: {
-    note: createTextField(),
+    note: createTextField({ personal: false, reason: "test_fixture" }),
     customerId: {
       type: "reference",
       entity: "refSortCustomer",

package/src/db/__tests__/event-store-executor-write-verbs.integration.test.ts

@@ -44,7 +44,7 @@ afterAll(async () => {
 const restrictedEntity = createEntity({
   table: "read_es_write_restricted",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
   softDelete: true,
   access: { write: { Admin: "all" } },
@@ -189,7 +189,7 @@ describe("event-store-executor write-verbs — entity-level ownership_denied", (
 const hardDeleteEntity = createEntity({
   table: "read_es_write_hard",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
 });
 const hardDeleteTable = buildEntityTable("esWriteHard", hardDeleteEntity);
@@ -340,7 +340,7 @@ describe("event-store-executor write-verbs — field-level ownership_denied", ()
 const versionEntity = createEntity({
   table: "read_es_write_version",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
 });
 const versionTable = buildEntityTable("esWriteVersion", versionEntity);
@@ -394,7 +394,7 @@ describe("event-store-executor write-verbs — version_conflict edge cases", ()
 const raceEntity = createEntity({
   table: "read_es_write_race",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
   softDelete: true,
 });

package/src/db/__tests__/event-store-executor.integration.test.ts

@@ -21,8 +21,13 @@ import { createTenantDb, type TenantDb } from "../tenant-db";
 const entity = createEntity({
   table: "read_es_exec_users",
   fields: {
-    email: createTextField({ required: true, searchable: true }),
-    firstName: createTextField(),
+    email: createTextField({
+      required: true,
+      searchable: true,
+      personal: false,
+      reason: "test_fixture",
+    }),
+    firstName: createTextField({ personal: false, reason: "test_fixture" }),
     isEnabled: createBooleanField({ default: true }),
   },
   softDelete: true,
@@ -133,7 +138,7 @@ const SENSITIVE_TEST_KEY = Buffer.from("s3nS!t1vE.kP9xQ2@wN!vL$hR5yT8eU0").toStr
 const sensitiveEntity = createEntity({
   table: "read_es_exec_sensitive",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     passwordHash: createTextField({ sensitive: true, encrypted: true }),
     apiToken: createTextField({ sensitive: true, encrypted: true }),
   },
@@ -337,7 +342,7 @@ const ENCRYPTION_TEST_KEY = Buffer.from("a]bJm#kP9xQ2@wN!vL$hR5yT8eU0iO3f").toSt
 const encryptedEntity = createEntity({
   table: "read_es_exec_encrypted",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     secretNote: createTextField({ encrypted: true }),
   },
 });
@@ -346,7 +351,7 @@ const encryptedTable = buildEntityTable("esExecEncrypted", encryptedEntity);
 const encryptedSoftDeleteEntity = createEntity({
   table: "read_es_exec_enc_soft",
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     secretNote: createTextField({ encrypted: true }),
   },
   softDelete: true,
@@ -699,7 +704,7 @@ const piiEntity = createEntity({
       find: "none",
     }),
     authorId: createTextField(),
-    plain: createTextField(),
+    plain: createTextField({ personal: false, reason: "test_fixture" }),
   },
 });
 const piiTable = buildEntityTable("esExecPii", piiEntity);

package/src/db/__tests__/event-store-system-stream.integration.test.ts

@@ -22,11 +22,11 @@ import { createTenantDb } from "../tenant-db";
 const systemEntity = createEntity({
   table: "sstream_sys",
   systemStream: true,
-  fields: { name: createTextField({ required: true }) },
+  fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 const tenantOwnedEntity = createEntity({
   table: "sstream_tn",
-  fields: { name: createTextField({ required: true }) },
+  fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 
 const systemTable = buildEntityTable("sstreamSys", systemEntity);

package/src/db/__tests__/implicit-projection-equivalence.integration.test.ts

@@ -31,8 +31,8 @@ import { createTenantDb, type TenantDb } from "../tenant-db";
 const userEntity = createEntity({
   table: "read_implicit_users",
   fields: {
-    email: createTextField({ required: true }),
-    firstName: createTextField(),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    firstName: createTextField({ personal: false, reason: "test_fixture" }),
     isEnabled: createBooleanField({ default: true }),
   },
   softDelete: true,
@@ -204,7 +204,9 @@ describe("implicit-projection / Live==Rebuild equivalence", () => {
   test("ohne softDelete → keine restore-apply-key registriert", () => {
     const hardDeleteEntity = createEntity({
       table: "read_implicit_hard",
-      fields: { name: createTextField({ required: true }) },
+      fields: {
+        name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+      },
     });
     const hardFeature = defineFeature("implicithard", (r) => {
       r.entity("widget", hardDeleteEntity);
@@ -249,7 +251,7 @@ const SENSITIVE_BIDX_KEY = decodeBlindIndexKey(SENSITIVE_BIDX_KEY_B64);
 const sensitiveEntity = createEntity({
   table: sensitiveTable,
   fields: {
-    email: createTextField({ required: true }),
+    email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     apiKey: createTextField({ personal: "self", find: "exact" }),
   },
 });

package/src/db/__tests__/located-timestamp.test.ts

@@ -8,7 +8,7 @@ import { flattenLocatedTimestamp, rehydrateLocatedTimestamp } from "../located-t
 
 const orderEntity: EntityDefinition = createEntity({
   fields: {
-    clientName: createTextField(),
+    clientName: createTextField({ personal: false, reason: "test_fixture" }),
     pickup: createLocatedTimestampField(),
     delivery: createLocatedTimestampField(),
   },

package/src/db/__tests__/money.test.ts

@@ -12,7 +12,7 @@ import { flattenMoney, type MoneyRead, moneyPayloadToMinorUnits, rehydrateMoney
 const orderEntity: EntityDefinition = createEntity({
   defaultCurrency: "EUR",
   fields: {
-    label: createTextField(),
+    label: createTextField({ personal: false, reason: "test_fixture" }),
     buyingPrice: createMoneyField(),
     sellingPrice: createMoneyField(),
   },

package/src/db/__tests__/multi-row-insert.integration.test.ts

@@ -18,8 +18,8 @@ import { setupTestStack, type TestStack, unsafeCreateEntityTable } from "../../s
 const linkEntity = createEntity({
   table: "mri_links",
   fields: {
-    leftId: createTextField({ required: true }),
-    rightId: createTextField({ required: true }),
+    leftId: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    rightId: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
 });
 const linkTable = buildEntityTable("link", linkEntity);
@@ -42,7 +42,7 @@ describe("instant() customType is forgiving with ISO strings", () => {
 
   const tsEntity = createEntity({
     table: "mri_ts",
-    fields: { name: createTextField({ required: true }) },
+    fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
   });
   const tsTable = buildEntityTable("ts-row", tsEntity);
 

package/src/db/__tests__/parent-ref-clause.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from "bun:test";
+import { createEntity, createTextField } from "../../engine/factories";
+import { combineClauses, from } from "../../engine/ownership";
+import type { EntityDefinition, SessionUser } from "../../engine/types";
+import { buildParentRefClause } from "../parent-ref-clause";
+import { buildEntityTable } from "../table-builder";
+import type { TenantDb } from "../tenant-db";
+
+const TENANT = "11111111-1111-4111-8111-111111111111";
+
+const user: SessionUser = {
+  id: "22222222-2222-4222-8222-222222222222",
+  tenantId: TENANT,
+  roles: ["TenantMember"],
+  claims: {},
+};
+
+// Only `mode` and `tenantId` are read by the clause builder.
+const tenantDb = { mode: "tenant", tenantId: TENANT } as unknown as TenantDb;
+const systemDb = { mode: "system", tenantId: TENANT } as unknown as TenantDb;
+
+const textField = () =>
+  createTextField({
+    required: true,
+    maxLength: 64,
+    personal: false,
+    reason: "technical_reference",
+  });
+
+const joinEntity = createEntity({
+  table: "read_test_joins",
+  fields: { entityType: textField(), entityId: textField() },
+  parentRef: { entityTypeField: "entityType", entityIdField: "entityId" },
+});
+
+function hostEntity(opts?: {
+  readonly access?: EntityDefinition["access"];
+  readonly softDelete?: boolean;
+  readonly idType?: "serial" | "uuid";
+  readonly parentRef?: EntityDefinition["parentRef"];
+}) {
+  return createEntity({
+    table: "read_test_hosts",
+    fields: { ownerId: textField(), entityType: textField(), entityId: textField() },
+    ...opts,
+  });
+}
+
+const joinTable = buildEntityTable("test-join", joinEntity);
+
+function build(
+  entities: ReadonlyMap<string, EntityDefinition> | undefined,
+  opts: { includeDeleted?: boolean; narrowTypes?: ReadonlySet<string>; db?: TenantDb } = {},
+) {
+  return buildParentRefClause(
+    joinEntity,
+    joinTable,
+    "read_test_joins",
+    user,
+    opts.db ?? tenantDb,
+    entities === undefined ? undefined : { entities },
+    {
+      ...(opts.includeDeleted !== undefined && { includeDeleted: opts.includeDeleted }),
+      ...(opts.narrowTypes !== undefined && { narrowTypes: opts.narrowTypes }),
+    },
+  );
+}
+
+describe("buildParentRefClause", () => {
+  test("an entity without parentRef is not gated", () => {
+    const plain = createEntity({ table: "read_plain", fields: { a: textField() } });
+    const clause = buildParentRefClause(
+      plain,
+      buildEntityTable("plain", plain),
+      "read_plain",
+      user,
+      tenantDb,
+      { entities: new Map([["host", hostEntity()]]) },
+      {},
+    );
+    expect(clause.kind).toBe("pass");
+  });
+
+  test("a raw executor call without the registry option stays ungated", () => {
+    expect(build(undefined).kind).toBe("pass");
+  });
+
+  test("no candidate at all denies every row", () => {
+    expect(build(new Map()).kind).toBe("empty");
+  });
+
+  test("a candidate whose read-ownership can never match is dropped, denying when it was the only one", () => {
+    // The role has a rule, but the column it names is not on the host — the
+    // ownership clause collapses to `empty`, so the branch cannot be satisfied.
+    const host = hostEntity({ access: { read: { TenantMember: from("user:id", "notAColumn") } } });
+    expect(build(new Map([["host", host]])).kind).toBe("empty");
+  });
+
+  test("a serial-id candidate is excluded — it has no event-store read path", () => {
+    const host = hostEntity({ idType: "serial" });
+    expect(build(new Map([["host", host]])).kind).toBe("empty");
+  });
+
+  test("a candidate that is itself a join row is excluded — no recursive gating", () => {
+    const host = hostEntity({
+      parentRef: { entityTypeField: "entityType", entityIdField: "entityId" },
+    });
+    expect(build(new Map([["host", host]])).kind).toBe("empty");
+  });
+
+  test("narrowTypes restricts the OR-chain to the named hosts", () => {
+    const entities = new Map([
+      ["host", hostEntity()],
+      ["other", hostEntity()],
+      ["third", hostEntity()],
+    ]);
+    const all = build(entities);
+    const narrowed = build(entities, { narrowTypes: new Set(["other"]) });
+    if (all.kind !== "sql" || narrowed.kind !== "sql") throw new Error("expected sql clauses");
+    expect(all.sqlText.split(" OR ")).toHaveLength(3);
+    expect(narrowed.sqlText.split(" OR ")).toHaveLength(1);
+    expect(narrowed.params).toContain("other");
+    expect(narrowed.params).not.toContain("host");
+  });
+
+  test("the host's soft-delete filter applies by default and lifts under includeDeleted", () => {
+    const entities = new Map([["host", hostEntity({ softDelete: true })]]);
+    const gated = build(entities);
+    const trash = build(entities, { includeDeleted: true });
+    if (gated.kind !== "sql" || trash.kind !== "sql") throw new Error("expected sql clauses");
+    expect(gated.sqlText).toContain('"is_deleted" = FALSE');
+    expect(trash.sqlText).not.toContain("is_deleted");
+  });
+
+  test("the host id is matched through a shape guard, so a foreign id form cannot raise 22P02", () => {
+    const clause = build(new Map([["host", hostEntity()]]));
+    if (clause.kind !== "sql") throw new Error("expected sql clause");
+    expect(clause.sqlText).toContain("CASE WHEN");
+    expect(clause.sqlText).toContain("::uuid");
+    // The shape itself is bound, never inlined — a literal carrying `$` would
+    // be rewritten by shiftParams when the clause is combined.
+    expect(clause.params[0]).toBe("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$");
+    expect(clause.sqlText).not.toContain("[0-9a-f]");
+  });
+
+  test("the tenant predicate is bound once and reused across branches", () => {
+    const entities = new Map([
+      ["host", hostEntity()],
+      ["other", hostEntity()],
+    ]);
+    const clause = build(entities);
+    if (clause.kind !== "sql") throw new Error("expected sql clause");
+    expect(clause.params.filter((p) => p === TENANT)).toHaveLength(1);
+    // uuid shape + 2 tenant params + one host-name param per branch.
+    expect(clause.params).toHaveLength(5);
+  });
+
+  test("a system-mode db drops the tenant predicate, mirroring list()", () => {
+    const clause = build(new Map([["host", hostEntity()]]), { db: systemDb });
+    if (clause.kind !== "sql") throw new Error("expected sql clause");
+    expect(clause.sqlText).not.toContain("tenant_id");
+    expect(clause.params).not.toContain(TENANT);
+  });
+
+  test("a dropped branch reserves no placeholder — every $N still binds its own value", () => {
+    // First candidate collapses to `empty` (column missing on the host), so its
+    // tentatively-reserved indices must not leave a gap for the second.
+    const entities = new Map([
+      [
+        "dropped",
+        hostEntity({ access: { read: { TenantMember: from("user:id", "notAColumn") } } }),
+      ],
+      ["kept", hostEntity({ access: { read: { TenantMember: from("user:id", "ownerId") } } })],
+    ]);
+    const clause = build(entities);
+    if (clause.kind !== "sql") throw new Error("expected sql clause");
+
+    const indices = [...clause.sqlText.matchAll(/\$(\d+)/g)].map((m) => Number(m[1]));
+    expect(Math.max(...indices)).toBeLessThanOrEqual(clause.params.length);
+    expect(Math.min(...indices)).toBeGreaterThanOrEqual(1);
+
+    // The kept branch's host-name param must sit at the placeholder the SQL
+    // actually names for it, not one slot over.
+    const keptSlot = clause.params.indexOf("kept") + 1;
+    expect(keptSlot).toBeGreaterThan(0);
+    expect(clause.sqlText).toContain(`"entity_type" = $${keptSlot}`);
+    expect(clause.params).toContain(user.id);
+    expect(clause.params).not.toContain("dropped");
+  });
+});
+
+describe("combineClauses", () => {
+  const sqlA = { kind: "sql", sqlText: '"a" = $1', params: ["av"] } as const;
+  const sqlB = { kind: "sql", sqlText: '"b" = $1 OR "c" = $2', params: ["bv", "cv"] } as const;
+
+  test("empty on either side denies", () => {
+    expect(combineClauses({ kind: "empty" }, sqlA).kind).toBe("empty");
+    expect(combineClauses(sqlA, { kind: "empty" }).kind).toBe("empty");
+  });
+
+  test("pass is neutral", () => {
+    expect(combineClauses({ kind: "pass" }, sqlA)).toEqual(sqlA);
+    expect(combineClauses(sqlA, { kind: "pass" })).toEqual(sqlA);
+    expect(combineClauses({ kind: "pass" }, { kind: "pass" }).kind).toBe("pass");
+  });
+
+  test("the second clause's placeholders are shifted past the first's params", () => {
+    const combined = combineClauses(sqlA, sqlB);
+    if (combined.kind !== "sql") throw new Error("expected sql clause");
+    expect(combined.sqlText).toBe('("a" = $1 AND "b" = $2 OR "c" = $3)');
+    expect(combined.params).toEqual(["av", "bv", "cv"]);
+  });
+});

package/src/db/__tests__/schema-migration.integration.test.ts

@@ -80,8 +80,8 @@ describe("schema migration workflows", () => {
         createEntity({
           table: "wf1_posts",
           fields: {
-            title: createTextField({ required: true }),
-            body: createTextField(),
+            title: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+            body: createTextField({ personal: false, reason: "test_fixture" }),
             viewCount: createNumberField(),
             publishedAt: createDateField(),
             isDraft: createBooleanField({ default: true }),
@@ -121,7 +121,7 @@ describe("schema migration workflows", () => {
         "article",
         createEntity({
           table: "wf1b_articles",
-          fields: { title: createTextField() },
+          fields: { title: createTextField({ personal: false, reason: "test_fixture" }) },
         }),
       );
     });
@@ -138,7 +138,7 @@ describe("schema migration workflows", () => {
     // Initial entity with just email
     const initialEntity = createEntity({
       table: "wf2_users",
-      fields: { email: createTextField() },
+      fields: { email: createTextField({ personal: false, reason: "test_fixture" }) },
     });
     await unsafePushTables(testDb.db, { user: buildEntityTable("user", initialEntity) });
 
@@ -146,8 +146,8 @@ describe("schema migration workflows", () => {
     const updatedEntity = createEntity({
       table: "wf2_users",
       fields: {
-        email: createTextField(),
-        displayName: createTextField(), // NEW FIELD
+        email: createTextField({ personal: false, reason: "test_fixture" }),
+        displayName: createTextField({ personal: false, reason: "test_fixture" }), // NEW FIELD
       },
     });
 
@@ -168,7 +168,7 @@ describe("schema migration workflows", () => {
     // Initial entity with just name
     const initialEntity = createEntity({
       table: "wf3_projects",
-      fields: { name: createTextField() },
+      fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
     });
     const initialTable = buildEntityTable("project", initialEntity);
     await unsafePushTables(testDb.db, { project: initialTable });
@@ -182,7 +182,10 @@ describe("schema migration workflows", () => {
     // Developer adds boolean field with default
     const updatedEntity = createEntity({
       table: "wf3_projects",
-      fields: { name: createTextField(), isArchived: createBooleanField({ default: false }) },
+      fields: {
+        name: createTextField({ personal: false, reason: "test_fixture" }),
+        isArchived: createBooleanField({ default: false }),
+      },
     });
     const updatedTable = buildEntityTable("project", updatedEntity);
     await unsafePushTables(testDb.db, { project: updatedTable }, { project: initialTable });
@@ -202,7 +205,9 @@ describe("schema migration workflows", () => {
     // greift.
     const initialEntity = createEntity({
       table: "wf3b_users",
-      fields: { email: createTextField({ required: true }) },
+      fields: {
+        email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+      },
     });
     const initialTable = buildEntityTable("user", initialEntity);
     await unsafePushTables(testDb.db, { user: initialTable });
@@ -215,8 +220,13 @@ describe("schema migration workflows", () => {
     const updatedEntity = createEntity({
       table: "wf3b_users",
       fields: {
-        email: createTextField({ required: true }),
-        roles: createTextField({ required: true, default: "[]" }),
+        email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+        roles: createTextField({
+          required: true,
+          default: "[]",
+          personal: false,
+          reason: "test_fixture",
+        }),
       },
     });
     const updatedTable = buildEntityTable("user", updatedEntity);
@@ -232,7 +242,7 @@ describe("schema migration workflows", () => {
         "task",
         createEntity({
           table: "wf4_tasks",
-          fields: { title: createTextField() },
+          fields: { title: createTextField({ personal: false, reason: "test_fixture" }) },
           softDelete: true,
         }),
       );
@@ -253,7 +263,10 @@ describe("schema migration workflows", () => {
     const blogFeature = defineFeature("blog", (r) => {
       r.entity(
         "article",
-        createEntity({ table: "wf5_articles", fields: { title: createTextField() } }),
+        createEntity({
+          table: "wf5_articles",
+          fields: { title: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
     });
 
@@ -262,7 +275,10 @@ describe("schema migration workflows", () => {
         "product",
         createEntity({
           table: "wf5_products",
-          fields: { name: createTextField(), price: createNumberField() },
+          fields: {
+            name: createTextField({ personal: false, reason: "test_fixture" }),
+            price: createNumberField(),
+          },
         }),
       );
     });

package/src/db/__tests__/source-shadow-create.integration.test.ts

@@ -23,7 +23,7 @@ const sourceEntity = createEntity({
   table: "ssc_source",
   fields: {
     // `source` collides with the EntityTableMeta discriminator key.
-    source: createTextField({ required: true }),
+    source: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
 });
 const sourceTable = buildEntityTable("source-row", sourceEntity);