@cosmicdrift/kumiko-renderer 0.290.0 → 0.292.0

package/src/app/__tests__/return-to.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import type { ScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { FeatureSchema } from "../feature-schema";
-import { resolveReturnTarget, returnToParams } from "../return-to";
+import { formatReturnTo, resolveReturnTarget, returnToParams, splitReturnTo } from "../return-to";
 
 function schemaWith(featureName: string, screens: readonly ScreenDefinition[]): FeatureSchema {
   return { featureName, entities: {}, screens };
@@ -156,12 +156,37 @@ describe("resolveReturnTarget", () => {
     ).toBeUndefined();
   });
 
-  test("rejects entityId with '?'", () => {
+  test("rejects an entityId whose decoded form carries '?'", () => {
     expect(
-      resolveReturnTarget("token-edit/abc?x=1", "token-create", features, undefined),
+      resolveReturnTarget("token-edit/abc%3Fx=1", "token-create", features, undefined),
     ).toBeUndefined();
   });
 
+  test("a trailing host-state query resolves to the bare target", () => {
+    expect(
+      resolveReturnTarget("token-edit/abc?tab=keys", "token-create", features, undefined),
+    ).toEqual({ screenId: "token-edit", entityId: "abc" });
+  });
+
+  test("a host-state query does not loosen validation", () => {
+    expect(
+      resolveReturnTarget("https://evil.com?tab=keys", "token-create", features, undefined),
+    ).toBeUndefined();
+    expect(
+      resolveReturnTarget("//evil.com?tab=keys", "token-create", features, undefined),
+    ).toBeUndefined();
+    expect(
+      resolveReturnTarget("token-edit/..?tab=keys", "token-create", features, undefined),
+    ).toBeUndefined();
+    expect(
+      resolveReturnTarget("unknown-screen?tab=keys", "token-create", features, undefined),
+    ).toBeUndefined();
+    expect(
+      resolveReturnTarget("admin-only?tab=keys", "token-create", features, undefined),
+    ).toBeUndefined();
+    expect(resolveReturnTarget("?tab=keys", "token-create", features, undefined)).toBeUndefined();
+  });
+
   test("rejects entityId with '#'", () => {
     expect(
       resolveReturnTarget("token-edit/abc#frag", "token-create", features, undefined),
@@ -253,3 +278,61 @@ describe("returnToParams", () => {
     ).toEqual({ returnTo: "token-edit/abc" });
   });
 });
+
+describe("formatReturnTo / splitReturnTo", () => {
+  test("no host params formats exactly like before the snapshot existed", () => {
+    expect(formatReturnTo({ screenId: "token-list" })).toBe("token-list");
+    expect(formatReturnTo({ screenId: "token-list" }, {})).toBe("token-list");
+    expect(formatReturnTo({ screenId: "token-edit", entityId: "abc" })).toBe("token-edit/abc");
+  });
+
+  test("host params round-trip through the value", () => {
+    const raw = formatReturnTo(
+      { screenId: "token-detail", entityId: "abc" },
+      { tab: "keys", "orders.sort": "name", "orders.dir": "asc" },
+    );
+    expect(splitReturnTo(raw)).toEqual({
+      path: "token-detail/abc",
+      state: { tab: "keys", "orders.sort": "name", "orders.dir": "asc" },
+    });
+  });
+
+  test("empty param values are left out of the snapshot", () => {
+    expect(formatReturnTo({ screenId: "token-list" }, { q: "", tab: "keys" })).toBe(
+      "token-list?tab=keys",
+    );
+  });
+
+  test("two nesting levels round-trip one level per split", () => {
+    const inner = formatReturnTo({ screenId: "token-list" }, { returnTo: "settings" });
+    const outer = formatReturnTo({ screenId: "token-edit", entityId: "abc" }, { returnTo: inner });
+
+    const first = splitReturnTo(outer);
+    expect(first.path).toBe("token-edit/abc");
+    expect(first.state["returnTo"]).toBe("token-list?returnTo=settings");
+
+    const second = splitReturnTo(first.state["returnTo"] as string);
+    expect(second.path).toBe("token-list");
+    expect(second.state).toEqual({ returnTo: "settings" });
+  });
+
+  test("a fourth level is dropped, the rest of the snapshot survives", () => {
+    const level3 = formatReturnTo(
+      { screenId: "token-list" },
+      { returnTo: formatReturnTo({ screenId: "token-detail" }, { returnTo: "settings" }) },
+    );
+    const level4 = formatReturnTo({ screenId: "token-edit" }, { returnTo: level3, tab: "keys" });
+
+    expect(splitReturnTo(level4)).toEqual({ path: "token-edit", state: { tab: "keys" } });
+  });
+
+  test("an over-long snapshot degrades to the bare target", () => {
+    expect(formatReturnTo({ screenId: "token-list" }, { q: "x".repeat(600) })).toBe("token-list");
+  });
+
+  test("returnToParams carries the host snapshot", () => {
+    expect(
+      returnToParams({ screenId: "token-list" }, { screenId: "token-create" }, { tab: "keys" }),
+    ).toEqual({ returnTo: "token-list?tab=keys" });
+  });
+});

package/src/app/kumiko-screen.tsx

@@ -50,8 +50,9 @@ import { useDispatcher, useOptionalDispatcher } from "../context/dispatcher-cont
 import { useUserRoles } from "../context/user-roles-context";
 import { type ListSort, useListUrlState } from "../hooks/use-list-url-state";
 import { type UseQueryResult, useQuery } from "../hooks/use-query";
-import { useTranslation } from "../i18n";
+import { useOptionalTimeZone, useTranslation } from "../i18n";
 import {
+  type DataTableDateRangeFacet,
   type DataTableFacet,
   type DataTableRowAction,
   statusToneForValue,
@@ -66,10 +67,14 @@ import type { FeatureSchema } from "./feature-schema";
 import { buildFormSchema } from "./form-schema";
 import { layoutFieldNames } from "./layout-fields";
 import {
+  buildDateRangePayload,
   buildFilterFacets,
   buildFilterPayload,
+  clampDateRange,
   mergeReferenceFacetOptions,
   type ResolvedFacetSpec,
+  readDateRange,
+  resolveDateRangeFacets,
   resolveProjectionFacetSpecs,
 } from "./list-facets";
 import { type NavApi, type ScreenTarget, useInitialValuesHandoff, useNav } from "./nav";
@@ -82,6 +87,8 @@ import { lastSegment, toKebab } from "./qn";
 import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id";
 import { ReferenceFacetBridges, type ReferenceFacetOption } from "./reference-facet-bridge";
 import {
+  navigateToReturn,
+  navigateToReturnOr,
   navigateWithReturnTo,
   type ReturnHost,
   ReturnHostProvider,
@@ -99,7 +106,7 @@ import {
   runProjectionRowNavigate,
   stringifyNavParams,
 } from "./row-actions";
-import { findEditScreenFor, screenAccessAllows } from "./screen-access";
+import { findEditScreenFor, navigateTargetAllows, screenAccessAllows } from "./screen-access";
 import { SecretMintBody } from "./secret-mint-body";
 import { SecretsEditBody } from "./secrets-edit-body";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
@@ -487,6 +494,63 @@ function resolveTenantCurrency(
   return { status: "ready", currency: typeof raw === "string" && raw !== "" ? raw : fallback };
 }
 
+// An entity-less form screen has no `entity.defaultCurrency` to fall back on,
+// so a tenant-declared field whose config query errors or returns no value
+// lands here — same last resort as the entityEdit path's `?? "EUR"`.
+const ACTION_FORM_CURRENCY_FALLBACK = "EUR";
+
+// A money field naming a fixed ISO code (`currency: { kind: "literal", code }`,
+// fw#2839) resolves with no query at all. Read structurally, same idiom as
+// tenantCurrencyMoneyFieldNames above.
+export function literalCurrencyOverrides(
+  fields: Readonly<Record<string, unknown>>,
+): Readonly<Record<string, string>> {
+  const out: Record<string, string> = {};
+  for (const [name, def] of Object.entries(fields)) {
+    const shape = def as {
+      readonly type?: string;
+      readonly currency?: { readonly kind?: string; readonly code?: string };
+    };
+    const code = shape.currency?.code;
+    if (shape.type === "money" && shape.currency?.kind === "literal" && code !== undefined) {
+      out[name] = code;
+    }
+  }
+  return out;
+}
+
+// Per-field currency for the money fields that declare their own source: a
+// literal code resolves synchronously (fw#2839), a `{ kind: "tenant" }` field
+// needs the tenant-settings config query and makes the caller hold the form
+// until it lands (fw#2933) — seeding the fallback meanwhile would render, and
+// on a fast click submit, the wrong currency. Callers pass the tenant field
+// names themselves because an edit form only needs the fetch for fields the
+// record has no stored value for.
+function useMoneyCurrencyOverrides(
+  fields: Readonly<Record<string, unknown>>,
+  tenantFieldNames: readonly string[],
+  fallback: string,
+): {
+  readonly overrides: Readonly<Record<string, string>> | undefined;
+  readonly loading: boolean;
+} {
+  const query = useQuery<TenantConfigValuesResponse>(
+    "config:query:values",
+    {},
+    { enabled: tenantFieldNames.length > 0 },
+  );
+  const resolution = resolveTenantCurrency(tenantFieldNames, query, fallback);
+  const resolvedTenantCurrency = resolution.status === "ready" ? resolution.currency : undefined;
+  const overrides = useMemo(() => {
+    const out: Record<string, string> = { ...literalCurrencyOverrides(fields) };
+    if (resolvedTenantCurrency !== undefined) {
+      for (const name of tenantFieldNames) out[name] = resolvedTenantCurrency;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+  }, [fields, tenantFieldNames, resolvedTenantCurrency]);
+  return { overrides, loading: resolution.status === "loading" };
+}
+
 function multiSelectOptionValues(shape: {
   readonly options?: readonly (string | { readonly value: string })[];
 }): ReadonlySet<string> | undefined {
@@ -857,26 +921,11 @@ function EntityEditCreateBody({
     () => tenantCurrencyMoneyFieldNames(entity.fields),
     [entity.fields],
   );
-  const needsTenantCurrency = tenantCurrencyFieldNames.length > 0;
-  const tenantCurrencyQuery = useQuery<TenantConfigValuesResponse>(
-    "config:query:values",
-    {},
-    { enabled: needsTenantCurrency },
-  );
-  const tenantCurrencyResolution = resolveTenantCurrency(
+  const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(
+    entity.fields,
     tenantCurrencyFieldNames,
-    tenantCurrencyQuery,
     entityDefaultCurrency,
   );
-  const resolvedTenantCurrency =
-    tenantCurrencyResolution.status === "ready" ? tenantCurrencyResolution.currency : undefined;
-  const moneyCurrencyOverrides = useMemo(
-    () =>
-      resolvedTenantCurrency !== undefined
-        ? Object.fromEntries(tenantCurrencyFieldNames.map((name) => [name, resolvedTenantCurrency]))
-        : undefined,
-    [tenantCurrencyFieldNames, resolvedTenantCurrency],
-  );
   const initial = useMemo(
     () =>
       mergeSearchParamsIntoInitial(entity.fields, {
@@ -900,7 +949,7 @@ function EntityEditCreateBody({
   const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "create");
   const navigateToList = useNavigateToListAfter(schema, screen.entity);
   const handleCancel = useCallback(
-    () => navigateToReturnTargetOr(nav, returnTarget, navigateToList),
+    () => navigateToReturnOr(nav, returnTarget, navigateToList),
     [nav, returnTarget, navigateToList],
   );
   // Create's write-handler success payload doesn't flatly expose a parent FK
@@ -916,7 +965,7 @@ function EntityEditCreateBody({
       const redirect = screen.redirect;
       if (redirect !== undefined) {
         if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
-          nav.navigate(returnTarget);
+          navigateToReturn(nav, returnTarget);
         } else if (typeof redirect === "string") {
           // String form unchanged: always carries the newly created
           // record's own id, regardless of the target screen's type. The
@@ -938,7 +987,7 @@ function EntityEditCreateBody({
           nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
         }
       } else {
-        navigateToReturnTargetOr(nav, returnTarget, navigateToList);
+        navigateToReturnOr(nav, returnTarget, navigateToList);
         onSaved?.();
       }
     },
@@ -946,7 +995,7 @@ function EntityEditCreateBody({
   );
   // Never seed a tenant-declared money field with entityDefaultCurrency while
   // its real tenant currency is still in flight (fw#2933) — wait instead.
-  if (needsTenantCurrency && tenantCurrencyResolution.status === "loading") {
+  if (currencyLoading) {
     return (
       <Banner padded variant="loading" testId="kumiko-screen-loading">
         Loading…
@@ -1109,26 +1158,11 @@ function EntityEditUpdateForm({
       ),
     [entity.fields, record],
   );
-  const needsTenantCurrency = tenantCurrencyFieldNames.length > 0;
-  const tenantCurrencyQuery = useQuery<TenantConfigValuesResponse>(
-    "config:query:values",
-    {},
-    { enabled: needsTenantCurrency },
-  );
-  const tenantCurrencyResolution = resolveTenantCurrency(
+  const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(
+    entity.fields,
     tenantCurrencyFieldNames,
-    tenantCurrencyQuery,
     entityDefaultCurrency,
   );
-  const resolvedTenantCurrency =
-    tenantCurrencyResolution.status === "ready" ? tenantCurrencyResolution.currency : undefined;
-  const moneyCurrencyOverrides = useMemo(
-    () =>
-      resolvedTenantCurrency !== undefined
-        ? Object.fromEntries(tenantCurrencyFieldNames.map((name) => [name, resolvedTenantCurrency]))
-        : undefined,
-    [tenantCurrencyFieldNames, resolvedTenantCurrency],
-  );
   const initial = useMemo(() => {
     const out: Record<string, unknown> = {};
     for (const name of Object.keys(entity.fields)) {
@@ -1311,7 +1345,7 @@ function EntityEditUpdateForm({
       const redirect = screen.redirect;
       if (redirect !== undefined) {
         if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
-          nav.navigate(returnTarget);
+          navigateToReturn(nav, returnTarget);
         } else if (typeof redirect === "string") {
           // String form unchanged: navigates without an entityId, same as
           // before the object form existed. The object form resolves like
@@ -1334,14 +1368,14 @@ function EntityEditUpdateForm({
           });
         }
       } else {
-        navigateToReturnTargetOr(nav, returnTarget, navigateToList);
+        navigateToReturnOr(nav, returnTarget, navigateToList);
         onSaved?.();
       }
     },
     [nav, screen.redirect, schema, appFeatures, record, navigateToList, onSaved, returnTarget],
   );
   const handleCancel = useCallback(
-    () => navigateToReturnTargetOr(nav, returnTarget, navigateToList),
+    () => navigateToReturnOr(nav, returnTarget, navigateToList),
     [nav, returnTarget, navigateToList],
   );
   const handleDelete = useCallback(async () => {
@@ -1349,7 +1383,7 @@ function EntityEditUpdateForm({
     if (res.isSuccess) {
       // Never return onto the just-deleted record.
       const target = returnTarget?.entityId !== entityId ? returnTarget : undefined;
-      navigateToReturnTargetOr(nav, target, navigateToList);
+      navigateToReturnOr(nav, target, navigateToList);
       onDeleted?.();
     }
   }, [dispatcher, deleteCommand, entityId, navigateToList, onDeleted, returnTarget, nav]);
@@ -1358,7 +1392,7 @@ function EntityEditUpdateForm({
   // its real tenant currency is still in flight (fw#2933) — wait instead. A
   // stored (non-empty) value is unaffected — it never reaches this branch's
   // fallback because `initial` above already prefers `record[name]`.
-  if (needsTenantCurrency && tenantCurrencyResolution.status === "loading") {
+  if (currencyLoading) {
     return (
       <Banner padded variant="loading" testId="kumiko-screen-loading">
         Loading…
@@ -2381,6 +2415,19 @@ function ProjectionListBody({
     [urlState.filters, facetSpecs],
   );
 
+  // dateRange facets (fw#3104) bypass `filters` entirely — their two bounds
+  // become the top-level query params the facet declares, resolved from a
+  // calendar date to an instant in the viewer's zone.
+  const timeZone = useOptionalTimeZone();
+  const dateRangeSpecs = useMemo(
+    () => resolveDateRangeFacets(screen.facets, effectiveTranslate),
+    [screen.facets, effectiveTranslate],
+  );
+  const dateRangePayload = useMemo(
+    () => buildDateRangePayload(dateRangeSpecs, urlState.filters, timeZone),
+    [dateRangeSpecs, urlState.filters, timeZone],
+  );
+
   const queryPayload = useMemo(() => {
     const payload = buildListQueryPayload({
       limit,
@@ -2401,6 +2448,7 @@ function ProjectionListBody({
     if (screen.facets !== undefined && filterPayload.length > 0) {
       payload["filters"] = filterPayload;
     }
+    Object.assign(payload, dateRangePayload);
     return payload;
   }, [
     limit,
@@ -2411,6 +2459,7 @@ function ProjectionListBody({
     screen.filter,
     screen.facets,
     filterPayload,
+    dateRangePayload,
   ]);
 
   const rowsQuery = useQuery<PagedRows>(screen.query, queryPayload, { live: true });
@@ -2419,6 +2468,24 @@ function ProjectionListBody({
     () => buildFilterFacets(resolvedFacetSpecs),
     [resolvedFacetSpecs],
   );
+  const dateRangeFacets = useMemo<DataTableDateRangeFacet[]>(
+    () =>
+      dateRangeSpecs.map((spec) => ({
+        field: spec.field,
+        label: spec.label,
+        ...readDateRange(urlState.filters, spec.field),
+      })),
+    [dateRangeSpecs, urlState.filters],
+  );
+  const handleDateRangeChange = useCallback(
+    (field: string, bound: "from" | "to", value: string) => {
+      urlState.setDateRange(
+        field,
+        clampDateRange(readDateRange(urlState.filters, field), bound, value),
+      );
+    },
+    [urlState.setDateRange, urlState.filters],
+  );
 
   // Entity-Targets (fw#2228) — see EntityListBody.runNavigate for why the
   // resolution happens in the NavApi impl. Unlike there: NO row["id"]
@@ -2554,8 +2621,14 @@ function ProjectionListBody({
         {...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick })}
         {...(filterFacets.length > 0 && {
           filterFacets,
-          filterValues: urlState.filters,
           onFilterChange: urlState.setFilter,
+        })}
+        {...(dateRangeFacets.length > 0 && {
+          dateRangeFacets,
+          onDateRangeChange: handleDateRangeChange,
+        })}
+        {...((filterFacets.length > 0 || dateRangeFacets.length > 0) && {
+          filterValues: urlState.filters,
           onFilterReset: urlState.clearFilters,
         })}
       />
@@ -3155,7 +3228,7 @@ function ProjectionDetailBody({
                 const testId = `kumiko-screen-projection-detail-metric-${field}`;
                 const navigate = metricNavigateSpec(metric);
                 const onPress =
-                  navigate !== undefined
+                  navigate !== undefined && navigateTargetAllows(navigate, appFeatures, userRoles)
                     ? () => runMetricNavigate(nav, navigate, record, host)
                     : undefined;
                 return Metric !== undefined ? (
@@ -3281,7 +3354,7 @@ function redirectTargetsRecord(
 }
 
 // Type-guard form narrows `returnTarget` for the caller's subsequent
-// nav.navigate(returnTarget) call.
+// navigateToReturn(nav, returnTarget) call.
 function returnToWinsOverRedirect(
   returnTarget: ScreenTarget | undefined,
   redirect: string | ActionFormRedirect,
@@ -3291,18 +3364,6 @@ function returnToWinsOverRedirect(
   return returnTarget !== undefined && !redirectTargetsRecord(redirect, schema, appFeatures);
 }
 
-function navigateToReturnTargetOr(
-  nav: NavApi,
-  returnTarget: ScreenTarget | undefined,
-  fallback: () => void,
-): void {
-  if (returnTarget !== undefined) {
-    nav.navigate(returnTarget);
-  } else {
-    fallback();
-  }
-}
-
 // Resolves an object-form redirect to a nav target — shared by
 // actionForm and entityEdit (create + update) so the id
 // carries over identically regardless of which screen type triggered it.
@@ -3367,6 +3428,7 @@ function ActionFormBody({
 }): ReactNode {
   const nav = useNav();
   const appFeatures = useAppFeatures();
+  const { Banner } = usePrimitives();
   // Unused when drawer-hosted — onSuccess/onCancelOverride win below first.
   const returnTarget = useReturnTarget(screen.id);
   const synthEntity = useMemo(() => synthesizeActionFormEntity(screen.fields), [screen.fields]);
@@ -3374,12 +3436,27 @@ function ActionFormBody({
   const pendingHandoff = useInitialValuesHandoff(screen.id);
   // A drawer-hosted form is not a navigation target, so it never takes a handoff.
   const handoffValues = onSuccess === undefined ? pendingHandoff : undefined;
+  // This screen has no entity, so a money field here declares its own currency
+  // source (fw#2839, boot-enforced) — without one the form would seed a bare
+  // `0` the handler's schema rejects. ACTION_FORM_CURRENCY_FALLBACK only
+  // applies when a tenant-declared field's config query errors or holds no
+  // value, matching the entityEdit path's behaviour (fw#2937).
+  const tenantCurrencyFieldNames = useMemo(
+    () => tenantCurrencyMoneyFieldNames(screen.fields),
+    [screen.fields],
+  );
+  const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(
+    screen.fields,
+    tenantCurrencyFieldNames,
+    ACTION_FORM_CURRENCY_FALLBACK,
+  );
   const initial = useMemo(
     () =>
       mergeSearchParamsIntoInitial(screen.fields, {
         searchParams: nav.searchParams,
         urlPrefillFields: screen.urlPrefillFields,
         renderableFields: layoutFieldNames(synthScreen),
+        ...(moneyCurrencyOverrides !== undefined && { moneyCurrencyOverrides }),
         ...(initialOverrides !== undefined && { drawerOverrides: initialOverrides }),
         ...(handoffValues !== undefined && { handoffValues }),
       }) as FormValues,
@@ -3388,6 +3465,7 @@ function ActionFormBody({
       screen.urlPrefillFields,
       nav.searchParams,
       synthScreen,
+      moneyCurrencyOverrides,
       initialOverrides,
       handoffValues,
     ],
@@ -3403,7 +3481,7 @@ function ActionFormBody({
       // navigation, and never one to a record screen (see redirectTargetsRecord).
       if (screen.redirect !== undefined) {
         if (returnToWinsOverRedirect(returnTarget, screen.redirect, schema, appFeatures)) {
-          nav.navigate(returnTarget);
+          navigateToReturn(nav, returnTarget);
         } else {
           const { screenId, entityId } = resolveRedirectTarget(
             screen.redirect,
@@ -3428,8 +3506,18 @@ function ActionFormBody({
       screen.cancelTarget ??
       (screen.redirect !== undefined ? redirectScreenTarget(screen.redirect) : undefined);
     if (target === undefined || target === false) return undefined;
-    return () => nav.navigate(returnTarget ?? { screenId: lastSegment(target) });
+    return () =>
+      navigateToReturnOr(nav, returnTarget, () => nav.navigate({ screenId: lastSegment(target) }));
   }, [nav, screen.redirect, screen.cancelTarget, onCancelOverride, returnTarget]);
+  // Rendering the form before a tenant-declared currency lands would show the
+  // fallback and, on a fast click, submit it (fw#2933) — hold instead.
+  if (currencyLoading) {
+    return (
+      <Banner padded variant="loading" testId="kumiko-screen-loading">
+        Loading…
+      </Banner>
+    );
+  }
   return (
     <RenderEdit
       screen={synthScreen}