@cosmicdrift/kumiko-renderer 0.328.0 → 0.328.1

package/src/app/__tests__/feature-schema.test.ts

@@ -1,40 +0,0 @@
-// toAppSchema normalisiert FeatureSchema → AppSchema (idempotent),
-// isAppSchema diskriminiert die beiden Formen. Zero source-change.
-
-import { describe, expect, test } from "bun:test";
-import type { AppSchema, FeatureSchema } from "@cosmicdrift/kumiko-framework/ui-types";
-import { isAppSchema, toAppSchema } from "../feature-schema";
-
-const feature: FeatureSchema = { featureName: "tasks", entities: {}, screens: [] };
-
-describe("toAppSchema", () => {
-  test("wraps a FeatureSchema into the AppSchema envelope", () => {
-    const app = toAppSchema(feature);
-    expect(app.features).toHaveLength(1);
-    expect(app.features[0]?.featureName).toBe("tasks");
-    expect(app.workspaces).toBeUndefined();
-  });
-
-  test("idempotent for AppSchema input (returns the same reference)", () => {
-    const app: AppSchema = { features: [feature] };
-    expect(toAppSchema(app)).toBe(app);
-  });
-});
-
-describe("isAppSchema", () => {
-  test("true for AppSchema (has 'features'), false for FeatureSchema", () => {
-    expect(isAppSchema({ features: [feature] })).toBe(true);
-    expect(isAppSchema(feature)).toBe(false);
-  });
-});
-
-describe("toAppSchema — workspaces-Hoist (Legacy-Form)", () => {
-  test("hebt feature-lokale workspaces auf App-Ebene und entfernt sie vom Feature", () => {
-    const ws = [{ definition: { id: "admin", label: "Admin", navs: [] }, navMembers: [] }];
-    const withWs: FeatureSchema = { ...feature, workspaces: ws };
-    const app = toAppSchema(withWs);
-    expect(app.workspaces).toEqual(ws);
-    expect(app.features[0]).not.toHaveProperty("workspaces");
-    expect(app.features[0]?.featureName).toBe("tasks");
-  });
-});

package/src/app/__tests__/form-schema.test.ts

