@object-ui/app-shell 6.2.3 → 7.1.0

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

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ArrowDown, ArrowUp, Trash2, X } from 'lucide-react';
+import { cn } from '@object-ui/components';
+import { Badge, Button, Input, Label, Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@object-ui/components';
+export function InspectorShell({ kindLabel, title, onClose, closeLabel = 'Close', children, footer, headerActions, hideClose }) {
+    return (_jsxs("div", { className: "flex h-full flex-col", children: [_jsxs("div", { className: "flex items-start justify-between gap-2 border-b px-4 py-2.5", children: [_jsxs("div", { className: "min-w-0", children: [_jsx(Badge, { variant: "secondary", className: "text-[10px] uppercase tracking-wider", children: kindLabel }), _jsx("div", { className: "mt-1 truncate text-sm font-medium", title: title, children: title })] }), _jsxs("div", { className: "flex items-center gap-1 shrink-0", children: [headerActions, !hideClose && (_jsx(Button, { variant: "ghost", size: "sm", onClick: onClose, "aria-label": closeLabel, className: "h-7 w-7 p-0", children: _jsx(X, { className: "h-4 w-4" }) }))] })] }), _jsx("div", { className: "flex-1 overflow-auto px-4 py-3 space-y-3", children: children }), footer && _jsx("div", { className: "border-t px-4 py-2.5", children: footer })] }));
+}
+/**
+ * Compact ↑/↓ pair sized to fit alongside the close button in the
+ * inspector header. Auto-disables boundaries (↑ at index 0, ↓ at
+ * `total - 1`) and the whole pair when `total <= 1`.
+ */
+export function InspectorReorderButtons({ index, total, onMove, upLabel = 'Move up', downLabel = 'Move down', disabled, }) {
+    if (total <= 1 || index < 0)
+        return null;
+    const canUp = !disabled && index > 0;
+    const canDown = !disabled && index < total - 1;
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { type: "button", variant: "ghost", size: "sm", className: "h-7 w-7 p-0", onClick: () => canUp && onMove(index - 1), disabled: !canUp, "aria-label": upLabel, title: upLabel, children: _jsx(ArrowUp, { className: "h-4 w-4" }) }), _jsx(Button, { type: "button", variant: "ghost", size: "sm", className: "h-7 w-7 p-0", onClick: () => canDown && onMove(index + 1), disabled: !canDown, "aria-label": downLabel, title: downLabel, children: _jsx(ArrowDown, { className: "h-4 w-4" }) })] }));
+}
+/* ─────────────── Form atoms ─────────────── */
+export function InspectorTextField({ label, value, onCommit, onBlur, placeholder, disabled, mono, testId, }) {
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: label }), _jsx(Input, { value: value, onChange: (e) => onCommit(e.target.value), onBlur: (e) => onBlur?.(e.target.value), placeholder: placeholder, disabled: disabled, "data-testid": testId, className: cn('h-8 text-sm', mono && 'font-mono') })] }));
+}
+export function InspectorNumberField({ label, value, onCommit, placeholder, disabled, }) {
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: label }), _jsx(Input, { type: "number", value: value ?? '', onChange: (e) => {
+                    const v = e.target.value;
+                    onCommit(v === '' ? undefined : Number(v));
+                }, placeholder: placeholder, disabled: disabled, className: "h-8 text-sm" })] }));
+}
+export function InspectorSelectField({ label, value, options, onCommit, placeholder = '—', disabled, }) {
+    // Radix `<Select.Item>` forbids an empty-string value (it reserves ""
+    // for the cleared/placeholder state), yet callers legitimately use ""
+    // to mean "no value" (e.g. a "— None —" option). Bridge with an
+    // internal sentinel so the public contract (value="" ⇄ none) holds.
+    const toInner = (v) => (v === '' ? SELECT_NONE_SENTINEL : v);
+    const fromInner = (v) => (v === SELECT_NONE_SENTINEL ? '' : v);
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: label }), _jsxs(Select, { value: toInner(value ?? ''), onValueChange: (v) => onCommit(fromInner(v)), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-8 text-sm", children: _jsx(SelectValue, { placeholder: placeholder }) }), _jsx(SelectContent, { children: options.map((o) => (_jsx(SelectItem, { value: toInner(o.value), children: o.label }, o.value))) })] })] }));
+}
+const SELECT_NONE_SENTINEL = '__inspector_select_none__';
+export function InspectorCheckboxField({ label, value, onCommit, disabled, }) {
+    return (_jsxs("label", { className: "flex items-center gap-2 text-xs cursor-pointer select-none", children: [_jsx("input", { type: "checkbox", checked: value, disabled: disabled, onChange: (e) => onCommit(e.target.checked), className: "h-3.5 w-3.5" }), _jsx("span", { children: label })] }));
+}
+export function InspectorRemoveButton({ label, onClick, disabled }) {
+    // Calm by default (muted outline), escalating to destructive-red only on
+    // hover — a full-width solid-red bar reads as alarming for what is a routine
+    // "remove this element" footer action. The trash icon keeps intent clear.
+    return (_jsxs(Button, { variant: "outline", size: "sm", onClick: onClick, disabled: disabled, className: "w-full gap-1.5 text-muted-foreground hover:border-destructive/40 hover:bg-destructive/5 hover:text-destructive", children: [_jsx(Trash2, { className: "h-3.5 w-3.5" }), label] }));
+}
+export function InspectorEmptyState({ message }) {
+    return _jsx("div", { className: "text-xs italic text-muted-foreground p-4 text-center", children: message });
+}
+/**
+ * Helper to immutably splice an item in an array on a draft.
+ * Returns a new array; never mutates input.
+ */
+export function spliceArray(arr, index, replacement) {
+    const a = Array.isArray(arr) ? [...arr] : [];
+    if (replacement === null)
+        a.splice(index, 1);
+    else
+        a[index] = replacement;
+    return a;
+}
+/**
+ * Insert `item` at `index` immutably. Index out of range clamps to
+ * [0, length]. Returns a new array; never mutates input.
+ */
+export function insertArray(arr, index, item) {
+    const a = Array.isArray(arr) ? [...arr] : [];
+    const i = Math.max(0, Math.min(a.length, index));
+    a.splice(i, 0, item);
+    return a;
+}
+/**
+ * Append `item` to the end immutably. Convenience wrapper over
+ * insertArray for the common "+ Add at end" case.
+ */
+export function appendArray(arr, item) {
+    const a = Array.isArray(arr) ? [...arr] : [];
+    a.push(item);
+    return a;
+}
+/**
+ * Move an item from `from` to `to` immutably. Out-of-range or no-op
+ * moves return a new copy unchanged. Useful for ↑/↓ reorder buttons.
+ */
+export function moveArray(arr, from, to) {
+    const a = Array.isArray(arr) ? [...arr] : [];
+    if (from < 0 || from >= a.length)
+        return a;
+    const clampedTo = Math.max(0, Math.min(a.length - 1, to));
+    if (clampedTo === from)
+        return a;
+    const [item] = a.splice(from, 1);
+    a.splice(clampedTo, 0, item);
+    return a;
+}
+/**
+ * Generate a snake_case id that doesn't collide with `existing`. Used
+ * by Add helpers that need a stable identifier (Flow nodes, App nav,
+ * Dashboard widgets) before the user fills in a meaningful name.
+ *
+ *   uniqueId('node', ['node_1', 'node_3']) -> 'node_2'
+ */
+export function uniqueId(prefix, existing) {
+    const taken = new Set(existing.filter((x) => typeof x === 'string'));
+    for (let i = 1; i < 10000; i++) {
+        const candidate = `${prefix}_${i}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    return `${prefix}_${Date.now()}`;
+}

package/dist/views/metadata-admin/inspectors/datasetFilterCondition.d.ts

@@ -0,0 +1,24 @@
+export interface BuilderCondition {
+    id?: string;
+    field: string;
+    operator: string;
+    value?: unknown;
+}
+export interface BuilderGroup {
+    id?: string;
+    logic: 'and' | 'or';
+    conditions: BuilderCondition[];
+}
+export type FilterCondition = Record<string, any>;
+/** Serialize the visual group → a spec FilterCondition (flat `$and`). */
+export declare function groupToCondition(group: BuilderGroup | undefined): FilterCondition | undefined;
+/**
+ * Parse a stored FilterCondition → the visual group. `representable: false` when
+ * the condition uses shapes the flat builder can't faithfully edit (nested
+ * `$and`/`$or`, multi-op objects, unmapped operators) — callers should then show
+ * the source editor instead.
+ */
+export declare function conditionToGroup(cond: FilterCondition | undefined | null): {
+    group: BuilderGroup;
+    representable: boolean;
+};

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

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * Bridge between the visual {@link FilterBuilder} (a flat `FilterGroup` of
+ * `{field, operator, value}` rows, camelCase operators) and the spec
+ * `FilterCondition` (Mongo-style `{ field: { $op: value } }`, conjoined with
+ * `$and`) stored on `dataset.filter` / `measure.filter`.
+ *
+ * Scope (deliberate): the visual editor supports the common case — a flat AND
+ * of simple `field op value` conditions. Anything it can't faithfully round-trip
+ * (nested groups, `$or`, multi-operator objects, unmapped operators) is reported
+ * as NOT representable so the caller can fall back to the source editor instead
+ * of silently corrupting the author's filter.
+ */
+/** FilterBuilder camelCase operator → FilterCondition Mongo operator. */
+const OP_TO_MONGO = {
+    equals: '$eq', notEquals: '$ne',
+    greaterThan: '$gt', greaterOrEqual: '$gte', lessThan: '$lt', lessOrEqual: '$lte',
+    after: '$gt', before: '$lt',
+    contains: '$contains', in: '$in', notIn: '$nin',
+};
+const MONGO_TO_OP = {
+    $eq: 'equals', $ne: 'notEquals',
+    $gt: 'greaterThan', $gte: 'greaterOrEqual', $lt: 'lessThan', $lte: 'lessOrEqual',
+    $contains: 'contains', $in: 'in', $nin: 'notIn',
+};
+/** Serialize the visual group → a spec FilterCondition (flat `$and`). */
+export function groupToCondition(group) {
+    const conds = (group?.conditions ?? []).filter((c) => c && c.field);
+    const parts = [];
+    for (const c of conds) {
+        if (c.operator === 'isEmpty') {
+            parts.push({ [c.field]: { $exists: false } });
+            continue;
+        }
+        if (c.operator === 'isNotEmpty') {
+            parts.push({ [c.field]: { $exists: true } });
+            continue;
+        }
+        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 } });
+    }
+    if (parts.length === 0)
+        return undefined;
+    if (parts.length === 1)
+        return parts[0];
+    return { $and: parts };
+}
+/**
+ * Parse a stored FilterCondition → the visual group. `representable: false` when
+ * the condition uses shapes the flat builder can't faithfully edit (nested
+ * `$and`/`$or`, multi-op objects, unmapped operators) — callers should then show
+ * the source editor instead.
+ */
+export function conditionToGroup(cond) {
+    const empty = { id: 'g', logic: 'and', conditions: [] };
+    if (cond == null)
+        return { group: empty, representable: true };
+    if (typeof cond !== 'object' || Array.isArray(cond))
+        return { group: empty, representable: false };
+    if ('$or' in cond)
+        return { group: empty, representable: false };
+    const list = Array.isArray(cond.$and) ? cond.$and : [cond];
+    const conditions = [];
+    for (let i = 0; i < list.length; i++) {
+        const c = list[i];
+        if (!c || typeof c !== 'object' || Array.isArray(c))
+            return { group: empty, representable: false };
+        if ('$and' in c || '$or' in c)
+            return { group: empty, representable: false };
+        const keys = Object.keys(c);
+        if (keys.length !== 1)
+            return { group: empty, representable: false };
+        const field = keys[0];
+        const v = c[field];
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            const opKeys = Object.keys(v);
+            if (opKeys.length !== 1)
+                return { group: empty, representable: false };
+            const mop = opKeys[0];
+            if (mop === '$exists') {
+                conditions.push({ id: `c${i}`, field, operator: v.$exists ? 'isNotEmpty' : 'isEmpty', value: '' });
+            }
+            else {
+                const op = MONGO_TO_OP[mop];
+                if (!op)
+                    return { group: empty, representable: false };
+                conditions.push({ id: `c${i}`, field, operator: op, value: v[mop] });
+            }
+        }
+        else {
+            conditions.push({ id: `c${i}`, field, operator: 'equals', value: v }); // implicit equality
+        }
+    }
+    return { group: { id: 'g', logic: 'and', conditions }, representable: true };
+}

package/dist/views/metadata-admin/inspectors/expression-validate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Author-time expression validation for the metadata inspectors (ADR-0032).
+ *
+ * The GUI is a first-class author surface, so the same rule the build and the
+ * `validate_expression` agent tool enforce must surface *here, as you type* —
+ * not only on save/build. The #1 mistake (human or AI) is wrapping a field
+ * reference in single `{…}` braces inside a CEL condition: `{x}` parses as a
+ * CEL map literal and silently fails (issue #1491). We catch that and a couple
+ * of other obvious shape errors, with the **same corrective message** the
+ * server-side validator emits.
+ *
+ * NOTE: this is an intentionally small client-side check (no CEL parser in the
+ * browser). Once `@objectstack/formula` is published, swap the body of
+ * {@link validateExpressionClient} for a call to its shared `validateExpression`
+ * so the GUI, SDK, and CLI share one validator verbatim.
+ */
+export type ExprFieldRole = 'predicate' | 'value' | 'template';
+export interface ExprClientIssue {
+    /** Self-correcting message: what is wrong + the correct form. */
+    message: string;
+}
+/**
+ * Validate one expression for a field role. Returns `null` when clean, or an
+ * issue with a corrective message. Empty/absent input is always clean.
+ */
+export declare function validateExpressionClient(role: ExprFieldRole, raw: unknown): ExprClientIssue | null;

package/dist/views/metadata-admin/inspectors/expression-validate.js

@@ -0,0 +1,66 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/** A bare `{x}` that is NOT part of a `{{x}}` mustache hole. */
+const SINGLE_BRACE_RE = /(?:^|[^{])\{\s*([A-Za-z_$][\w.$]*)\s*\}(?!\})/;
+function balanced(src, open, close) {
+    let depth = 0;
+    for (const ch of src) {
+        if (ch === open)
+            depth++;
+        else if (ch === close) {
+            depth--;
+            if (depth < 0)
+                return false;
+        }
+    }
+    return depth === 0;
+}
+/**
+ * Validate one expression for a field role. Returns `null` when clean, or an
+ * issue with a corrective message. Empty/absent input is always clean.
+ */
+export function validateExpressionClient(role, raw) {
+    // Accept a bare string or an Expression envelope ({ dialect, source }).
+    let source = '';
+    let dialect;
+    if (typeof raw === 'string')
+        source = raw;
+    else if (raw && typeof raw === 'object') {
+        const env = raw;
+        dialect = env.dialect;
+        source = env.source ?? '';
+    }
+    if (!source.trim())
+        return null;
+    if (role === 'template') {
+        if (dialect && dialect !== 'template') {
+            return { message: `Expected a text template but got a \`${dialect}\` expression.` };
+        }
+        if (!balanced(source.replace(/\{\{/g, '').replace(/\}\}/g, ''), '{', '}')) {
+            // crude: only flag obviously single-brace mustache misuse below
+        }
+        const m = SINGLE_BRACE_RE.exec(source);
+        if (m) {
+            return { message: `Single-brace \`{${m[1]}}\` is not a valid template hole — use double braces: \`{{ ${m[1]} }}\`.` };
+        }
+        return null;
+    }
+    // predicate | value → CEL
+    if (dialect && dialect !== 'cel') {
+        return { message: `Expected a CEL expression but got a \`${dialect}\` dialect.` };
+    }
+    const m = SINGLE_BRACE_RE.exec(source);
+    if (m) {
+        return {
+            message: `It looks like a \`{${m[1]}}\` template brace was used inside a condition — ` +
+                `\`{…}\` parses as a CEL map literal and fails. Write the bare reference instead, e.g. \`${m[1]}\`. ` +
+                `Conditions are bare CEL (e.g. \`record.rating >= 4\`).`,
+        };
+    }
+    if (!balanced(source, '(', ')')) {
+        return { message: `Unbalanced parentheses in \`${source}\`.` };
+    }
+    if (!balanced(source, '[', ']')) {
+        return { message: `Unbalanced brackets in \`${source}\`.` };
+    }
+    return null;
+}

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

