@object-ui/app-shell 7.1.0 → 7.3.0

package/dist/views/metadata-admin/inspectors/VariableTextInput.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * VariableTextInput — a single-line input (or textarea) for an expression /
+ * template flow-config value, with a "{x}" data-picker (#1934) that inserts an
+ * in-scope reference at the cursor.
+ *
+ * Brace handling is done FOR the author (ADR-0032): the picker inserts the BARE
+ * reference (`discount_pct`) in `expression` fields and the braced
+ * `{discount_pct}` in `template` (text / textarea) fields — killing the
+ * recurring `{record.x}` brace-in-CEL trap. Free-text typing is untouched, and
+ * the picker button is hidden entirely when nothing is in scope, so an empty
+ * scope degrades to a plain input.
+ */
+import * as React from 'react';
+import { Braces } from 'lucide-react';
+import { cn, Input, Popover, PopoverTrigger, PopoverContent, Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, } from '@object-ui/components';
+/** Wrap a bare reference token for insertion into the given field mode. */
+export function formatToken(token, mode) {
+    return mode === 'template' ? `{${token}}` : token;
+}
+/**
+ * Splice a reference into `value` at the selection `[selStart, selEnd]`, in the
+ * brace mode for the field, returning the new string and the caret position
+ * just after the inserted token. Pure (the DOM caret restore lives in the
+ * component); selection bounds are clamped and order-normalized so a reversed or
+ * out-of-range selection can't corrupt the value.
+ */
+export function insertToken(value, mode, token, selStart, selEnd) {
+    const text = formatToken(token, mode);
+    const a = Math.min(Math.max(selStart, 0), value.length);
+    const b = Math.min(Math.max(selEnd, 0), value.length);
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    return { next: value.slice(0, lo) + text + value.slice(hi), caret: lo + text.length };
+}
+const PICK_LABEL = 'Insert a reference';
+const SEARCH_LABEL = 'Search references…';
+const EMPTY_LABEL = 'No matching references.';
+export function VariableTextInput({ value, onValueChange, onBlur, onKeyDown, mode, groups, placeholder, disabled, multiline, rows = 4, mono, className, }) {
+    const inputRef = React.useRef(null);
+    // Remember the caret across the button press (which blurs the field) so the
+    // token lands where the author was typing — not appended at the end.
+    const caret = React.useRef({ start: 0, end: 0 });
+    const [open, setOpen] = React.useState(false);
+    const setRef = (el) => {
+        inputRef.current = el;
+    };
+    const rememberCaret = () => {
+        const el = inputRef.current;
+        if (el) {
+            caret.current = {
+                start: el.selectionStart ?? value.length,
+                end: el.selectionEnd ?? value.length,
+            };
+        }
+    };
+    const insert = (token) => {
+        const { next, caret: pos } = insertToken(value, mode, token, caret.current.start, caret.current.end);
+        onValueChange(next);
+        setOpen(false);
+        // Restore focus + place the caret just after the inserted token.
+        requestAnimationFrame(() => {
+            const el = inputRef.current;
+            if (!el)
+                return;
+            el.focus();
+            try {
+                el.setSelectionRange(pos, pos);
+            }
+            catch {
+                /* some input types disallow setSelectionRange */
+            }
+            caret.current = { start: pos, end: pos };
+        });
+    };
+    const hasScope = groups.some((g) => g.refs.length > 0);
+    const shared = {
+        value,
+        onChange: (e) => onValueChange(e.target.value),
+        onBlur,
+        onKeyDown,
+        onSelect: rememberCaret,
+        onKeyUp: rememberCaret,
+        onClick: rememberCaret,
+        placeholder,
+        disabled,
+    };
+    return (_jsxs("div", { className: cn('relative', className), children: [multiline ? (_jsx("textarea", { ref: setRef, ...shared, rows: rows, className: "w-full rounded border bg-background px-2 py-1.5 pr-8 font-mono text-xs" })) : (_jsx(Input, { ref: setRef, ...shared, className: cn('h-8 pr-8 text-sm', mono && 'font-mono') })), hasScope && !disabled && (_jsxs(Popover, { open: open, onOpenChange: setOpen, children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx("button", { type: "button", "aria-label": PICK_LABEL, title: PICK_LABEL, 
+                            // Capture the caret on mousedown (fires before the input blur), so
+                            // the insertion point is the author's last position.
+                            onMouseDown: rememberCaret, className: "absolute right-1 top-1 inline-flex h-6 w-6 items-center justify-center rounded text-muted-foreground transition-colors hover:bg-muted hover:text-foreground", children: _jsx(Braces, { className: "h-3.5 w-3.5" }) }) }), _jsx(PopoverContent, { align: "end", className: "w-72 p-0", 
+                        // Keep our rAF focus-restore from fighting Radix's focus return.
+                        onCloseAutoFocus: (e) => e.preventDefault(), children: _jsxs(Command, { children: [_jsx(CommandInput, { placeholder: SEARCH_LABEL, className: "h-9" }), _jsxs(CommandList, { children: [_jsx(CommandEmpty, { children: EMPTY_LABEL }), groups.map((g) => (_jsx(CommandGroup, { heading: g.label, children: g.refs.map((ref) => (_jsxs(CommandItem, { value: `${ref.token} ${ref.label} ${ref.detail ?? ''}`, onSelect: () => insert(ref.token), className: "flex items-center justify-between gap-2", children: [_jsx("span", { className: "truncate font-mono text-xs", children: formatToken(ref.token, mode) }), ref.detail && (_jsx("span", { className: "shrink-0 truncate text-[10px] text-muted-foreground", children: ref.detail }))] }, `${g.id}:${ref.token}`))) }, g.id)))] })] }) })] }))] }));
+}

