@cosmicdrift/kumiko-renderer 0.384.0 → 0.386.0

package/dist/app/config-edit-body.js

@@ -0,0 +1,340 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { useCallback, useMemo } from "react";
+import { QueryOptionLabel, resolveOptionsQueryPayload, } from "../components/query-options-select.js";
+import { RenderEdit } from "../components/render-edit.js";
+import { useDispatcher } from "../context/dispatcher-context.js";
+import { buildOptionLabels, fieldOptionLabelKey } from "../headless/index.js";
+import { useQuery } from "../hooks/use-query.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+import { screenFillsHeight } from "../screen-fills-height.js";
+import { buildConfigEditSchema, synthesizeConfigEditEntity, synthesizeConfigEditScreen, } from "./config-edit-shim.js";
+import { buildInitialValues } from "./entity-edit-prefill.js";
+import { layoutEditFields } from "./layout-fields.js";
+import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
+// A money-typed config-edit field renders through RenderField's entityEdit
+// `{amount, currency}` payload shape (render-field.tsx, #1923), but
+// `ConfigKeyType` (write-helpers.ts validateType) only ever knows
+// number/boolean/text/select — a config value is always a bare scalar.
+// Unwrap back to the amount before it hits config:write:set.
+function unwrapMoneyValue(value) {
+    if (typeof value === "object" && value !== null && "amount" in value) {
+        const amount = value.amount;
+        if (typeof amount === "number")
+            return amount;
+    }
+    return value;
+}
+const CONFIG_SCOPE_SOURCE = {
+    user: "user-row",
+    tenant: "tenant-row",
+    system: "system-row",
+};
+function isWriteOnlyTextField(fieldDef) {
+    return fieldDef?.type === "text" && fieldDef.writeOnly === true;
+}
+function hasStoredValue(stored) {
+    return stored !== undefined && stored !== null && stored !== "";
+}
+const CONFIG_WRITE_ISSUE_PATH = "value";
+// write-helpers report every issue at `value`; in a batch that path is
+// meaningless to the form, so point it at the field whose command failed.
+function mapFailedConfigCommandIssuesToField(error, failedIndex, commandFieldNames) {
+    const fieldName = commandFieldNames[failedIndex];
+    const fields = error.details?.fields;
+    if (fieldName === undefined || fields === undefined)
+        return error;
+    return {
+        ...error,
+        details: {
+            ...error.details,
+            fields: fields.map((issue) => {
+                if (issue.path === CONFIG_WRITE_ISSUE_PATH)
+                    return { ...issue, path: fieldName };
+                if (issue.path.startsWith(`${CONFIG_WRITE_ISSUE_PATH}.`)) {
+                    return {
+                        ...issue,
+                        path: `${fieldName}${issue.path.slice(CONFIG_WRITE_ISSUE_PATH.length)}`,
+                    };
+                }
+                return issue;
+            }),
+        },
+    };
+}
+// A money field without a declared default starts empty too (buildInitialValues
+// maps it to 0, which a save would persist as a deliberate "0" override); numbers
+// are handled there, except a required one, which config fields never are.
+function buildConfigEditDefaults(fields) {
+    const defaults = buildInitialValues(fields); // @cast-boundary render-helper
+    for (const [shortName, fieldDef] of Object.entries(fields)) {
+        const { type, default: fieldDefault } = fieldDef; // @cast-boundary schema-walk
+        if ((type === "number" || type === "money") && fieldDefault === undefined) {
+            defaults[shortName] = undefined;
+        }
+    }
+    return defaults;
+}
+// A field hidden by its `visible` condition (a provider's settings while another
+// provider is picked) is not saved: the form saves what it shows.
+function hiddenLayoutFieldNames(screen, values) {
+    return new Set(layoutEditFields(screen)
+        .filter((spec) => spec.visible !== undefined && !evalFieldCondition(spec.visible, values))
+        .map((spec) => spec.field));
+}
+function isEmptyNumericFormValue(value) {
+    if (value === undefined || value === null || value === "")
+        return true;
+    return typeof value === "number" && !Number.isFinite(value);
+}
+export function ConfigEditBody({ schema, screen, translate, }) {
+    const { ConfigCascadeView } = usePrimitives();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const dispatcher = useDispatcher();
+    // Detail load: config:query:values returns ALL keys of the tenant.
+    // We map them via screen.configKeys from short to qualified name onto our
+    // form field values.
+    const valuesQuery = useQuery("config:query:values", {});
+    const cascadeQuery = useQuery("config:query:cascade", {});
+    const secretKeys = screen.secretKeys;
+    const secretsQuery = useQuery("secrets:query:list", {}, { enabled: secretKeys !== undefined });
+    const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);
+    const synthScreen = useMemo(() => synthesizeConfigEditScreen(screen), [screen]);
+    const boundsSchema = useMemo(() => buildConfigEditSchema(screen.fields), [screen.fields]);
+    // Initial values: per field name, fetch the value from `values[qualifiedKey]`.
+    // If the key is missing on the server (= never set), we use the field
+    // default (createTextField/createNumberField/...).
+    // String-coerce only for text fields; other types should already be the
+    // native type in the response.
+    const initial = useMemo(() => {
+        if (valuesQuery.data === null)
+            return null;
+        if (secretKeys !== undefined && secretsQuery.data === null)
+            return null;
+        const storedSecretKeys = new Set((secretsQuery.data ?? []).map((row) => row.key));
+        const out = {};
+        const defaults = buildConfigEditDefaults(screen.fields);
+        for (const [shortName, fieldDef] of Object.entries(screen.fields)) {
+            const secretKey = secretKeys?.[shortName];
+            if (secretKey !== undefined) {
+                out[shortName] = storedSecretKeys.has(secretKey) ? true : null;
+                continue;
+            }
+            const qualified = screen.configKeys[shortName];
+            if (qualified === undefined) {
+                // The author declared a field without a mapping: take the default.
+                // The boot validator pins this, it should never hit at runtime.
+                out[shortName] = defaults[shortName];
+                continue;
+            }
+            const stored = valuesQuery.data[qualified]?.value;
+            // The read carries a mask (or nothing); only whether a value exists is
+            // meaningful, so the field gets the writeOnly wire shape true / null.
+            // The read is the effective value: an inherited one is not "set" on this
+            // scope, and a reset here would remove nothing.
+            if (isWriteOnlyTextField(fieldDef)) {
+                const ownedByThisScope = valuesQuery.data[qualified]?.source === CONFIG_SCOPE_SOURCE[screen.scope];
+                out[shortName] = ownedByThisScope && hasStoredValue(stored) ? true : null;
+                continue;
+            }
+            if (stored === undefined) {
+                out[shortName] = defaults[shortName];
+                continue;
+            }
+            const ftype = propertyOf(fieldDef, "type");
+            // Field type coercion: config values are string|number|boolean, but the
+            // form state expects the matching native field type.
+            if (ftype === "number" || ftype === "money") {
+                out[shortName] = typeof stored === "number" ? stored : Number(stored);
+            }
+            else if (ftype === "boolean") {
+                out[shortName] = typeof stored === "boolean" ? stored : stored === "true";
+            }
+            else {
+                out[shortName] = typeof stored === "string" ? stored : String(stored);
+            }
+        }
+        return out;
+    }, [
+        valuesQuery.data,
+        secretsQuery.data,
+        secretKeys,
+        screen.fields,
+        screen.configKeys,
+        screen.scope,
+    ]);
+    // Cascade lookup: qualifiedKey -> ConfigCascade for the cascade display
+    // under each field. Defensive `levels` shape check so foreign query mocks
+    // (e.g. configEdit unit tests that only mock `config:query:values`) do not
+    // crash through the cascade rendering.
+    const cascades = useMemo(() => {
+        if (!cascadeQuery.data)
+            return {};
+        const out = {};
+        for (const [shortName, qualified] of Object.entries(screen.configKeys)) {
+            const cascade = cascadeQuery.data[qualified];
+            if (cascade && Array.isArray(cascade.levels))
+                out[shortName] = cascade;
+        }
+        return out;
+    }, [cascadeQuery.data, screen.configKeys]);
+    // Multi-write submit: a single /api/batch call with N config:write:set
+    // commands. Server-side the batch is atomic (transactional: all writes in
+    // one DB tx, all-or-nothing) and browser-side it is exactly one HTTP
+    // roundtrip, so there is no race between several in-flight fetches that
+    // the browser could abort on a mid-submit page.reload. Promise.all over N
+    // separate dispatcher.write calls was fragile: the server receives and
+    // commits all N, but the browser connection pool sporadically returns
+    // "Failed to fetch" for individual responses, customSubmit returns failure
+    // although the write went through, and the form stays dirty.
+    const customSubmit = useCallback(async (snapshot) => {
+        const commands = [];
+        const commandFieldNames = [];
+        const hiddenFieldNames = hiddenLayoutFieldNames(synthScreen, snapshot.values);
+        for (const [shortName, value] of Object.entries(snapshot.changes)) {
+            if (hiddenFieldNames.has(shortName))
+                continue;
+            const secretKey = secretKeys?.[shortName];
+            if (secretKey !== undefined) {
+                // Same wire shape as a writeOnly config field: null removes, a string replaces.
+                if (value === null) {
+                    commandFieldNames.push(shortName);
+                    commands.push({ type: "secrets:write:delete", payload: { key: secretKey } });
+                }
+                else if (typeof value === "string" && value.trim() !== "") {
+                    commandFieldNames.push(shortName);
+                    commands.push({ type: "secrets:write:set", payload: { key: secretKey, value } });
+                }
+                continue;
+            }
+            const qualified = screen.configKeys[shortName];
+            if (qualified === undefined)
+                continue;
+            const fieldDef = screen.fields[shortName];
+            const ftype = fieldDef?.type;
+            if (isWriteOnlyTextField(screen.fields[shortName])) {
+                // true (untouched/undone) and "" mean keep the stored secret; null removes it.
+                if (value === null) {
+                    commandFieldNames.push(shortName);
+                    commands.push({
+                        type: "config:write:reset",
+                        payload: { key: qualified, scope: screen.scope },
+                    });
+                }
+                else if (typeof value === "string" && value !== "") {
+                    commandFieldNames.push(shortName);
+                    commands.push({
+                        type: "config:write:set",
+                        payload: { key: qualified, value, scope: screen.scope },
+                    });
+                }
+                continue;
+            }
+            // A query-backed select is cleared to "" when its dependent value became
+            // invalid. config:write:set would store that as an empty override (the
+            // badge shows "Mandant" with no value); reset falls back to the inherited
+            // value. set can't do it: deleting the row is irreversible, reset is
+            // the high-risk handler.
+            if (ftype === "select" && fieldDef?.optionsQuery !== undefined && value === "") {
+                commandFieldNames.push(shortName);
+                commands.push({
+                    type: "config:write:reset",
+                    payload: { key: qualified, scope: screen.scope },
+                });
+                continue;
+            }
+            // Cleared number/money: drop this scope's override instead of storing an empty value.
+            if ((ftype === "number" || ftype === "money") &&
+                isEmptyNumericFormValue(ftype === "money" ? unwrapMoneyValue(value) : value)) {
+                commandFieldNames.push(shortName);
+                commands.push({
+                    type: "config:write:reset",
+                    payload: { key: qualified, scope: screen.scope },
+                });
+                continue;
+            }
+            commandFieldNames.push(shortName);
+            commands.push({
+                type: "config:write:set",
+                payload: {
+                    key: qualified,
+                    value: ftype === "money" ? unwrapMoneyValue(value) : value,
+                    scope: screen.scope,
+                },
+            });
+        }
+        if (commands.length === 0) {
+            return { validationBlocked: false, isSuccess: true, data: undefined };
+        }
+        const result = await dispatcher.batch(commands);
+        if (!result.isSuccess) {
+            return {
+                validationBlocked: false,
+                isSuccess: false,
+                error: mapFailedConfigCommandIssuesToField(result.error, result.failedIndex, commandFieldNames),
+            };
+        }
+        // Refresh the cascade disclosure + mask values after the write, otherwise
+        // the display stays stale until reload; same refetch calls as onReset.
+        // allSettled: the write is already committed, a failed refetch (stale
+        // display) must not turn the success result into an error.
+        await Promise.allSettled([
+            valuesQuery.refetch?.(),
+            cascadeQuery.refetch?.(),
+            ...(secretKeys !== undefined ? [secretsQuery.refetch?.()] : []),
+        ]);
+        return { validationBlocked: false, isSuccess: true, data: undefined };
+    }, [
+        dispatcher,
+        synthScreen,
+        secretKeys,
+        screen.configKeys,
+        screen.fields,
+        screen.scope,
+        valuesQuery.refetch,
+        cascadeQuery.refetch,
+        secretsQuery.refetch,
+    ]);
+    if (valuesQuery.loading && valuesQuery.data === null)
+        return _jsx(QueryLoadingBanner, {});
+    const failedQuery = valuesQuery.error ? valuesQuery : secretsQuery.error ? secretsQuery : null;
+    if (failedQuery?.error) {
+        return (_jsx(QueryErrorBanner, { error: failedQuery.error, translate: effectiveTranslate, onRetry: failedQuery.refetch }));
+    }
+    if (initial === null)
+        return _jsx(QueryLoadingBanner, {});
+    // Cascade values of a select show the option label the select itself shows,
+    // not the stored value (a UUID for optionsQuery selects).
+    const cascadeValueRenderer = (fieldName) => {
+        const fieldDef = screen.fields[fieldName];
+        if (fieldDef?.type !== "select")
+            return undefined;
+        if (fieldDef.optionsQuery !== undefined) {
+            const query = fieldDef.optionsQuery;
+            const payload = resolveOptionsQueryPayload(fieldDef.optionsQueryPayload ?? {}, initial);
+            return (value) => _jsx(QueryOptionLabel, { query: query, payload: payload, value: value });
+        }
+        if (fieldDef.options.length === 0)
+            return undefined;
+        return (value) => buildOptionLabels(effectiveTranslate, (option) => fieldOptionLabelKey(schema.featureName, synthScreen.entity, fieldName, option), [String(value)])[String(value)];
+    };
+    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, schema: boundsSchema, customSubmit: customSubmit, dirtyFooter: true, validateOnChange: true, ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), fieldAppendixPlacement: "below-control", fieldAccent: (fieldName) => cascades[fieldName]?.levels.find((level) => level.isActive)?.source ===
+            CONFIG_SCOPE_SOURCE[screen.scope], markChangedFields: true, ...(screen.fieldDescriptions !== undefined && {
+            fieldDescription: (fieldName) => {
+                const key = screen.fieldDescriptions?.[fieldName];
+                return key === undefined ? undefined : effectiveTranslate(key);
+            },
+        }), fieldAppendix: (fieldName) => {
+            const cascade = cascades[fieldName];
+            if (cascade === undefined)
+                return undefined;
+            const renderValue = cascadeValueRenderer(fieldName);
+            return (_jsx(ConfigCascadeView, { cascade: cascade, screenScope: screen.scope, qualifiedKey: screen.configKeys[fieldName], required: screen.requiredFields?.includes(fieldName) ?? false, ...(renderValue !== undefined && { renderValue }), onReset: async (key, scope) => {
+                    await dispatcher.write("config:write:reset", { key, scope });
+                    await Promise.allSettled([valuesQuery.refetch?.(), cascadeQuery.refetch?.()]);
+                } }));
+        } }));
+}

