@cosmicdrift/kumiko-renderer 0.387.0 → 0.389.0

package/dist/app/action-form-body.js

@@ -129,6 +129,7 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
         })
         : undefined, loadableFieldNames);
     const loadedValues = loadState?.status === "ready" ? loadState.values : undefined;
+    const refetchLoadedValues = loadState?.status === "ready" ? loadState.refetch : undefined;
     const initial = useMemo(() => {
         // With `load` the loaded record is the only source of values: a crafted link
         // or a row's params must not seed fields the record would otherwise own.
@@ -204,8 +205,14 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
             else if (hasSuccessLinks || screen.resetOnSuccess === true) {
                 publish(effectiveTranslate("kumiko.actionForm.success"));
             }
-            if (screen.resetOnSuccess === true)
-                setFormEpoch((epoch) => epoch + 1);
+            if (screen.resetOnSuccess === true) {
+                // A loaded record is stale after the write: reseed the form from the fresh one.
+                const remountForm = () => setFormEpoch((epoch) => epoch + 1);
+                if (refetchLoadedValues === undefined)
+                    remountForm();
+                else
+                    void refetchLoadedValues().finally(remountForm);
+            }
         }
         // Without a redirect the form stays put; returnTo only replaces an existing
         // navigation, and never one to a record screen (see redirectTargetsRecord).
@@ -227,6 +234,7 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
         dispatcher,
         locale,
         effectiveTranslate,
+        refetchLoadedValues,
     ]);
     // The success box disappears with the next edit; a submit clears it itself.
     const handleDirtyChange = useCallback((dirty) => {

package/dist/app/action-form-support.d.ts

@@ -21,6 +21,7 @@ export type ActionFormLoadState = {
 } | {
     readonly status: "ready";
     readonly values: Readonly<Record<string, unknown>>;
+    readonly refetch: () => Promise<void>;
 };
 /** A sensitive, writeOnly or password field never takes a value from a loaded
  *  record: the form must not echo a secret back into an input. */

package/dist/app/action-form-support.js

@@ -53,7 +53,7 @@ export function useActionFormLoad(load, recordId, fieldNames) {
         return { status: "loading" };
     if (query.data === null)
         return { status: "missing-record" };
-    return { status: "ready", values };
+    return { status: "ready", values, refetch: query.refetch };
 }
 /** Banner for every `load` state that is not "ready". */
 export function ActionFormLoadStatus({ state, screenId, translate, }) {

package/dist/app/base-path-context.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+/** Provides the URL prefix the app is mounted under to components outside the NavProvider
+ *  (auth gates and pages). `createKumikoApp({ basePath })` mounts it. */
+export declare function BasePathProvider({ basePath, children, }: {
+    readonly basePath: string | undefined;
+    readonly children: ReactNode;
+}): ReactNode;
+/** Normalized base path ("" when the app is served from the root). */
+export declare function useBasePath(): string;

package/dist/app/base-path-context.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { normalizeBasePath } from "./base-path.js";
+const BasePathContext = createContext("");
+/** Provides the URL prefix the app is mounted under to components outside the NavProvider
+ *  (auth gates and pages). `createKumikoApp({ basePath })` mounts it. */
+export function BasePathProvider({ basePath, children, }) {
+    return (_jsx(BasePathContext.Provider, { value: normalizeBasePath(basePath), children: children }));
+}
+/** Normalized base path ("" when the app is served from the root). */
+export function useBasePath() {
+    return useContext(BasePathContext);
+}

package/dist/app/base-path.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeBasePath(raw: string | undefined): string;
+export declare function stripBasePath(path: string, basePath: string): string | undefined;
+export declare function prependBasePath(path: string, basePath: string): string;

package/dist/app/base-path.js

@@ -0,0 +1,27 @@
+// basePath mounts an app under a URL prefix (for example, `/admin`). Pure helpers shared by the
+// browser nav adapter and the auth pages, which sit outside the NavProvider.
+export function normalizeBasePath(raw) {
+    if (raw === undefined || raw === "" || raw === "/")
+        return "";
+    const withLeading = raw.startsWith("/") ? raw : `/${raw}`;
+    return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
+}
+// Returns the in-app (basePath-relative) path when `path` is under basePath; otherwise
+// `undefined`. The segment boundary is strict: "/administrator" does not match "/admin".
+export function stripBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    if (path === basePath)
+        return "/";
+    if (path.startsWith(`${basePath}/`))
+        return path.slice(basePath.length);
+    return undefined;
+}
+export function prependBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    // An in-app path is absolute: "/" or "/screen-id" or "/screen-id/entity-id". "/" becomes basePath.
+    if (path === "/" || path === "")
+        return basePath;
+    return `${basePath}${path}`;
+}

package/dist/app/config-edit-body.d.ts

@@ -2,7 +2,7 @@ import type { ConfigEditScreenDefinition } from "@cosmicdrift/kumiko-framework/u
 import { type ReactNode } from "react";
 import type { Translate } from "../headless/index.ts";
 import type { FeatureSchema } from "./feature-schema.ts";
-export declare function ConfigEditBody({ schema, screen, translate, }: {
+export declare function ConfigEditBody({ schema, screen: declaredScreen, translate, }: {
     readonly schema: FeatureSchema;
     readonly screen: ConfigEditScreenDefinition;
     readonly translate?: Translate;

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

@@ -11,6 +11,7 @@ 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 { configEditWithoutSecretFields } from "./config-edit-without-secret-fields.js";
 import { buildInitialValues } from "./entity-edit-prefill.js";
 import { layoutEditFields } from "./layout-fields.js";
 import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
@@ -89,7 +90,7 @@ function isEmptyNumericFormValue(value) {
         return true;
     return typeof value === "number" && !Number.isFinite(value);
 }
-export function ConfigEditBody({ schema, screen, translate, }) {
+export function ConfigEditBody({ schema, screen: declaredScreen, translate, }) {
     const { ConfigCascadeView } = usePrimitives();
     const t = useTranslation();
     const effectiveTranslate = translate ?? t;
@@ -97,10 +98,18 @@ export function ConfigEditBody({ schema, screen, translate, }) {
     // 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 valuesQuery = useQuery("config:query:values", {
+        scope: declaredScreen.scope,
+    });
+    const cascadeQuery = useQuery("config:query:cascade", {
+        scope: declaredScreen.scope,
+    });
+    const secretsQuery = useQuery("secrets:query:list", {}, { enabled: declaredScreen.secretKeys !== undefined });
+    // The form screen's access is the union of config and secrets access, so a viewer may write
+    // the config keys without being allowed to list secrets: that must not take the form down.
+    const secretsDenied = secretsQuery.error?.code === "access_denied";
+    const screen = useMemo(() => (secretsDenied ? configEditWithoutSecretFields(declaredScreen) : declaredScreen), [secretsDenied, declaredScreen]);
+    const secretKeys = secretsDenied ? undefined : declaredScreen.secretKeys;
     const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);
     const synthScreen = useMemo(() => synthesizeConfigEditScreen(screen), [screen]);
     const boundsSchema = useMemo(() => buildConfigEditSchema(screen.fields), [screen.fields]);
@@ -300,7 +309,11 @@ export function ConfigEditBody({ schema, screen, translate, }) {
     ]);
     if (valuesQuery.loading && valuesQuery.data === null)
         return _jsx(QueryLoadingBanner, {});
-    const failedQuery = valuesQuery.error ? valuesQuery : secretsQuery.error ? secretsQuery : null;
+    const failedQuery = valuesQuery.error
+        ? valuesQuery
+        : secretsQuery.error && !secretsDenied
+            ? secretsQuery
+            : null;
     if (failedQuery?.error) {
         return (_jsx(QueryErrorBanner, { error: failedQuery.error, translate: effectiveTranslate, onRetry: failedQuery.refetch }));
     }

package/dist/app/config-edit-without-secret-fields.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare function configEditWithoutSecretFields(screen: ConfigEditScreenDefinition): ConfigEditScreenDefinition;

package/dist/app/config-edit-without-secret-fields.js

@@ -0,0 +1,28 @@
+import { isFieldsEditSection, normalizeEditField } from "@cosmicdrift/kumiko-framework/ui-types";
+// A merged provider form carries the secret-backed fields of a secrets feature the viewer may
+// not read. Without the secrets list those fields cannot show or save a state, so the form
+// drops them and stays usable for the config keys.
+export function configEditWithoutSecretFields(screen) {
+    const secretFieldNames = new Set(Object.keys(screen.secretKeys ?? {}));
+    if (secretFieldNames.size === 0)
+        return screen;
+    const keepSpec = (spec) => !secretFieldNames.has(normalizeEditField(spec).field);
+    const fields = Object.fromEntries(Object.entries(screen.fields).filter(([name]) => !secretFieldNames.has(name)));
+    const sections = screen.layout.sections.flatMap((section) => {
+        if (!isFieldsEditSection(section))
+            return [section];
+        if ("groups" in section) {
+            const groups = section.groups
+                .map((group) => ({ ...group, fields: group.fields.filter(keepSpec) }))
+                .filter((group) => group.fields.length > 0);
+            return groups.length === 0 ? [] : [{ ...section, groups }];
+        }
+        const kept = section.fields.filter(keepSpec);
+        return kept.length === 0 ? [] : [{ ...section, fields: kept }];
+    });
+    return {
+        ...screen,
+        fields,
+        layout: { ...screen.layout, sections },
+    };
+}

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

@@ -2,6 +2,17 @@ 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 type TenantCurrencyResolution = {
+    readonly status: "not-needed";
+} | {
+    readonly status: "loading";
+} | {
+    readonly status: "unresolved";
+} | {
+    readonly status: "ready";
+    readonly currency: string;
+};
+export declare function useTenantCurrency(needed: boolean, fallback: string | undefined): TenantCurrencyResolution;
 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;

package/dist/app/entity-edit-prefill.js

@@ -71,8 +71,8 @@ export function tenantCurrencyMoneyFieldNames(fields) {
 // back to "EUR" while the query is genuinely still in flight — a
 // screen with no tenant-declared money field, or a query that errored or
 // returned no value for the key, resolves immediately instead of blocking.
-function resolveTenantCurrency(fieldNames, query, fallback) {
-    if (fieldNames.length === 0)
+function resolveTenantCurrency(needed, query, fallback) {
+    if (!needed)
         return { status: "not-needed" };
     if (query.error) {
         return fallback === undefined
@@ -88,6 +88,12 @@ function resolveTenantCurrency(fieldNames, query, fallback) {
         ? { status: "unresolved" }
         : { status: "ready", currency: fallback };
 }
+// `needed = false` skips the config query entirely; an errored query or a missing value
+// resolves to `fallback` (or `unresolved` without one).
+export function useTenantCurrency(needed, fallback) {
+    const query = useQuery("config:query:values", { keys: [TENANT_CURRENCY_CONFIG_KEY] }, { enabled: needed });
+    return resolveTenantCurrency(needed, query, fallback);
+}
 // A money field naming a fixed ISO code (`currency: { kind: "literal", code }`)
 // resolves with no query at all. Read structurally, same idiom as
 // tenantCurrencyMoneyFieldNames above.
@@ -115,8 +121,7 @@ export function useMoneyCurrencyOverrides(fields, tenantFieldNames,
 // `undefined` = no safe last resort (entity-less forms): an unresolvable
 // tenant currency is reported via `unresolved` instead of guessing a code.
 fallback) {
-    const query = useQuery("config:query:values", { keys: [TENANT_CURRENCY_CONFIG_KEY] }, { enabled: tenantFieldNames.length > 0 });
-    const resolution = resolveTenantCurrency(tenantFieldNames, query, fallback);
+    const resolution = useTenantCurrency(tenantFieldNames.length > 0, fallback);
     const resolvedTenantCurrency = resolution.status === "ready" ? resolution.currency : undefined;
     const overrides = useMemo(() => {
         const out = { ...literalCurrencyOverrides(fields) };

package/dist/app/entity-list-facet-specs.d.ts

@@ -0,0 +1,3 @@
+import type { Translate } from "../headless/index.ts";
+import type { ResolvedFacetSpec } from "./list-facets.ts";
+export declare function resolveEntityFacetSpecs(fields: Readonly<Record<string, unknown>>, featureName: string, entityName: string, translate: Translate): ResolvedFacetSpec[];

package/dist/app/entity-list-facet-specs.js

@@ -0,0 +1,65 @@
+import { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { fieldLabelKey, fieldOptionLabelKey } from "../headless/index.js";
+// entityList adapter — one DataTableFacet per filterable select/boolean
+// entity field, labels via the standard field/option i18n convention.
+export function resolveEntityFacetSpecs(fields, featureName, entityName, translate) {
+    const out = [];
+    for (const [field, rawDef] of Object.entries(fields)) {
+        // entity.fields is weakly typed at the renderer layer (deserialized from the schema).
+        const def = {
+            type: propertyOf(rawDef, "type"),
+            filterable: propertyOf(rawDef, "filterable"),
+            options: propertyOf(rawDef, "options"),
+            entity: propertyOf(rawDef, "entity"),
+            labelField: propertyOf(rawDef, "labelField"),
+        };
+        if (def.filterable !== true)
+            continue;
+        const label = translate(fieldLabelKey(featureName, entityName, field));
+        if (def.type === "select" && Array.isArray(def.options)) {
+            const optionValues = def.options.filter((value) => typeof value === "string");
+            out.push({
+                field,
+                type: "select",
+                label,
+                options: optionValues.map((value) => ({
+                    value,
+                    label: translate(fieldOptionLabelKey(featureName, entityName, field, value)),
+                })),
+            });
+        }
+        else if (def.type === "boolean") {
+            out.push({
+                field,
+                type: "boolean",
+                label,
+                options: [
+                    {
+                        value: "true",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "true")),
+                    },
+                    {
+                        value: "false",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "false")),
+                    },
+                ],
+            });
+        }
+        else if (def.type === "reference" && typeof def.entity === "string") {
+            const target = parseRefTarget(def.entity, featureName);
+            out.push({
+                field,
+                type: "reference",
+                label,
+                options: [],
+                reference: {
+                    refEntity: target.entityName,
+                    refFeature: target.featureName,
+                    labelField: typeof def.labelField === "string" ? def.labelField : "id",
+                },
+            });
+        }
+    }
+    return out;
+}