package/dist/views/metadata-admin/inspectors/datasetFilterCondition.js

@@ -39,7 +39,12 @@ export function groupToCondition(group) {
         const mop = OP_TO_MONGO[c.operator];
         if (!mop)
             continue; // unmapped (e.g. notContains/between) — drop rather than emit a bad filter
-        parts.push({ [c.field]: { [mop]: c.value } });
+        // Skip incomplete rows (no value typed yet) — emitting `{field:{$op:''}}` would
+        // be a silently-wrong filter (matches only empty), not "no filter".
+        const v = c.value;
+        if (v == null || v === '' || (Array.isArray(v) && v.length === 0))
+            continue;
+        parts.push({ [c.field]: { [mop]: v } });
     }
     if (parts.length === 0)
         return undefined;

package/dist/views/metadata-admin/inspectors/flow-node-config.d.ts

@@ -93,6 +93,14 @@ export interface FlowConfigField {
      * the spec's top-level `node.waitEventConfig.eventType`.
      */
     path: string[];
+    /**
+     * Optional secondary read location used when `path` holds no value — lets the
+     * inspector tolerate a looser on-disk shape the engine also accepts (e.g. a
+     * `wait` node authored with `config.eventType` instead of the spec-canonical
+     * `waitEventConfig.eventType`). Reads fall back to it; the inspector writes the
+     * canonical `path` and prunes the fallback (migrate-on-edit).
+     */
+    fallbackPath?: string[];
     /** Human-readable field label (English — repo is English-only). */
     label: string;
     kind: FlowConfigFieldKind;
@@ -120,10 +128,17 @@ export interface FlowConfigField {
     columns?: FlowConfigColumn[];
     /** Reference target for `reference` fields — drives the combobox data source. */
     ref?: FlowReferenceSpec;
+    /**
+     * Data-picker brace mode override (#1934). Defaults by kind (`expression` →
+     * bare CEL, `text` / `textarea` → `{var}` template). Set `'expression'` on a
+     * code field (e.g. a script body) so the picker inserts bare references, not
+     * `{var}` — `{x}` is a syntax error in a JS/TS script.
+     */
+    refMode?: 'expression' | 'template';
 }
 /** Resolve the config fields for a node type (alias-aware). */
 export declare function fieldsForNodeType(type?: string): FlowConfigField[];
-/** Read the current value at a field's node path. */
+/** Read the current value at a field's node path, falling back to `fallbackPath`. */
 export declare function getFieldValue(node: Record<string, unknown> | null | undefined, field: FlowConfigField): unknown;
 /**
  * The `config` key this field owns, or `undefined` for fields stored outside

package/dist/views/metadata-admin/inspectors/flow-node-config.js

@@ -163,6 +163,7 @@ const FLOW_NODE_CONFIG = {
         cfg('script', 'Code', 'textarea', {
             placeholder: 'return { ok: true };',
             help: 'Script body (JS/TS).',
+            refMode: 'expression',
             showWhen: { field: 'actionType', equals: ['code'] },
         }),
         cfg('outputVariables', 'Output variables', 'stringList', {
@@ -315,23 +316,27 @@ const FLOW_NODE_CONFIG = {
                 { value: 'condition', label: 'Condition' },
             ],
             defaultValue: 'timer',
+            fallbackPath: ['config', 'eventType'],
         }),
         at('waitEventConfig', 'timerDuration', 'Duration', 'text', {
             placeholder: 'PT1H · P3D',
             help: 'ISO 8601 duration (e.g. PT1H, P3D).',
             showWhen: { field: 'waitEventConfig.eventType', equals: ['timer'] },
+            fallbackPath: ['config', 'timerDuration'],
         }),
         at('waitEventConfig', 'signalName', 'Signal name', 'text', {
             placeholder: 'contract.renewed',
             showWhen: { field: 'waitEventConfig.eventType', equals: ['signal', 'webhook'] },
+            fallbackPath: ['config', 'signalName'],
         }),
-        at('waitEventConfig', 'timeoutMs', 'Timeout (ms)', 'number', { placeholder: '3600000' }),
+        at('waitEventConfig', 'timeoutMs', 'Timeout (ms)', 'number', { placeholder: '3600000', fallbackPath: ['config', 'timeoutMs'] }),
         at('waitEventConfig', 'onTimeout', 'On timeout', 'select', {
             options: [
                 { value: 'fail', label: 'Fail' },
                 { value: 'continue', label: 'Continue' },
             ],
             defaultValue: 'fail',
+            fallbackPath: ['config', 'onTimeout'],
         }),
     ],
     subflow: [
@@ -436,16 +441,22 @@ export function fieldsForNodeType(type) {
     const canonical = TYPE_ALIASES[type] ?? type;
     return FLOW_NODE_CONFIG[canonical] ?? [];
 }
-/** Read the current value at a field's node path. */
+/** Read the current value at a field's node path, falling back to `fallbackPath`. */
 export function getFieldValue(node, field) {
-    let cur = node;
-    for (const seg of field.path) {
-        if (cur && typeof cur === 'object' && !Array.isArray(cur))
-            cur = cur[seg];
-        else
-            return undefined;
-    }
-    return cur;
+    const read = (path) => {
+        let cur = node;
+        for (const seg of path) {
+            if (cur && typeof cur === 'object' && !Array.isArray(cur))
+                cur = cur[seg];
+            else
+                return undefined;
+        }
+        return cur;
+    };
+    const primary = read(field.path);
+    if (primary !== undefined)
+        return primary;
+    return field.fallbackPath ? read(field.fallbackPath) : undefined;
 }
 /**
  * The `config` key this field owns, or `undefined` for fields stored outside

package/dist/views/metadata-admin/inspectors/flow-ref-check.d.ts

@@ -0,0 +1,39 @@
+/**
+ * flow-ref-check — pure, scope-aware "unknown reference" detection for the flow
+ * inspector's inline validation (#1934 follow-up). Pairs the data-picker with a
+ * gentle warning when an authored expression / template references a name that
+ * is NOT in scope at the node — catching typos (`recrod.email`) and stale
+ * references the picker would have prevented.
+ *
+ * Deliberately conservative — a warning that cries wolf is worse than none:
+ *   • Only the ROOT of a reference path is checked (`record.email` → `record`),
+ *     so a field list is never needed; if `record` is in scope the whole path is
+ *     accepted.
+ *   • Function / macro calls (`daysFromNow(90)`, `has(...)`, `size(...)`) are
+ *     skipped — an identifier immediately followed by `(` is never a reference.
+ *   • String-literal contents are stripped before scanning.
+ *   • Runtime globals the engine injects (`env`, `$error`, `data`, …) and CEL
+ *     keywords/literals are allow-listed.
+ *   • For templates only the inside of single-brace `{…}` holes is scanned.
+ *
+ * The caller supplies the in-scope ROOT names (see {@link scopeRoots}); an empty
+ * set means "scope unknown" and the check is skipped (returns nothing).
+ */
+import type { ExprFieldRole } from './expression-validate';
+import type { ScopeRef } from './flow-scope';
+export interface UnknownRef {
+    /** The unresolved root identifier, as authored. */
+    token: string;
+    /** Nearest in-scope root within edit distance 2, when one exists (typo hint). */
+    suggestion?: string;
+}
+/** The set of valid root identifiers from a resolved scope's refs. */
+export declare function scopeRoots(refs: ReadonlyArray<ScopeRef>): Set<string>;
+/**
+ * Find referenced roots that are not in scope. Returns [] when clean, when the
+ * source is empty, or when `knownRoots` is empty (scope unknown → don't guess).
+ */
+export declare function findUnknownRefs(source: unknown, role: ExprFieldRole, knownRoots: Set<string>): UnknownRef[];
+/** Build a one-line inspector warning from unknown refs (shared by the field
+ *  and edge inspectors). */
+export declare function describeUnknownRefs(unknown: ReadonlyArray<UnknownRef>): string;

package/dist/views/metadata-admin/inspectors/flow-ref-check.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/** CEL keywords / literals that are never flow references. */
+const CEL_RESERVED = new Set(['true', 'false', 'null', 'in']);
+/**
+ * Roots the engine provides at runtime that won't show up in the graph-resolved
+ * scope. Conservative allow-list — better to miss a typo than flag a valid ref.
+ */
+const RUNTIME_GLOBALS = new Set(['env', 'request', 'context', 'user', 'now', 'today', 'self', 'data']);
+/** The set of valid root identifiers from a resolved scope's refs. */
+export function scopeRoots(refs) {
+    const roots = new Set();
+    for (const r of refs) {
+        const root = r.token.split('.')[0];
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+/** Bounded Levenshtein distance, giving up (returns max+1) once it exceeds `max`. */
+function editDistance(a, b, max = 2) {
+    if (Math.abs(a.length - b.length) > max)
+        return max + 1;
+    const prev = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j++)
+        prev[j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        let diag = prev[0];
+        prev[0] = i;
+        let rowMin = prev[0];
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diag = tmp;
+            if (prev[j] < rowMin)
+                rowMin = prev[j];
+        }
+        if (rowMin > max)
+            return max + 1;
+    }
+    return prev[b.length];
+}
+/** Extract reference-position root identifiers (skipping members and calls). */
+function rootIdentifiers(src) {
+    // Strip string literals so their contents aren't scanned as references.
+    const noStrings = src
+        .replace(/'(?:[^'\\]|\\.)*'/g, ' ')
+        .replace(/"(?:[^"\\]|\\.)*"/g, ' ');
+    const out = [];
+    // Lookbehind keeps this to ROOTS: an identifier not preceded by `.` (member),
+    // a word char, or `$`. Zero-width, so adjacent tokens are never swallowed.
+    const re = /(?<![.\w$])([A-Za-z_$][\w$]*)/g;
+    let m;
+    while ((m = re.exec(noStrings))) {
+        const name = m[1];
+        // A trailing `(` (after optional spaces) marks a function / macro call.
+        if (/^\s*\(/.test(noStrings.slice(m.index + name.length)))
+            continue;
+        if (CEL_RESERVED.has(name))
+            continue;
+        out.push(name);
+    }
+    return out;
+}
+/**
+ * Find referenced roots that are not in scope. Returns [] when clean, when the
+ * source is empty, or when `knownRoots` is empty (scope unknown → don't guess).
+ */
+export function findUnknownRefs(source, role, knownRoots) {
+    let raw = '';
+    if (typeof source === 'string')
+        raw = source;
+    else if (source && typeof source === 'object')
+        raw = String(source.source ?? '');
+    if (!raw.trim() || knownRoots.size === 0)
+        return [];
+    let scan = raw;
+    if (role === 'template') {
+        const holes = raw.match(/\{([^{}]+)\}/g);
+        if (!holes)
+            return [];
+        scan = holes.map((h) => h.slice(1, -1)).join(' ; ');
+    }
+    const seen = new Set();
+    const unknown = [];
+    for (const root of rootIdentifiers(scan)) {
+        if (seen.has(root))
+            continue;
+        seen.add(root);
+        if (knownRoots.has(root) || RUNTIME_GLOBALS.has(root) || root.startsWith('$'))
+            continue;
+        let suggestion;
+        let best = 3;
+        for (const k of knownRoots) {
+            const d = editDistance(root, k, 2);
+            if (d < best) {
+                best = d;
+                suggestion = k;
+            }
+        }
+        unknown.push({ token: root, suggestion: best <= 2 ? suggestion : undefined });
+    }
+    return unknown;
+}
+/** Build a one-line inspector warning from unknown refs (shared by the field
+ *  and edge inspectors). */
+export function describeUnknownRefs(unknown) {
+    if (unknown.length === 1) {
+        const u = unknown[0];
+        return u.suggestion
+            ? `Unknown reference \`${u.token}\` — did you mean \`${u.suggestion}\`?`
+            : `\`${u.token}\` is not a reference in scope at this step.`;
+    }
+    return `Not in scope: ${unknown.map((u) => `\`${u.token}\``).join(', ')}.`;
+}

package/dist/views/metadata-admin/inspectors/flow-scope.d.ts

@@ -0,0 +1,109 @@
+/**
+ * flow-scope — pure, framework-free resolution of the in-scope variable
+ * references at a given flow node, for the inspector's variable data-picker
+ * (#1934).
+ *
+ * "In scope" is GRAPH-AWARE: a reference is offered at node N only if it can
+ * actually exist when N runs. Concretely:
+ *
+ *   - Flow variables — every entry in `draft.variables[]` (declared up-front, so
+ *     always in scope).
+ *   - Upstream outputs — the `outputVariable(s)` / collected screen
+ *     `fields[].name` / `assignments` keys / `idVariable` of every ANCESTOR node
+ *     (a node from which N is reachable, found by walking edges backwards). A
+ *     node's OWN outputs and any DOWNSTREAM node's outputs are deliberately
+ *     excluded — they don't exist yet when N runs. This is the property the
+ *     picker's "a downstream output is not offered upstream" guarantee rests on.
+ *   - Loop / map iterators — the `iteratorVariable` of an enclosing loop/map
+ *     ancestor, surfaced as its own group.
+ *   - Trigger record — on a record-triggered flow, the trigger object's fields.
+ *     Referenced BARE on the start node's own entry condition (`status`,
+ *     matching the engine's trigger-evaluation context where the changed
+ *     record's fields are top-level) and as `record.<field>` on every
+ *     downstream node (the convention the showcase flows use). The object's
+ *     field list is fetched lazily by the React layer (see useFlowScope); this
+ *     module only resolves the object NAME and the correct token prefix.
+ *
+ * The graph-walk here is the unit-tested heart of the picker; async field-list
+ * expansion and rendering live in the React layer so this module stays pure.
+ */
+/** Which group a reference belongs to (drives the picker's section headers). */
+export type ScopeGroupId = 'variables' | 'outputs' | 'loop' | 'trigger';
+/**
+ * One pickable reference. `token` is the BARE form (no braces); the picker
+ * inserts it as-is into CEL `expression` fields and wraps it as `{token}` for
+ * `text` / `textarea` template fields (ADR-0032 — the brace rule is handled for
+ * the author).
+ */
+export interface ScopeRef {
+    token: string;
+    /** Primary display text (the token, or the bare field name). */
+    label: string;
+    /** Secondary, muted text — a type, an origin node label, etc. */
+    detail?: string;
+    group: ScopeGroupId;
+}
+/** The trigger object whose fields the UI layer should fetch and expand. */
+export interface TriggerScope {
+    objectName: string;
+    /** Per-field token prefix: '' on the start node (bare), 'record.' downstream. */
+    fieldPrefix: string;
+    /** Also emit `previous.<field>` refs (update / change / before-update triggers). */
+    includePrevious: boolean;
+}
+export interface FlowScope {
+    /**
+     * References resolvable WITHOUT a network fetch: flow variables, upstream
+     * outputs, loop iterators, and the whole-record `record` / `previous` tokens.
+     */
+    refs: ScopeRef[];
+    /** Present when a record trigger is in scope — the UI expands its fields. */
+    trigger?: TriggerScope;
+}
+interface FlowNodeLike {
+    id?: unknown;
+    type?: unknown;
+    label?: unknown;
+    config?: unknown;
+}
+interface FlowEdgeLike {
+    source?: unknown;
+    target?: unknown;
+}
+/**
+ * Ancestor node ids of `nodeId` — every node from which `nodeId` is reachable
+ * by following edges forward (equivalently, a reverse breadth-first walk from
+ * `nodeId`). Cycle-safe (a declared `back`-edge revise loop won't spin) and
+ * never includes `nodeId` itself.
+ */
+export declare function flowAncestors(nodeId: string, edges: FlowEdgeLike[]): Set<string>;
+/**
+ * The variable names a node INTRODUCES into scope for its successors — mirroring
+ * what the simulator (flow-simulator.ts) and engine actually write:
+ * `outputVariable` (single), `outputVariables` (list), an assignment node's
+ * `assignments` keys (map / array / flat shapes), a screen's collected
+ * `fields[].name`, a screen object-form's `idVariable`, and a loop/map
+ * `iteratorVariable` (flagged as a `loop` ref). The start node is NOT handled
+ * here — its trigger record is resolved separately.
+ */
+export declare function nodeOutputRefs(node: FlowNodeLike): ScopeRef[];
+/**
+ * Resolve the in-scope reference set at `nodeId` (graph-aware). Pure: the
+ * trigger object's fields are NOT expanded here (that needs an async fetch) —
+ * the returned `trigger` carries the object name and per-field token prefix for
+ * the UI layer to expand. Order: flow variables, upstream outputs, loop
+ * iterators, then trigger refs, de-duplicated by token.
+ */
+export declare function resolveFlowScope(draft: Record<string, unknown>, nodeId: string | undefined): FlowScope;
+/**
+ * Expand a trigger object's fields into per-field refs — `record.<field>`
+ * downstream, bare `<field>` on the start node — given an already-fetched field
+ * list. Split out from {@link resolveFlowScope} so it is unit-testable without a
+ * metadata client.
+ */
+export declare function triggerFieldRefs(trigger: TriggerScope, fields: ReadonlyArray<{
+    name: string;
+    label?: string;
+    type?: string;
+}>): ScopeRef[];
+export {};