package/dist/app/entity-edit-prefill.d.ts

@@ -0,0 +1,27 @@
+import type { FormValues } from "../headless/index.ts";
+export declare function versionOf(record: Readonly<Record<string, unknown>>): number;
+export declare function buildInitialValues(fields: Readonly<Record<string, unknown>>, defaultCurrency?: string, moneyCurrencyOverrides?: Readonly<Record<string, string>>): FormValues;
+export declare function tenantCurrencyMoneyFieldNames(fields: Readonly<Record<string, unknown>>): readonly string[];
+export declare function literalCurrencyOverrides(fields: Readonly<Record<string, unknown>>): Readonly<Record<string, string>>;
+export declare function useMoneyCurrencyOverrides(fields: Readonly<Record<string, unknown>>, tenantFieldNames: readonly string[], fallback: string | undefined): {
+    readonly overrides: Readonly<Record<string, string>> | undefined;
+    readonly loading: boolean;
+    readonly unresolved: boolean;
+};
+type MoneyValue = {
+    readonly amount: number;
+    readonly currency: string;
+};
+export declare function isMoneyValue(value: unknown): value is MoneyValue;
+export declare const ISO_DATE_PATTERN: RegExp;
+export type InitialValueSources = {
+    readonly searchParams: Readonly<Record<string, string>>;
+    readonly urlPrefillFields: readonly string[] | undefined;
+    readonly renderableFields?: ReadonlySet<string>;
+    readonly defaultCurrency?: string;
+    readonly moneyCurrencyOverrides?: Readonly<Record<string, string>>;
+    readonly drawerOverrides?: Readonly<Record<string, unknown>>;
+    readonly handoffValues?: Readonly<Record<string, unknown>>;
+};
+export declare function mergeSearchParamsIntoInitial(fields: Readonly<Record<string, unknown>>, sources: InitialValueSources): Record<string, unknown>;
+export {};