@@ -0,0 +1,143 @@
+/**
+ * flow-node-config — declarative, spec-precise config-field schema per flow
+ * node type.
+ *
+ * Node types and the structured config blocks below mirror the authoritative
+ * `@objectstack/spec` FlowNode schema (automation/flow.zod.ts): the type enum
+ * is the spec's `FlowNodeAction`, and spec-schematized blocks — `waitEventConfig`
+ * (wait), `connectorConfig` (connector_action), `boundaryConfig`
+ * (boundary_event) and the node-level `timeoutMs` — are edited as precise form
+ * fields rather than free JSON.
+ *
+ * Each field declares a `path` into the node object. Most CRUD/script/http
+ * fields live under `['config', key]` (the spec's freeform, type-specific
+ * config record); spec-structured blocks live at the node top level, e.g.
+ * `['waitEventConfig', 'eventType']`. Only fields whose path is rooted at
+ * `config` "own" a config key — any *other* config keys remain editable in the
+ * optional Advanced block so authors are never locked out.
+ *
+ * Field kinds: scalar (text / expression / number / boolean / select),
+ * `textarea` (script code, request body) and `keyValue` for flat object maps
+ * (e.g. record field values, connector input). Deeply nested / array values
+ * still fall back to the optional Advanced block.
+ */
+export type FlowConfigFieldKind = 'text' | 'expression' | 'number' | 'boolean' | 'select' | 'textarea' | 'keyValue' | 'stringList' | 'objectList' | 'reference';
+/**
+ * What a `reference` field points at — the picker's data source. The control
+ * is always an *editable* combobox (suggestions + free text), so an unknown /
+ * not-yet-created value is never rejected and an empty catalog degrades to a
+ * plain text box.
+ *
+ *   • `object`        → a business object, by API name (`client.list('object')`)
+ *   • `object-field`  → a field of some object; the object is resolved via
+ *                       {@link FlowReferenceSpec.objectSource}
+ *   • `flow`          → a flow, by name (`client.list('flow')`)
+ *   • `role`          → a security role (`client.list('role')`)
+ *   • `node`          → another node in *this* flow, by id (read from the draft)
+ *   • `user` / `team` / `queue` / `department` → the matching metadata list
+ *                       (`client.list(kind)`); empty in dev, populated per tenant
+ *   • `connector`     → an installed connector (`client.list('connector')`)
+ *   • `email-template`→ an email template (`client.list('email_template')`)
+ *
+ * Kinds that have no catalog in the current tenant simply degrade to a plain
+ * text box — the control is always an editable combobox, never a hard dropdown.
+ */
+export type ReferenceKind = 'object' | 'object-field' | 'flow' | 'role' | 'node' | 'user' | 'team' | 'queue' | 'department' | 'connector' | 'email-template';
+export interface FlowReferenceSpec {
+    /**
+     * Concrete reference kind. Omit when the kind is *polymorphic* — chosen at
+     * render time from a sibling value (see {@link kindFrom}).
+     */
+    kind?: ReferenceKind;
+    /**
+     * For `object-field` only: where to find the target object's name.
+     *   • `'$trigger'` (default) → the flow trigger object, read from the start
+     *     node's `config.objectName` (the record an approval / record node acts on).
+     *   • any other string       → a sibling config key on the *same* node holding
+     *     the object name (e.g. CRUD nodes resolve from their own `objectName`).
+     */
+    objectSource?: string;
+    /**
+     * Polymorphic reference: the kind is selected at render time by the value of
+     * a sibling field/column named `kindFrom`, looked up in {@link map}. A value
+     * with no mapping (or an empty sibling) falls back to free text. Used by the
+     * approval node's `approvers[].value` (kind follows the row's `type`) and the
+     * script node's `template` (follows `actionType`).
+     */
+    kindFrom?: string;
+    map?: Record<string, ReferenceKind>;
+}
+/** Column descriptor for an `objectList` repeater row. */
+export interface FlowConfigColumn {
+    key: string;
+    label: string;
+    kind: 'text' | 'expression' | 'boolean' | 'select' | 'reference';
+    placeholder?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /** For `kind: 'reference'` — the picker data source (may be polymorphic). */
+    ref?: FlowReferenceSpec;
+}
+export interface FlowConfigField {
+    /**
+     * Stable field identity — used as the React key and as the `showWhen.field`
+     * reference. Distinct from the storage path so nested-path fields stay
+     * unambiguous (e.g. `wait.timerDuration`).
+     */
+    id: string;
+    /**
+     * Location of this value on the node object. `['config', 'objectName']`
+     * writes `node.config.objectName`; `['waitEventConfig', 'eventType']` writes
+     * the spec's top-level `node.waitEventConfig.eventType`.
+     */
+    path: string[];
+    /** Human-readable field label (English — repo is English-only). */
+    label: string;
+    kind: FlowConfigFieldKind;
+    placeholder?: string;
+    /** Options for `select` fields. */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /** One-line helper hint shown under the control. */
+    help?: string;
+    /** Spec default, used when resolving `showWhen` against an unset controller. */
+    defaultValue?: string;
+    /**
+     * Conditional visibility: only render this field when the controlling field
+     * (referenced by its `id`) currently resolves to one of `equals`. A field is
+     * always shown if it already holds a stored value, so existing config is
+     * never hidden.
+     */
+    showWhen?: {
+        field: string;
+        equals: string[];
+    };
+    /** Column schema for `objectList` fields (array-of-objects repeater). */
+    columns?: FlowConfigColumn[];
+    /** Reference target for `reference` fields — drives the combobox data source. */
+    ref?: FlowReferenceSpec;
+}
+/** 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. */
+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
+ * `config` (spec-structured blocks, top-level `timeoutMs`). Used by the
+ * inspector to compute "extra" config keys for the optional Advanced block —
+ * only config-rooted fields suppress an Advanced key.
+ */
+export declare function configKeyOf(field: FlowConfigField): string | undefined;
+/**
+ * Whether a field should render. Conditional fields show when their controller
+ * (by `id`) resolves — via stored value, else spec `defaultValue` — to one of
+ * `equals`, OR when the field already holds a stored value (so existing config
+ * is never hidden).
+ */
+export declare function isFieldVisible(field: FlowConfigField, node: Record<string, unknown> | null | undefined, fields: FlowConfigField[]): boolean;
+/** Node types offered in the inspector's type picker (spec `FlowNodeAction`). */
+export declare const FLOW_NODE_TYPE_OPTIONS: readonly ["start", "create_record", "update_record", "delete_record", "get_record", "decision", "assignment", "loop", "http_request", "script", "screen", "approval", "wait", "subflow", "map", "connector_action", "parallel", "try_catch", "end"];