@cosmicdrift/kumiko-framework 0.328.0 → 0.329.0

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

@@ -1,1211 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  createBooleanField,
-  createDateField,
-  createEmbeddedField,
-  createEmbeddedListField,
-  createEntity,
-  createFileField,
-  createFilesField,
-  createImageField,
-  createImagesField,
-  createLocatedTimestampField,
-  createMoneyField,
-  createMultiSelectField,
-  createNumberField,
-  createSelectField,
-  createTextField,
-} from "../factories";
-import { buildInsertSchema, buildUpdateSchema } from "../schema-builder";
-import type { FieldDefinition } from "../types/fields";
-
-type SchemaCase = {
-  readonly name: string;
-  readonly fields: Record<string, FieldDefinition>;
-  readonly valid: Record<string, unknown> | null;
-  readonly invalid: Record<string, unknown> | null;
-};
-
-// --- Field type → Zod mapping ---
-
-describe("buildInsertSchema", () => {
-  test.each<SchemaCase>([
-    {
-      name: "required text field",
-      fields: {
-        email: createTextField({ required: true, personal: false, reason: "test_fixture" }),
-      },
-      valid: { email: "test@test.de" },
-      invalid: { email: "" },
-    },
-    {
-      name: "optional text field",
-      fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
-      valid: {},
-      invalid: null,
-    },
-    {
-      name: "text field with maxLength",
-      fields: { name: createTextField({ maxLength: 5, personal: false, reason: "test_fixture" }) },
-      valid: { name: "hello" },
-      invalid: { name: "toolong" },
-    },
-    {
-      name: "email format",
-      fields: {
-        email: createTextField({
-          required: true,
-          format: "email",
-          personal: false,
-          reason: "test_fixture",
-        }),
-      },
-      valid: { email: "a@b.de" },
-      invalid: { email: "not-an-email" },
-    },
-    {
-      name: "boolean field",
-      fields: { active: createBooleanField() },
-      valid: { active: true },
-      invalid: { active: "yes" },
-    },
-    {
-      name: "boolean with default",
-      fields: { active: createBooleanField({ default: true }) },
-      valid: {},
-      invalid: null,
-    },
-    {
-      name: "select field",
-      fields: { locale: createSelectField({ options: ["de", "en", "fr"] as const }) },
-      valid: { locale: "de" },
-      invalid: { locale: "xx" },
-    },
-    {
-      name: "multiSelect field accepts subset",
-      fields: { tags: createMultiSelectField({ options: ["red", "green", "blue"] as const }) },
-      valid: { tags: ["red", "blue"] },
-      invalid: { tags: ["yellow"] },
-    },
-    {
-      name: "multiSelect field accepts empty array",
-      fields: { tags: createMultiSelectField({ options: ["a", "b"] as const }) },
-      valid: { tags: [] },
-      invalid: null,
-    },
-    {
-      name: "multiSelect with default",
-      fields: {
-        tags: createMultiSelectField({ options: ["a", "b", "c"] as const, default: ["a"] }),
-      },
-      valid: {},
-      invalid: null,
-    },
-    {
-      name: "required multiSelect rejects empty array",
-      fields: {
-        tags: createMultiSelectField({ options: ["a", "b"] as const, required: true }),
-      },
-      valid: { tags: ["a"] },
-      invalid: { tags: [] },
-    },
-    {
-      name: "required multiSelect rejects missing field",
-      fields: {
-        tags: createMultiSelectField({ options: ["a", "b"] as const, required: true }),
-      },
-      valid: { tags: ["b"] },
-      invalid: {},
-    },
-    {
-      name: "number field",
-      fields: { age: createNumberField({ required: true }) },
-      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: "integer field rejects a value outside Postgres int4 range (must 400, not crash the DB write)",
-      fields: { attempt: createNumberField({ integer: true }) },
-      valid: { attempt: 2147483647 },
-      invalid: { attempt: 2147483648 },
-    },
-    {
-      name: "integer field with explicit max narrower than int4 still enforces the explicit bound",
-      fields: { displayOrder: createNumberField({ integer: true, max: 100 }) },
-      valid: { displayOrder: 100 },
-      invalid: { displayOrder: 101 },
-    },
-    {
-      name: "date field",
-      fields: { born: createDateField() },
-      valid: { born: "2026-01-01" },
-      invalid: { born: 12345 },
-    },
-  ])("$name", ({ fields, valid, invalid }) => {
-    const entity = createEntity({ table: "Test", fields });
-    const schema = buildInsertSchema(entity);
-
-    if (valid) {
-      expect(schema.safeParse(valid).success).toBe(true);
-    }
-    if (invalid) {
-      expect(schema.safeParse(invalid).success).toBe(false);
-    }
-  });
-
-  test("combines multiple fields into one schema", () => {
-    const entity = createEntity({
-      table: "Users",
-      fields: {
-        email: createTextField({
-          required: true,
-          format: "email",
-          personal: false,
-          reason: "test_fixture",
-        }),
-        firstName: createTextField({ personal: false, reason: "test_fixture" }),
-        isEnabled: createBooleanField({ default: true }),
-        locale: createSelectField({ options: ["de", "en"] as const }),
-      },
-    });
-
-    const schema = buildInsertSchema(entity);
-
-    // Valid: only required field + rest optional
-    const result = schema.safeParse({ email: "a@b.de" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["isEnabled"]).toBe(true); // default applied
-    }
-
-    // Invalid: missing required field
-    expect(schema.safeParse({}).success).toBe(false);
-
-    // Invalid: wrong type
-    expect(schema.safeParse({ email: "a@b.de", isEnabled: "nope" }).success).toBe(false);
-  });
-
-  // The four file-field variants. Pre-fix the schema was z.number() /
-  // z.array(z.number()) — legacy of an era where fileRefs were serial-keyed.
-  // After the UUID table-builder fix those schemas would have rejected every
-  // valid UUID string, so the fix HAD to move in lockstep. Each test here
-  // asserts the new UUID contract AND explicitly rejects the old number
-  // shape, so a regression to z.number() would flip every test red.
-  test("file field accepts UUID (fileRefId)", () => {
-    const entity = createEntity({ table: "Test", fields: { contract: createFileField() } });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ contract: "00000000-0000-4000-8000-000000000001" }).success).toBe(
-      true,
-    );
-    expect(schema.safeParse({ contract: 42 }).success).toBe(false);
-    expect(schema.safeParse({ contract: "not-a-uuid" }).success).toBe(false);
-  });
-
-  test("image field accepts UUID (fileRefId)", () => {
-    const entity = createEntity({ table: "Test", fields: { avatar: createImageField() } });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ avatar: "00000000-0000-4000-8000-000000000002" }).success).toBe(true);
-    expect(schema.safeParse({ avatar: 1 }).success).toBe(false);
-    expect(schema.safeParse({ avatar: "photo.jpg" }).success).toBe(false);
-  });
-
-  test("files field accepts array of UUIDs", () => {
-    const entity = createEntity({ table: "Test", fields: { docs: createFilesField() } });
-    const schema = buildInsertSchema(entity);
-    expect(
-      schema.safeParse({
-        docs: ["00000000-0000-4000-8000-000000000001", "00000000-0000-4000-8000-000000000002"],
-      }).success,
-    ).toBe(true);
-    expect(schema.safeParse({ docs: [1, 2, 3] }).success).toBe(false);
-    expect(schema.safeParse({ docs: "00000000-0000-4000-8000-000000000001" }).success).toBe(false);
-  });
-
-  test("images field accepts array of UUIDs", () => {
-    const entity = createEntity({ table: "Test", fields: { photos: createImagesField() } });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ photos: ["00000000-0000-4000-8000-000000000003"] }).success).toBe(
-      true,
-    );
-    expect(schema.safeParse({ photos: [10, 20] }).success).toBe(false);
-    expect(schema.safeParse({ photos: "nope" }).success).toBe(false);
-  });
-
-  test("money field accepts { amount, currency } object", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { price: createMoneyField({ required: true }) },
-      defaultCurrency: "EUR",
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ price: { amount: 1250, currency: "EUR" } }).success).toBe(true);
-    expect(schema.safeParse({ price: { amount: 99.99, currency: "USD" } }).success).toBe(true);
-  });
-
-  test("money field rejects invalid currency", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { price: createMoneyField() },
-      defaultCurrency: "EUR",
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ price: { amount: 100, currency: "FAKE" } }).success).toBe(false);
-  });
-
-  test("money field rejects plain number", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { price: createMoneyField() },
-      defaultCurrency: "EUR",
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ price: 1250 }).success).toBe(false);
-  });
-
-  test("money field with custom currencies", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { price: createMoneyField() },
-      defaultCurrency: "BHD",
-    });
-    const customCurrencies = ["EUR", "USD", "BHD"] as const;
-    const schema = buildInsertSchema(entity, customCurrencies);
-    expect(schema.safeParse({ price: { amount: 500, currency: "BHD" } }).success).toBe(true);
-    expect(schema.safeParse({ price: { amount: 500, currency: "GBP" } }).success).toBe(false);
-  });
-
-  test("required text rejects empty string", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ name: "" }).success).toBe(false);
-  });
-
-  test("embedded field accepts object matching schema", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        address: createEmbeddedField({
-          street: { type: "text", required: true },
-          zip: { type: "text", required: true },
-          city: { type: "text", required: true },
-          country: { type: "text" },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(
-      schema.safeParse({
-        address: { street: "Hauptstr. 1", zip: "10115", city: "Berlin" },
-      }).success,
-    ).toBe(true);
-  });
-
-  test("embedded field rejects missing required sub-field", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        address: createEmbeddedField({
-          street: { type: "text", required: true },
-          city: { type: "text", required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ address: { street: "Hauptstr." } }).success).toBe(false);
-  });
-
-  test("embedded field rejects wrong sub-field type", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        address: createEmbeddedField({
-          zip: { type: "number" },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ address: { zip: "not-a-number" } }).success).toBe(false);
-    expect(schema.safeParse({ address: { zip: 10115 } }).success).toBe(true);
-  });
-
-  test("embedded field accepts optional sub-fields", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        address: createEmbeddedField({
-          street: { type: "text", required: true },
-          notes: { type: "text" },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ address: { street: "Main St" } }).success).toBe(true);
-  });
-
-  test("optional embedded field can be omitted", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
-        address: createEmbeddedField({ street: { type: "text" } }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ name: "Test" }).success).toBe(true);
-  });
-
-  test("required embedded field cannot be omitted", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        address: createEmbeddedField({ street: { type: "text" } }, { required: true }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({}).success).toBe(false);
-  });
-
-  test("embedded-list field validates every row against the schema", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField({
-          accountId: { type: "text", required: true },
-          amount: { type: "number", required: true },
-          note: { type: "text" },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(
-      schema.safeParse({
-        lines: [
-          { accountId: "bank", amount: 100 },
-          { accountId: "rent", amount: -100, note: "Januar" },
-        ],
-      }).success,
-    ).toBe(true);
-    // second row is missing `amount` — a per-row check the free jsonb field
-    // this replaces could not make
-    expect(
-      schema.safeParse({ lines: [{ accountId: "bank", amount: 100 }, { accountId: "rent" }] })
-        .success,
-    ).toBe(false);
-    expect(schema.safeParse({ lines: [{ accountId: "bank", amount: "100" }] }).success).toBe(false);
-  });
-
-  test("embedded-list field rejects a bare object", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { lines: createEmbeddedListField({ accountId: { type: "text", required: true } }) },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ lines: { accountId: "bank" } }).success).toBe(false);
-  });
-
-  test("optional embedded-list accepts an empty list, required one does not", () => {
-    const optional = buildInsertSchema(
-      createEntity({
-        table: "Test",
-        fields: { lines: createEmbeddedListField({ accountId: { type: "text" } }) },
-      }),
-    );
-    expect(optional.safeParse({ lines: [] }).success).toBe(true);
-    expect(optional.safeParse({}).success).toBe(true);
-
-    const required = buildInsertSchema(
-      createEntity({
-        table: "Test",
-        fields: {
-          lines: createEmbeddedListField({ accountId: { type: "text" } }, { required: true }),
-        },
-      }),
-    );
-    expect(required.safeParse({ lines: [] }).success).toBe(false);
-    expect(required.safeParse({}).success).toBe(false);
-    expect(required.safeParse({ lines: [{ accountId: "bank" }] }).success).toBe(true);
-  });
-
-  test("select sub-field accepts a listed option, rejects an unlisted string", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField({
-          status: { type: "select", options: ["draft", "sent"], required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ lines: [{ status: "sent" }] }).success).toBe(true);
-    expect(schema.safeParse({ lines: [{ status: "archived" }] }).success).toBe(false);
-  });
-
-  test("reference sub-field accepts a UUID, rejects a non-UUID string", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField({
-          productId: { type: "reference", entity: "product", required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(
-      schema.safeParse({ lines: [{ productId: "550e8400-e29b-41d4-a716-446655440000" }] }).success,
-    ).toBe(true);
-    expect(schema.safeParse({ lines: [{ productId: "not-a-uuid" }] }).success).toBe(false);
-  });
-
-  test("minItems/maxItems bound an embedded list", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField(
-          { accountId: { type: "text", required: true } },
-          { minItems: 2, maxItems: 3 },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ lines: [{ accountId: "a" }] }).success).toBe(false);
-    expect(schema.safeParse({ lines: [{ accountId: "a" }, { accountId: "b" }] }).success).toBe(
-      true,
-    );
-    expect(
-      schema.safeParse({
-        lines: [{ accountId: "a" }, { accountId: "b" }, { accountId: "c" }],
-      }).success,
-    ).toBe(true);
-    expect(
-      schema.safeParse({
-        lines: [{ accountId: "a" }, { accountId: "b" }, { accountId: "c" }, { accountId: "d" }],
-      }).success,
-    ).toBe(false);
-  });
-
-  test("money sub-field accepts signed integer minor units, rejects fractions", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField({
-          accountId: { type: "text", required: true },
-          amount: { type: "money", required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const line = (amount: number) => ({ lines: [{ accountId: "bank", amount }] });
-    expect(schema.safeParse(line(100)).success).toBe(true);
-    expect(schema.safeParse(line(-100)).success).toBe(true);
-    expect(schema.safeParse(line(Number.MAX_SAFE_INTEGER)).success).toBe(true);
-    // a fractional amount is the Euro-vs-Cent confusion the type exists to catch
-    expect(schema.safeParse(line(10.5)).success).toBe(false);
-    expect(schema.safeParse(line(Number.MAX_SAFE_INTEGER + 1)).success).toBe(false);
-  });
-
-  test("decimal sub-field bounds the value to its scale", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        items: createEmbeddedListField({
-          qty: { type: "decimal", scale: 2, required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const row = (qty: number) => ({ items: [{ qty }] });
-    expect(schema.safeParse(row(1.25)).success).toBe(true);
-    expect(schema.safeParse(row(-3.5)).success).toBe(true);
-    // float artifact of an in-scale computation must pass (same contract as
-    // the top-level decimal field)
-    expect(schema.safeParse(row(0.1 + 0.2)).success).toBe(true);
-    expect(schema.safeParse(row(0.305)).success).toBe(false);
-    // scaled by 10^2 this leaves the safe-integer range
-    expect(schema.safeParse(row(Number.MAX_SAFE_INTEGER)).success).toBe(false);
-  });
-
-  test("tz field validates against the IANA zone list", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { zone: { type: "tz", required: true } },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ zone: "Europe/Berlin" }).success).toBe(true);
-    expect(schema.safeParse({ zone: "UTC" }).success).toBe(true);
-    expect(schema.safeParse({ zone: "Mars/Phobos" }).success).toBe(false);
-    expect(schema.safeParse({ zone: "" }).success).toBe(false);
-  });
-
-  test("locatedTimestamp validates its tz against the IANA zone list", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { pickup: createLocatedTimestampField({ required: true }) },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(
-      schema.safeParse({ pickup: { at: "2026-04-03T10:00:00", tz: "Europe/Lisbon" } }).success,
-    ).toBe(true);
-    expect(
-      schema.safeParse({ pickup: { at: "2026-04-03T10:00:00", tz: "Mars/Phobos" } }).success,
-    ).toBe(false);
-  });
-
-  // #1674: an untouched HTML <select> submits "" for its placeholder option.
-  // An optional select without a default must treat "" as "not set" (null),
-  // not reject it as an invalid enum value.
-  test("optional select without default accepts empty string as unset (null)", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { locale: createSelectField({ options: ["de", "en", "fr"] as const }) },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ locale: "" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBeNull();
-    }
-  });
-
-  test("optional select without default still validates a real value", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { locale: createSelectField({ options: ["de", "en", "fr"] as const }) },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ locale: "en" }).success).toBe(true);
-    expect(schema.safeParse({ locale: "xx" }).success).toBe(false);
-  });
-
-  test("required select rejects empty string", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { locale: createSelectField({ options: ["de", "en"] as const, required: true }) },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ locale: "" }).success).toBe(false);
-  });
-
-  // #1702: same ""-problem as #1674, but for a select WITH a default —
-  // an untouched <select> sends "" and the default only kicks in for
-  // undefined. "" maps to the default (a defaulted field is never unset).
-  test("optional select with default accepts empty string and falls back to the default", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en", "fr"] as const, default: "de" }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ locale: "" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBe("de");
-    }
-  });
-
-  // Review-fix (kumiko-framework#1712): an optional select WITHOUT a default
-  // normalizes an untouched <select> to null (see the "unset (null)" test
-  // above). A client that reuses that null against a since-defaulted field
-  // must fall back to the default too, not get rejected as an invalid enum
-  // value the way a bare `null` previously was.
-  test("optional select with default accepts null and falls back to the default", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en", "fr"] as const, default: "de" }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ locale: null });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBe("de");
-    }
-  });
-
-  test("optional select with default still validates a real value", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en"] as const, default: "de" }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ locale: "en" }).success).toBe(true);
-    expect(schema.safeParse({ locale: "xx" }).success).toBe(false);
-  });
-
-  // #1712: pin omitted-key + explicit undefined — ZodPipe/optin path for defaults
-  test("optional select with default applies when key omitted or undefined", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en", "fr"] as const, default: "de" }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const omitted = schema.safeParse({});
-    expect(omitted.success).toBe(true);
-    if (omitted.success) expect(omitted.data["locale"]).toBe("de");
-    const undef = schema.safeParse({ locale: undefined });
-    expect(undef.success).toBe(true);
-    if (undef.success) expect(undef.data["locale"]).toBe("de");
-  });
-});
-
-// --- fw#1839: embedded-list timestamp sub-field ---
-
-describe("embedded sub-field: timestamp", () => {
-  test("accepts a valid ISO datetime, rejects an invalid string", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        lines: createEmbeddedListField({
-          loggedAt: { type: "timestamp", required: true },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    expect(schema.safeParse({ lines: [{ loggedAt: "2026-08-06T10:00:00Z" }] }).success).toBe(true);
-    expect(schema.safeParse({ lines: [{ loggedAt: "not-a-date" }] }).success).toBe(false);
-    expect(schema.safeParse({ lines: [{ loggedAt: "2026-08-06" }] }).success).toBe(false);
-  });
-});
-
-// --- fw#1839: totalsMatch cross-field validation (schema-level, shared by
-// client form-controller and server write handler via the same
-// z.object().safeParse() call) ---
-
-describe("totalsMatch (fw#1839)", () => {
-  function invoiceEntity() {
-    return createEntity({
-      table: "Invoices",
-      fields: {
-        total: createMoneyField({ required: true }),
-        lines: createEmbeddedListField(
-          { amount: { type: "money", required: true } },
-          { totalsMatch: { amount: "total" } },
-        ),
-      },
-      defaultCurrency: "EUR",
-    });
-  }
-
-  test("accepts when the sum of line amounts (minor units) equals the sibling total (major units)", () => {
-    const schema = buildInsertSchema(invoiceEntity());
-    const result = schema.safeParse({
-      total: { amount: 30, currency: "EUR" },
-      lines: [{ amount: 1000 }, { amount: 2000 }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("rejects when the sum diverges from the sibling total, issue path is the embedded field name", () => {
-    const schema = buildInsertSchema(invoiceEntity());
-    const result = schema.safeParse({
-      total: { amount: 30, currency: "EUR" },
-      lines: [{ amount: 1000 }, { amount: 1500 }],
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.issues.some((issue) => issue.path.join(".") === "lines")).toBe(true);
-    }
-  });
-
-  test("update payload omitting the embedded list is rejected (totalsMatch pair incomplete)", () => {
-    const schema = buildUpdateSchema(invoiceEntity());
-    expect(schema.safeParse({ total: { amount: 30, currency: "EUR" } }).success).toBe(false);
-  });
-
-  // kumiko-framework#1972: a round total (30 EUR = 3000 minor) still passes
-  // even if the major/minor conversion is silently skipped, because 30 and
-  // 3000 both "look" plausible under either interpretation. A crooked
-  // amount catches that a round-number fixture wouldn't.
-  test("accepts a crooked total (1234.56 EUR) whose minor-unit line sum matches exactly", () => {
-    const schema = buildInsertSchema(invoiceEntity());
-    const result = schema.safeParse({
-      total: { amount: 1234.56, currency: "EUR" },
-      lines: [{ amount: 100000 }, { amount: 23456 }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  // The exact shape of the reported solon incident: a genuinely wrong total
-  // (100.00 EUR entered as if it were already minor units, i.e. 1.00 EUR)
-  // must still be rejected — proves the refinement doesn't silently pass a
-  // mismatch through by accident.
-  test("rejects a total that was itself entered/scaled wrong (100x too small)", () => {
-    const schema = buildInsertSchema(invoiceEntity());
-    const result = schema.safeParse({
-      total: { amount: 1, currency: "EUR" }, // should have been 100
-      lines: [{ amount: 10000 }], // 100.00 EUR
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.issues.some((issue) => issue.path.join(".") === "lines")).toBe(true);
-    }
-  });
-
-  test("update payload omitting the sibling total is rejected (totalsMatch pair incomplete)", () => {
-    const schema = buildUpdateSchema(invoiceEntity());
-    expect(schema.safeParse({ lines: [{ amount: 1000 }, { amount: 1500 }] }).success).toBe(false);
-  });
-
-  test("rejects a sibling total tagged with a currency other than the entity's default, even when the raw minor-unit amounts match", () => {
-    const schema = buildInsertSchema(invoiceEntity());
-    const result = schema.safeParse({
-      total: { amount: 30, currency: "USD" },
-      lines: [{ amount: 1000 }, { amount: 2000 }],
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.issues.some((issue) => issue.path.join(".") === "total")).toBe(true);
-    }
-  });
-});
-
-// --- kumiko-framework#1837: derived-cell server-side recomputation — the
-// server is the authority for derived cells, a client value is overwritten
-// with the recomputed one instead of merely checked against it. ---
-
-describe("embedded-list derived cell recomputation (kumiko-framework#1837)", () => {
-  function orderEntity() {
-    return createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "number", required: true },
-            price: { type: "number", required: true },
-            amount: { type: "number", required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-  }
-
-  test("a matching client-sent derived cell parses through unchanged", () => {
-    const schema = buildInsertSchema(orderEntity());
-    const result = schema.safeParse({ lines: [{ qty: 3, price: 10, amount: 30 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["lines"]).toEqual([{ qty: 3, price: 10, amount: 30 }]);
-    }
-  });
-
-  test("a diverging client-sent derived cell is overwritten with the server-computed value, not rejected", () => {
-    const schema = buildInsertSchema(orderEntity());
-    const result = schema.safeParse({ lines: [{ qty: 3, price: 10, amount: 99 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["lines"]).toEqual([{ qty: 3, price: 10, amount: 30 }]);
-    }
-  });
-
-  test("a derived cell omitted from the payload is filled in server-side", () => {
-    const schema = buildInsertSchema(orderEntity());
-    const result = schema.safeParse({ lines: [{ qty: 3, price: 10 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["lines"]).toEqual([{ qty: 3, price: 10, amount: 30 }]);
-    }
-  });
-
-  test("a missing source for a multiply-derived cell leaves the cell unset rather than 0", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "number", required: true },
-            price: { type: "number", required: false },
-            amount: { type: "number", required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ lines: [{ qty: 3, amount: 30 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row).toBeDefined();
-      expect(Object.hasOwn(row as Record<string, unknown>, "amount")).toBe(false);
-    }
-  });
-
-  test("an embedded-list field without `derived` leaves a client-sent value untouched", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField({
-          qty: { type: "number", required: true },
-          amount: { type: "number", required: false },
-        }),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ lines: [{ qty: 3, amount: 999 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["lines"]).toEqual([{ qty: 3, amount: 999 }]);
-    }
-  });
-
-  // --- kumiko-framework#1852: a fractional product on a money/decimal
-  // target isn't representable by the target sub-field's strict
-  // integer/scale validation — round to the target's declared precision
-  // before it's written back, instead of rejecting the whole row. ---
-
-  test("a fractional product on a money target is rounded to whole minor units (kaufmännisch)", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "decimal", scale: 2, required: true },
-            price: { type: "money", required: true },
-            amount: { type: "money", required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    // 12.34 * 187 = 2307.58 minor units — not representable by money's
-    // integer constraint. Rounds up (half-away-from-zero would round .58
-    // to .0 anyway, this just isn't a half-step case).
-    const result = schema.safeParse({ lines: [{ qty: 12.34, price: 187 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["amount"]).toBe(2308);
-    }
-  });
-
-  test("a negative product exactly on a half-step rounds away from zero, not toward it", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "decimal", scale: 1, required: true },
-            price: { type: "money", required: true },
-            amount: { type: "money", required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    // 2.5 * -923 = -2307.5 exactly. `Math.round(-2307.5)` alone would give
-    // -2307 (rounds toward zero for negative .5); half-away-from-zero must
-    // give -2308.
-    const result = schema.safeParse({ lines: [{ qty: 2.5, price: -923 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["amount"]).toBe(-2308);
-    }
-  });
-
-  test("a decimal target rounds correctly through the classic float half-step trap", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "decimal", scale: 3, required: true },
-            price: { type: "number", required: true },
-            amount: { type: "decimal", scale: 2, required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    // 1.005 * 1 === 1.005 as a JS number, but 1.005 * 100 is actually
-    // 100.49999999999999 in float — naive Math.round would floor this to
-    // 1.00 instead of the mathematically-correct 1.01.
-    const result = schema.safeParse({ lines: [{ qty: 1.005, price: 1 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["amount"]).toBe(1.01);
-    }
-  });
-
-  test("totalsMatch validates against the rounded derived values, not the raw fractional products", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        total: createMoneyField({ required: true }),
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "decimal", scale: 1, required: true },
-            price: { type: "money", required: true },
-            amount: { type: "money", required: false },
-          },
-          {
-            derived: { amount: { op: "multiply", from: ["qty", "price"] } },
-            totalsMatch: { amount: "total" },
-          },
-        ),
-      },
-      defaultCurrency: "EUR",
-    });
-    const schema = buildInsertSchema(entity);
-    // Each row's raw product is x.5 and rounds up by 1 minor unit: row 1 =
-    // 2.5 * 923 = 2307.5 -> 2308; row 2 = 3.5 * 100 = 350.0 -> 350 exactly.
-    // Sibling total must equal the sum of the ROUNDED amounts (26.58 EUR),
-    // not the sum of the raw fractional products.
-    const result = schema.safeParse({
-      total: { amount: 26.58, currency: "EUR" },
-      lines: [
-        { qty: 2.5, price: 923 },
-        { qty: 3.5, price: 100 },
-      ],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("a number-typed derived cell is left unrounded (unit-agnostic pass-through)", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            qty: { type: "number", required: true },
-            price: { type: "number", required: true },
-            amount: { type: "number", required: false },
-          },
-          { derived: { amount: { op: "multiply", from: ["qty", "price"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    const result = schema.safeParse({ lines: [{ qty: 1.5, price: 2 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["amount"]).toBe(3);
-    }
-  });
-
-  test("a sum of scale-3 sources on a scale-2 decimal target is rounded, not rejected as over-scale", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            a: { type: "decimal", scale: 3, required: true },
-            b: { type: "decimal", scale: 3, required: true },
-            c: { type: "decimal", scale: 3, required: true },
-            total: { type: "decimal", scale: 2, required: false },
-          },
-          { derived: { total: { op: "sum", from: ["a", "b", "c"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    // Each source is in-scale for its own scale-3 field, but the sum
-    // (0.333) has 3 decimal digits — over-scale for the scale-2 target
-    // without the rounding from #1867 (roundDerivedCellValue).
-    const result = schema.safeParse({ lines: [{ a: 0.111, b: 0.111, c: 0.111 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["total"]).toBe(0.33);
-    }
-  });
-
-  test("a subtract landing on a money target rounds to whole minor units", () => {
-    const entity = createEntity({
-      table: "Orders",
-      fields: {
-        lines: createEmbeddedListField(
-          {
-            gross: { type: "decimal", scale: 2, required: true },
-            refund: { type: "decimal", scale: 2, required: true },
-            total: { type: "money", required: false },
-          },
-          { derived: { total: { op: "subtract", from: ["gross", "refund"] } } },
-        ),
-      },
-    });
-    const schema = buildInsertSchema(entity);
-    // 2400.58 - 93 = 2307.58 major units — not representable by money's
-    // integer minor-unit constraint without rounding (#1867).
-    const result = schema.safeParse({ lines: [{ gross: 2400.58, refund: 93 }] });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const row = (result.data["lines"] as readonly Record<string, unknown>[])[0];
-      expect(row?.["total"]).toBe(2308);
-    }
-  });
-});
-
-// --- Update schema (all partial) ---
-
-describe("buildUpdateSchema", () => {
-  test("all fields are optional", () => {
-    const entity = createEntity({
-      table: "Users",
-      fields: {
-        email: createTextField({
-          required: true,
-          format: "email",
-          personal: false,
-          reason: "test_fixture",
-        }),
-        firstName: createTextField({ personal: false, reason: "test_fixture" }),
-        isEnabled: createBooleanField(),
-      },
-    });
-
-    const schema = buildUpdateSchema(entity);
-
-    // Empty update is valid
-    expect(schema.safeParse({}).success).toBe(true);
-
-    // Partial update is valid
-    expect(schema.safeParse({ firstName: "Marc" }).success).toBe(true);
-
-    // Still validates types
-    expect(schema.safeParse({ isEnabled: "nope" }).success).toBe(false);
-  });
-
-  test("still validates format on provided fields", () => {
-    const entity = createEntity({
-      table: "Users",
-      fields: {
-        email: createTextField({
-          required: true,
-          format: "email",
-          personal: false,
-          reason: "test_fixture",
-        }),
-      },
-    });
-
-    const schema = buildUpdateSchema(entity);
-
-    expect(schema.safeParse({ email: "valid@test.de" }).success).toBe(true);
-    expect(schema.safeParse({ email: "not-email" }).success).toBe(false);
-  });
-
-  // #1674: clearing a previously-set optional select back to "unset" must
-  // work through the update path too — "" from an untouched <select> maps to
-  // an explicit `null`, not `undefined` (which would be dropped from the
-  // changes payload and silently no-op instead of clearing).
-  test("optional select accepts empty string as an explicit clear-to-null", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { locale: createSelectField({ options: ["de", "en"] as const }) },
-    });
-
-    const schema = buildUpdateSchema(entity);
-    const result = schema.safeParse({ locale: "" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBeNull();
-    }
-  });
-
-  test("omitting an optional select on update leaves it untouched", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: { locale: createSelectField({ options: ["de", "en"] as const }) },
-    });
-
-    const schema = buildUpdateSchema(entity);
-    const result = schema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(Object.hasOwn(result.data, "locale")).toBe(false);
-    }
-  });
-
-  // fw#1703: buildUpdateSchema never applies defaults for an OMITTED field —
-  // omitting a field must leave it untouched. But an explicit `""` from an
-  // untouched <select> is a submission, not an omission, and "a field with a
-  // default is never unset" (same invariant the insert path documents at
-  // #1702) — so "" must map to the field's default on update too, not clobber
-  // an existing value to null.
-  test("optional select with default on update: empty string falls back to the default", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en"] as const, default: "de" }),
-      },
-    });
-
-    const schema = buildUpdateSchema(entity);
-    const result = schema.safeParse({ locale: "" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBe("de");
-    }
-  });
-
-  test("optional select with default on update: omitting the field leaves it untouched", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({ options: ["de", "en"] as const, default: "de" }),
-      },
-    });
-
-    const schema = buildUpdateSchema(entity);
-    const result = schema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(Object.hasOwn(result.data, "locale")).toBe(false);
-    }
-  });
-
-  test("required select with default on update: empty string falls back to the default instead of a required-error", () => {
-    const entity = createEntity({
-      table: "Test",
-      fields: {
-        locale: createSelectField({
-          options: ["de", "en"] as const,
-          default: "de",
-          required: true,
-        }),
-      },
-    });
-
-    const schema = buildUpdateSchema(entity);
-    const result = schema.safeParse({ locale: "" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data["locale"]).toBe("de");
-    }
-  });
-});