@@ -1,247 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  EditFieldSpec,
-  EntityDefinition,
-  EntityEditScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import { createFormController } from "@cosmicdrift/kumiko-headless";
-import { buildFormSchema, REQUIRED_FIELD_I18N_KEY } from "../form-schema";
-
-function screenWith(fields: readonly EditFieldSpec[]): EntityEditScreenDefinition {
-  return {
-    id: "s",
-    type: "entityEdit",
-    entity: "e",
-    layout: { sections: [{ fields }] },
-  };
-}
-
-function entityWith(fields: EntityDefinition["fields"]): EntityDefinition {
-  return { fields } as EntityDefinition;
-}
-
-describe("buildFormSchema", () => {
-  describe("required field missing → issue on that field", () => {
-    const entity = entityWith({ name: { type: "text", required: true } });
-    const screen = screenWith(["name"]);
-
-    for (const [label, value] of [
-      ['""', ""],
-      ["null", null],
-      ["undefined", undefined],
-      ["[]", [] as unknown[]],
-    ] as const) {
-      test(label, () => {
-        const result = buildFormSchema(entity, screen).safeParse({ name: value });
-        expect(result.success).toBe(false);
-        if (result.success) return;
-        expect(result.error.issues).toHaveLength(1);
-        expect(result.error.issues[0]?.path).toEqual(["name"]);
-      });
-    }
-  });
-
-  test("required field inside a groups-only section → presence issue", () => {
-    const entity = entityWith({ name: { type: "text", required: true } });
-    const screen: EntityEditScreenDefinition = {
-      id: "s",
-      type: "entityEdit",
-      entity: "e",
-      layout: { sections: [{ fields: [], groups: [{ title: "g", fields: ["name"] }] }] },
-    };
-
-    const result = buildFormSchema(entity, screen).safeParse({ name: "" });
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    expect(result.error.issues[0]?.path).toEqual(["name"]);
-  });
-
-  test("required field missing → issue carries the required-field i18nKey override", () => {
-    const entity = entityWith({ name: { type: "text", required: true } });
-    const screen = screenWith(["name"]);
-
-    const result = buildFormSchema(entity, screen).safeParse({ name: "" });
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    const issue = result.error.issues[0];
-    if (issue?.code !== "custom") throw new Error("expected a custom issue");
-    expect(issue.params).toMatchObject({ i18nKey: REQUIRED_FIELD_I18N_KEY });
-  });
-
-  // The seam the bug actually lived in — a schema built here only round-trips
-  // through createFormController's validate(), which is what feeds
-  // FormSnapshot.errors that render-edit.tsx passes to RenderField. A unit
-  // test on buildFormSchema() alone can't catch a break in that hand-off
-  // (e.g. zodErrorToFieldIssues not honoring the override).
-  test("end-to-end via createFormController: required field left empty → snapshot error carries kumiko.validation.required", () => {
-    const entity = entityWith({ name: { type: "text", required: true } });
-    const screen = screenWith(["name"]);
-
-    const form = createFormController({
-      initial: { name: "" },
-      schema: buildFormSchema(entity, screen),
-    });
-
-    expect(form.validate()).toBe(false);
-    const fieldErrors = form.getSnapshot().errors["name"];
-    expect(fieldErrors?.[0]?.i18nKey).toBe(REQUIRED_FIELD_I18N_KEY);
-  });
-
-  describe("required field present → no issue", () => {
-    const entity = entityWith({ name: { type: "number", required: true } });
-    const screen = screenWith(["name"]);
-
-    for (const [label, value] of [
-      ["0", 0],
-      ["false", false],
-      ['"Ada"', "Ada"],
-    ] as const) {
-      test(label, () => {
-        const result = buildFormSchema(entity, screen).safeParse({ name: value });
-        expect(result.success).toBe(true);
-      });
-    }
-  });
-
-  test("optional field left empty → no issue", () => {
-    const entity = entityWith({ name: { type: "text", required: false } });
-    const screen = screenWith(["name"]);
-    expect(buildFormSchema(entity, screen).safeParse({ name: "" }).success).toBe(true);
-  });
-
-  test("required field not rendered by the layout → no issue", () => {
-    const entity = entityWith({
-      name: { type: "text", required: true },
-      hidden: { type: "text", required: true },
-    });
-    const screen = screenWith(["name"]);
-    const result = buildFormSchema(entity, screen).safeParse({ name: "Ada", hidden: "" });
-    expect(result.success).toBe(true);
-  });
-
-  test("required multiSelect, empty array → issue on that field (#1925: has a combobox widget now)", () => {
-    const entity = entityWith({
-      tags: { type: "multiSelect", required: true, options: ["a", "b"] },
-    });
-    const screen = screenWith(["tags"]);
-    const result = buildFormSchema(entity, screen).safeParse({ tags: [] });
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    expect(result.error.issues).toHaveLength(1);
-    expect(result.error.issues[0]?.path).toEqual(["tags"]);
-  });
-
-  test("required multiSelect, non-empty array → no issue", () => {
-    const entity = entityWith({
-      tags: { type: "multiSelect", required: true, options: ["a", "b"] },
-    });
-    const screen = screenWith(["tags"]);
-    expect(buildFormSchema(entity, screen).safeParse({ tags: ["a"] }).success).toBe(true);
-  });
-
-  test("jsonb field → no issue (no editable widget on the auto-wired path)", () => {
-    const entity = entityWith({ data: { type: "jsonb" } });
-    const screen = screenWith(["data"]);
-    expect(buildFormSchema(entity, screen).safeParse({ data: undefined }).success).toBe(true);
-  });
-
-  test("required embedded field → no issue (no editable widget on the auto-wired path)", () => {
-    const entity = entityWith({
-      lines: { type: "embedded", required: true, schema: {} },
-    });
-    const screen = screenWith(["lines"]);
-    expect(buildFormSchema(entity, screen).safeParse({ lines: undefined }).success).toBe(true);
-  });
-
-  test("required embedded list field → issue when missing (has EmbeddedListField widget)", () => {
-    const entity = entityWith({
-      lines: { type: "embedded", multiple: true, required: true, schema: {} },
-    });
-    const screen = screenWith(["lines"]);
-    const result = buildFormSchema(entity, screen).safeParse({ lines: undefined });
-    expect(result.success).toBe(false);
-  });
-
-  test("required files field → no issue (#1925: no multi-upload widget yet, deliberately deferred)", () => {
-    const entity = entityWith({ attachments: { type: "files" } });
-    const screen = screenWith([{ field: "attachments", required: true }]);
-    expect(buildFormSchema(entity, screen).safeParse({ attachments: undefined }).success).toBe(
-      true,
-    );
-  });
-
-  test("required images field → no issue (#1925: no multi-upload widget yet, deliberately deferred)", () => {
-    const entity = entityWith({ gallery: { type: "images" } });
-    const screen = screenWith([{ field: "gallery", required: true }]);
-    expect(buildFormSchema(entity, screen).safeParse({ gallery: undefined }).success).toBe(true);
-  });
-
-  test("required money — bare number (create-form representation) → no issue", () => {
-    const entity = entityWith({ price: { type: "money", required: true } });
-    const screen = screenWith(["price"]);
-    expect(buildFormSchema(entity, screen).safeParse({ price: 1000 }).success).toBe(true);
-  });
-
-  test("required money — {amount,currency} (update-form representation) → no issue", () => {
-    const entity = entityWith({ price: { type: "money", required: true } });
-    const screen = screenWith(["price"]);
-    const result = buildFormSchema(entity, screen).safeParse({
-      price: { amount: 10, currency: "EUR" },
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("required money — undefined → issue on that field (has a widget)", () => {
-    const entity = entityWith({ price: { type: "money", required: true } });
-    const screen = screenWith(["price"]);
-    const result = buildFormSchema(entity, screen).safeParse({ price: undefined });
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    expect(result.error.issues).toHaveLength(1);
-    expect(result.error.issues[0]?.path).toEqual(["price"]);
-  });
-
-  describe("screen-spec required/readOnly override the entity default", () => {
-    test("spec required:false on an entity-required field, left empty → no issue", () => {
-      const entity = entityWith({ x: { type: "text", required: true } });
-      const screen = screenWith([{ field: "x", required: false }]);
-      expect(buildFormSchema(entity, screen).safeParse({ x: "" }).success).toBe(true);
-    });
-
-    test("spec required:true on an entity-optional field, left empty → issue on that field", () => {
-      const entity = entityWith({ x: { type: "text", required: false } });
-      const screen = screenWith([{ field: "x", required: true }]);
-      const result = buildFormSchema(entity, screen).safeParse({ x: "" });
-      expect(result.success).toBe(false);
-      if (result.success) return;
-      expect(result.error.issues).toHaveLength(1);
-      expect(result.error.issues[0]?.path).toEqual(["x"]);
-    });
-
-    test("readOnly field, entity-required and left empty → no issue (unresolvable by the user)", () => {
-      const entity = entityWith({ x: { type: "text", required: true } });
-      const screen = screenWith([{ field: "x", readOnly: true }]);
-      expect(buildFormSchema(entity, screen).safeParse({ x: "" }).success).toBe(true);
-    });
-
-    test("conditional required, entity-optional field", () => {
-      const entity = entityWith({
-        kind: { type: "text", required: false },
-        x: { type: "text", required: false },
-      });
-      const screen = screenWith([
-        "kind",
-        { field: "x", required: { field: "kind", eq: "business" } },
-      ]);
-
-      const notTriggered = buildFormSchema(entity, screen).safeParse({ kind: "private", x: "" });
-      expect(notTriggered.success).toBe(true);
-
-      const triggered = buildFormSchema(entity, screen).safeParse({ kind: "business", x: "" });
-      expect(triggered.success).toBe(false);
-      if (triggered.success) return;
-      expect(triggered.error.issues).toHaveLength(1);
-      expect(triggered.error.issues[0]?.path).toEqual(["x"]);
-    });
-  });
-});

package/src/app/__tests__/list-daterange-facet.test.ts

@@ -1,165 +0,0 @@
-// fw#3104: a dateRange facet turns two calendar dates into the two query
-// params it declares. The conversion is the whole risk surface — a calendar
-// date has no time, `createdAt` is an instant, and "to the 14th" has to mean
-// "through the end of the 14th" in the viewer's zone, not "at 00:00".
-
-import { describe, expect, test } from "bun:test";
-import type { ListFacetSpec } from "@cosmicdrift/kumiko-framework/ui-types";
-import { Temporal } from "temporal-polyfill";
-import {
-  buildDateRangePayload,
-  clampDateRange,
-  readDateRange,
-  resolveDateRangeFacets,
-  resolveProjectionFacetSpecs,
-} from "../list-facets";
-
-const VIENNA = "Europe/Vienna";
-
-const auditFacets: readonly ListFacetSpec[] = [
-  {
-    type: "dateRange",
-    field: "createdAt",
-    label: "audit.log.col.when",
-    params: { from: "from", to: "to" },
-  },
-];
-
-const specs = resolveDateRangeFacets(auditFacets, (key) => key);
-
-function payload(
-  filters: Record<string, readonly string[]>,
-  timeZone = VIENNA,
-): Record<string, string> {
-  return buildDateRangePayload(specs, filters, timeZone);
-}
-
-describe("dateRange facet resolution", () => {
-  test("resolves the declared param names, not a from/to convention", () => {
-    const resolved = resolveDateRangeFacets(
-      [
-        {
-          type: "dateRange",
-          field: "occurredAt",
-          label: "when",
-          params: { from: "since", to: "until" },
-        },
-      ],
-      (key) => key,
-    );
-    expect(resolved).toEqual([
-      { field: "occurredAt", label: "when", fromParam: "since", toParam: "until" },
-    ]);
-  });
-
-  test("stays out of the option-dropdown facets (no `filters` entry)", () => {
-    expect(resolveProjectionFacetSpecs(auditFacets, (key) => key, "audit")).toEqual([]);
-  });
-
-  test("reads both bounds out of the shared f.<field> URL namespace", () => {
-    expect(
-      readDateRange(
-        { "createdAt.from": ["2020-06-10"], "createdAt.to": ["2020-06-14"] },
-        "createdAt",
-      ),
-    ).toEqual({ from: "2020-06-10", to: "2020-06-14" });
-    expect(readDateRange({}, "createdAt")).toEqual({ from: "", to: "" });
-  });
-});
-
-describe("dateRange facet → query params", () => {
-  test("both bounds travel under the declared param names", () => {
-    expect(payload({ "createdAt.from": ["2020-06-10"], "createdAt.to": ["2020-06-14"] })).toEqual({
-      from: "2020-06-09T22:00:00Z",
-      to: "2020-06-14T21:59:59.999999999Z",
-    });
-  });
-
-  test("open interval: only `from` set sends only that param", () => {
-    expect(payload({ "createdAt.from": ["2020-06-10"] })).toEqual({ from: "2020-06-09T22:00:00Z" });
-  });
-
-  test("open interval: only `to` set sends only that param", () => {
-    expect(payload({ "createdAt.to": ["2020-06-14"] })).toEqual({
-      to: "2020-06-14T21:59:59.999999999Z",
-    });
-  });
-
-  test("no bounds set sends nothing", () => {
-    expect(payload({})).toEqual({});
-  });
-
-  test("a half-typed or hand-crafted URL value is dropped, not sent", () => {
-    expect(payload({ "createdAt.from": ["2020-06"], "createdAt.to": ["nonsense"] })).toEqual({});
-  });
-
-  test("bounds follow the viewer's zone", () => {
-    expect(payload({ "createdAt.from": ["2020-06-10"] }, "UTC")).toEqual({
-      from: "2020-06-10T00:00:00Z",
-    });
-  });
-
-  test("DST: the day the clock jumps forward is still bounded by its own edges", () => {
-    // 2020-03-29 is 23h long in Vienna — a naive +24h end-of-day would spill
-    // an hour into the 30th.
-    expect(payload({ "createdAt.from": ["2020-03-29"], "createdAt.to": ["2020-03-29"] })).toEqual({
-      from: "2020-03-28T23:00:00Z",
-      to: "2020-03-29T21:59:59.999999999Z",
-    });
-  });
-});
-
-describe("dateRange facet timezone edge (issue #3104)", () => {
-  test("an event at 23:59 of the `to` day falls inside the range", () => {
-    const { from, to } = payload({
-      "createdAt.from": ["2020-06-14"],
-      "createdAt.to": ["2020-06-14"],
-    });
-    if (from === undefined || to === undefined) throw new Error("expected both bounds");
-    const lateEvent = Temporal.ZonedDateTime.from(`2020-06-14T23:59:00[${VIENNA}]`).toInstant();
-    expect(Temporal.Instant.compare(lateEvent, Temporal.Instant.from(from))).toBeGreaterThan(0);
-    // The handler filters with `lte`, so the last instant of the day counts.
-    expect(Temporal.Instant.compare(lateEvent, Temporal.Instant.from(to))).toBeLessThanOrEqual(0);
-  });
-
-  test("the next day's first moment falls outside", () => {
-    const { to } = payload({ "createdAt.to": ["2020-06-14"] });
-    if (to === undefined) throw new Error("expected a `to` bound");
-    const nextDay = Temporal.ZonedDateTime.from(`2020-06-15T00:00:00[${VIENNA}]`).toInstant();
-    expect(Temporal.Instant.compare(nextDay, Temporal.Instant.from(to))).toBeGreaterThan(0);
-  });
-});
-
-describe("clampDateRange keeps from <= to", () => {
-  test("a `from` past the current `to` pushes `to` along", () => {
-    expect(clampDateRange({ from: "2020-06-01", to: "2020-06-10" }, "from", "2020-06-20")).toEqual({
-      from: "2020-06-20",
-      to: "2020-06-20",
-    });
-  });
-
-  test("a `to` before the current `from` pulls `from` along", () => {
-    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "to", "2020-06-01")).toEqual({
-      from: "2020-06-01",
-      to: "2020-06-01",
-    });
-  });
-
-  test("a valid bound leaves the other alone", () => {
-    expect(clampDateRange({ from: "2020-06-01", to: "2020-06-20" }, "from", "2020-06-05")).toEqual({
-      from: "2020-06-05",
-      to: "2020-06-20",
-    });
-  });
-
-  test("clearing a bound never drags the other one with it", () => {
-    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "from", "")).toEqual({
-      from: "",
-      to: "2020-06-20",
-    });
-    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "to", "")).toEqual({
-      from: "2020-06-10",
-      to: "",
-    });
-  });
-});