@uipath/maestro-builder-sdk 6.4.0 → 6.5.0

package/dist/registry/library-build/plan.js

@@ -0,0 +1,270 @@
+/**
+ * The pure half of `write_library`: which files the library consists of and
+ * what each one holds, before anything touches the disk.
+ *
+ * A plan is a map from POSIX-relative path to file text (every text produced by
+ * `pyJsonDocument`, i.e. `json.dump(indent=2)` + newline), the sorted index
+ * rows, and the warnings the collision protocol raised. `write.ts` puts it on
+ * disk; a test compares it in memory.
+ */
+import { pyJsonDocument } from "../codecs/pyjson.js";
+import { sortedByKeys } from "../compat/compare.js";
+import { pyStr } from "../compat/pystr.js";
+import { messageOf } from "../errors.js";
+import { SCHEMA_VERSION, actionIdFromNodeType } from "./canonical.js";
+import { get, isRecord, item, pyEquals, pyIter, pyOr, truthy } from "./py.js";
+export { actionIdFromNodeType };
+/** `_safe_path_segment`: sanitize a string for use as one path segment. */
+export function safePathSegment(s) {
+    return s.replace(/[^a-zA-Z0-9_.\-]+/g, "_") || "_";
+}
+/**
+ * `_input_field_count`: how much of a schema an entry carries — the tie-break
+ * when two claim one path, since whichever loses is dropped from the catalogue.
+ */
+export function inputFieldCount(entry) {
+    return pyIter(pyOr(get(pyOr(get(entry, "inputSchema"), {}), "fields"), [])).length;
+}
+/**
+ * `_entry_relpath`: where to write `entry` relative to the library root, sans
+ * extension, `/`-separated. Expanded Generic entries land under
+ * `<connector>/generic/<object>/<op>@<ver>`; per-object EVENT variants under
+ * `<connector>/events/<object>/<action>@<ver>` (they keep the template's
+ * nodeType, so the object is what separates them).
+ */
+export function entryRelpath(entry) {
+    const connectorKey = pyStr(pyOr(item(item(entry, "connector"), "key"), "unknown"));
+    const version = pyStr(pyOr(item(entry, "version"), "0.0.0"));
+    const operation = item(entry, "operation");
+    if (get(operation, "activityType") === "GenericExpanded") {
+        const obj = safePathSegment(pyStr(pyOr(item(operation, "objectName"), "object")));
+        const op = safePathSegment(pyStr(pyOr(item(operation, "name"), "op")).toLowerCase());
+        return `${connectorKey}/generic/${obj}/${op}@${version}`;
+    }
+    const actionId = actionIdFromNodeType(item(entry, "nodeType"));
+    if (get(operation, "activityType") === "GenericTrigger" && truthy(get(operation, "objectName"))) {
+        const obj = safePathSegment(pyStr(item(operation, "objectName")));
+        return `${connectorKey}/events/${obj}/${actionId}@${version}`;
+    }
+    return `${connectorKey}/${actionId}@${version}`;
+}
+/**
+ * `_build_v1_definition`: project a registry `Data.Node` into the shape a
+ * `.flow` file expects under `definitions[]`: drop `connectorMethodInfo` and
+ * `outputResponseDefinition`, add the three fields the editor stamps on every
+ * connector definition when absent (`setdefault`: a present `null` stays).
+ */
+export function buildV1Definition(nodeData) {
+    if (!isRecord(nodeData))
+        throw new TypeError(`'${nodeData === null ? "NoneType" : typeof nodeData}' object has no attribute 'items'`);
+    const keep = {};
+    for (const [k, v] of Object.entries(nodeData)) {
+        if (k !== "connectorMethodInfo" && k !== "outputResponseDefinition")
+            keep[k] = v;
+    }
+    if (!("supportsErrorHandling" in keep))
+        keep.supportsErrorHandling = true;
+    if (!("inputDefaults" in keep))
+        keep.inputDefaults = {};
+    if (!("debug" in keep))
+        keep.debug = { runtime: "bpmnEngine" };
+    return keep;
+}
+/**
+ * `write_library` without the disk.
+ *
+ * Collision protocol, per relpath: an identical second entry is skipped; one
+ * with fewer-or-equal input fields is skipped with a warning; a richer one
+ * replaces the earlier (its index row is dropped, its files are overwritten).
+ * The sidecar is projected from the node the loader answers, with the entry's
+ * resolved input fields stamped in (always for an expanded Generic node,
+ * otherwise only when the entry has any) and its `eventSchema` stamped in when
+ * present. Index rows carry `objectFromDiscovery` only when set.
+ */
+export function planLibrary(entries, loadNode, opts = {}) {
+    const files = new Map();
+    const index = [];
+    const warnings = [];
+    const claimed = new Map();
+    let written = 0;
+    /**
+     * `pyJsonDocument` for one file of one entry, naming the entry if it refuses.
+     *
+     * Both of an entry's writes are fatal (see the sidecar note below), and this
+     * runs over thousands of entries, so the refusal has to say which one it was
+     * about. `pyJsonDocument`'s own message is about a KEY — "object key "0"
+     * looks like an integer" — which tells an operator reading a pipeline log
+     * nothing about where to look. The catch adds the connector, the node type
+     * and the path, and rethrows; it never turns the failure into a warning.
+     */
+    const document = (value, path, label) => {
+        try {
+            return pyJsonDocument(value);
+        }
+        catch (exc) {
+            throw new Error(`cannot write ${path} for ${label}: ${messageOf(exc)}`);
+        }
+    };
+    for (const entry of entries) {
+        const connectorKey = pyOr(item(item(entry, "connector"), "key"), "unknown");
+        const version = pyOr(item(entry, "version"), "0.0.0");
+        const relpath = entryRelpath(entry);
+        const previous = claimed.get(relpath);
+        if (previous !== undefined) {
+            if (pyEquals(previous, entry))
+                continue;
+            const before = inputFieldCount(previous);
+            const now = inputFieldCount(entry);
+            if (now <= before) {
+                warnings.push(`  WARN: ${relpath} claimed by two differing entries; keeping the one with more inputs (${before} vs ${now})`);
+                continue;
+            }
+            // This one is richer — drop the row already recorded for it.
+            warnings.push(`  WARN: ${relpath} claimed by two differing entries; replacing the thinner one (${before} -> ${now})`);
+            const entryPath = `${relpath}.json`;
+            for (let i = index.length - 1; i >= 0; i--)
+                if (index[i].path === entryPath)
+                    index.splice(i, 1);
+            written -= 1;
+        }
+        claimed.set(relpath, entry);
+        const label = `${pyStr(pyOr(get(entry, "nodeType"), "?"))} (connector ${pyStr(connectorKey)}, version ${pyStr(version)})`;
+        files.set(`${relpath}.json`, document(entry, `${relpath}.json`, label));
+        written += 1;
+        // Flow definition sidecar. Expanded Generic entries reuse the source
+        // Generic action's `Data.Node` as a TEMPLATE.
+        const operation = item(entry, "operation");
+        const expanded = get(operation, "activityType") === "GenericExpanded";
+        const lookupKey = expanded ? get(operation, "sourceNodeType") : item(entry, "nodeType");
+        // Built inside the try, SERIALIZED outside it. The Python's `except
+        // Exception` turned any sidecar failure into a WARN, and for the failures
+        // it could actually meet — a node that would not load, an
+        // `inputDefinition` that is not a dict — that is reproduced below. But
+        // `pyJsonDocument` also refuses an object whose key order JavaScript has
+        // already lost (an integer-like key), and that refusal is this port's, not
+        // the Python's: the Python wrote the file. It makes the ENTRY write above
+        // fatal, so it must make the sidecar fatal too — a WARN there would leave
+        // a silently missing `.v1def.json` that `compile` trips over later. Both
+        // writes go through `document`, so the fatal message names the entry
+        // instead of leaving the operator with the JSON writer's own text.
+        let v1def;
+        try {
+            const nodeData = typeof lookupKey === "string" ? loadNode(lookupKey) : undefined;
+            if (truthy(nodeData)) {
+                v1def = buildV1Definition(nodeData);
+                // The entry's fields are the node's own plus whatever the parameters
+                // filled in — a superset of a verbatim projection — so prefer them
+                // whenever there are any. An expanded Generic node stamps even an
+                // empty list: its template's fields belong to the dispatch node.
+                const resolvedFields = pyOr(get(get(entry, "inputSchema", {}), "fields"), []);
+                if (expanded || truthy(resolvedFields)) {
+                    if (!("inputDefinition" in v1def))
+                        v1def.inputDefinition = {};
+                    const inputDefinition = v1def.inputDefinition;
+                    if (!isRecord(inputDefinition)) {
+                        throw new TypeError(`'${inputDefinition === null ? "NoneType" : typeof inputDefinition}' object does not support item assignment`);
+                    }
+                    // Stamp onto a COPY. `buildV1Definition` is shallow, so this block is
+                    // still the loader's own; the Python wrote into it in place and got
+                    // away with it only because `_load_node_data` re-read the file for
+                    // every entry. A loader here may answer one shared object (an
+                    // in-memory cache does), and writing through would hand the first
+                    // entry's fields to every later sidecar built from the same node.
+                    // The spread keeps `fields` in its existing position, as the
+                    // in-place write did.
+                    v1def.inputDefinition = { ...inputDefinition, fields: resolvedFields };
+                }
+                // A per-object EVENT variant carries its own subscription vocabulary,
+                // and this sidecar is where the SDK reads one.
+                const eventSchema = pyOr(get(entry, "eventSchema"), {});
+                if (truthy(eventSchema)) {
+                    v1def.eventParameters = { fields: pyOr(get(eventSchema, "eventParameters"), []) };
+                    v1def.filterFields = { fields: pyOr(get(eventSchema, "filterFields"), []) };
+                    for (const fact of ["eventMode", "byoaConnection", "isWebhookUrlVisible"]) {
+                        if (get(eventSchema, fact) !== null)
+                            v1def[fact] = eventSchema[fact];
+                    }
+                }
+            }
+        }
+        catch (exc) {
+            v1def = undefined;
+            warnings.push(`  WARN: v1def write failed for ${pyStr(item(entry, "nodeType"))}: ${messageOf(exc)}`);
+        }
+        if (v1def !== undefined) {
+            files.set(`${relpath}.v1def.json`, document(v1def, `${relpath}.v1def.json`, label));
+        }
+        const row = {
+            nodeType: item(entry, "nodeType"),
+            version: version,
+            connectorKey: connectorKey,
+            label: item(item(entry, "display"), "label"),
+            activityType: get(operation, "activityType", ""),
+            // `objectName` disambiguates expansions that share a nodeType.
+            objectName: pyOr(get(operation, "objectName", ""), ""),
+            operationName: pyOr(get(operation, "name", ""), ""),
+            path: `${relpath}.json`,
+        };
+        // `registry search` reads only this index; emitted only when set, so every
+        // other row stays byte-identical.
+        if (truthy(get(operation, "objectFromDiscovery")))
+            row.objectFromDiscovery = true;
+        index.push(row);
+    }
+    // Sort for stable diffs; many expanded entries share the source Generic
+    // nodeType, so `path` breaks ties.
+    const sorted = sortedByKeys(index, (r) => pyStr(r.connectorKey), (r) => pyStr(r.nodeType), (r) => pyStr(r.version), (r) => r.path);
+    files.set("index.json", pyJsonDocument({ schemaVersion: opts.schemaVersion ?? SCHEMA_VERSION, entries: sorted }));
+    return { files, index: sorted, warnings, written };
+}
+/** Files that live in a library directory without being entries. */
+const NOT_ENTRIES = new Set(["index.json", "list-envelopes.json", "invariant-collections.json", ".registry-source.json"]);
+/**
+ * Every entry file in `files` that has no index row: an empty list is the
+ * invariant `write_library` used to break (index one row longer than the
+ * directory). Sidecars and the known non-entry files are exempt.
+ */
+export function orphanCheck(files, index) {
+    const indexed = new Set(index.map((row) => row.path));
+    return [...files.keys()].filter((path) => !NOT_ENTRIES.has(path) && !path.endsWith(".v1def.json") && !indexed.has(path));
+}
+// ---------------------------------------------------------------------------
+// The trigger side-file
+// ---------------------------------------------------------------------------
+const TRIGGER_PREFIX = "uipath.connector.trigger.";
+/**
+ * `write_triggers_side_file`'s rows: every trigger nodeType the registry
+ * search exposed, sorted by `(connectorKey, NodeType)`.
+ */
+export function triggerRows(searchPayload) {
+    const rows = [];
+    for (const entry of pyIter(pyOr(get(searchPayload, "Data", []), []))) {
+        const nodeType = get(entry, "NodeType", "");
+        if (typeof nodeType !== "string")
+            throw new TypeError(`'${nodeType === null ? "NoneType" : typeof nodeType}' object has no attribute 'startswith'`);
+        if (!nodeType.startsWith(TRIGGER_PREFIX))
+            continue;
+        const parts = nodeType.split(".");
+        rows.push({
+            NodeType: nodeType,
+            DisplayName: get(entry, "DisplayName", ""),
+            Description: get(entry, "Description", ""),
+            Version: get(entry, "Version", ""),
+            connectorKey: parts.length > 3 ? parts[3] : "",
+        });
+    }
+    return sortedByKeys(rows, (t) => t.connectorKey, (t) => t.NodeType);
+}
+export const TRIGGER_CATALOGUE_NOTE = "Catalog of every IS trigger nodeType returned by " +
+    "`uip maestro flow registry search --filter tags:in=connector`. " +
+    "Full per-trigger schemas (filterFields, outputFields, eventMode) " +
+    "require `--connection-id` on `uip flow registry get`, which " +
+    "the library generator can't supply across all ~70 " +
+    "trigger-supporting connectors. Use this side-file for the " +
+    "'does an IS trigger exist for X provider?' question; fetch the " +
+    "full schema at author time with `uip is triggers describe " +
+    "<connector-key> <op> <object> --connection-id <id>`.";
+/** The side-file's text: the envelope around the rows, `json.dump(indent=2)` + newline. */
+export function triggerCatalogueDocument(rows) {
+    return pyJsonDocument({ schemaVersion: "1", note: TRIGGER_CATALOGUE_NOTE, count: rows.length, triggers: rows });
+}

package/dist/registry/library-build/py.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Python value semantics the generator leaned on without saying so.
+ *
+ * `generate_library_json.py` reads JSON the platform served and decides what to
+ * write with `or`, `if not x`, `dict.get(k, default)` and `==`. Each of those
+ * differs from its JavaScript spelling on exactly the values the registry
+ * serves — `[]` and `{}` are falsy in Python, a present `null` is not "absent"
+ * to `dict.get`, and two dicts compare equal in any key order. The port spells
+ * each rule once here so every call site can read like the line it replaces.
+ */
+export type Dict = Record<string, unknown>;
+/** A plain JSON object: what `json.load` calls a dict. */
+export declare function isRecord(value: unknown): value is Dict;
+/** `bool(value)` for a JSON-shaped value. */
+export declare function truthy(value: unknown): boolean;
+/** `a or b or …`: the first truthy operand, else the last one. */
+export declare function pyOr<T>(...values: T[]): T;
+/**
+ * `d.get(key, default)`. A present key answers its value even when that value
+ * is `null`; an absent key answers `dflt`, which is `null` (Python's `None`)
+ * unless given — never `undefined`, because `undefined` would vanish from the
+ * written JSON where Python would have written `null`.
+ *
+ * Calling `.get` on a non-dict raises in Python, and does here.
+ */
+export declare function get(d: unknown, key: string, dflt?: unknown): unknown;
+/** `d[key]`: raises on a missing key the way Python's `KeyError` does. */
+export declare function item(d: unknown, key: string): unknown;
+/** `for x in value`: a list yields items, a dict its keys, a string its characters. */
+export declare function pyIter(value: unknown): unknown[];
+/**
+ * `a == b` on JSON-loaded values: dicts compare by key set and value, in any
+ * order; lists element by element; `True == 1` as in Python.
+ */
+export declare function pyEquals(a: unknown, b: unknown): boolean;
+/** `json.loads(json.dumps(value))`: the generator's deep copy, JSON-shaped values only. */
+export declare function deepCopy<T>(value: T): T;
+/** `repr(str)`: single quotes unless the text holds one and no double quote. */
+export declare function pyReprStr(s: string): string;
+/** `repr(list_of_str)`: `['a', 'b']`. */
+export declare function pyReprStrList(items: readonly string[]): string;
+/** `s[start:end]` by code point. */
+export declare function codePointSlice(s: string, start: number, end?: number): string;
+/** `str.partition(sep)`. */
+export declare function partition(s: string, sep: string): [string, string, string];

package/dist/registry/library-build/py.js

@@ -0,0 +1,167 @@
+/**
+ * Python value semantics the generator leaned on without saying so.
+ *
+ * `generate_library_json.py` reads JSON the platform served and decides what to
+ * write with `or`, `if not x`, `dict.get(k, default)` and `==`. Each of those
+ * differs from its JavaScript spelling on exactly the values the registry
+ * serves — `[]` and `{}` are falsy in Python, a present `null` is not "absent"
+ * to `dict.get`, and two dicts compare equal in any key order. The port spells
+ * each rule once here so every call site can read like the line it replaces.
+ */
+/** A plain JSON object: what `json.load` calls a dict. */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map);
+}
+/** `bool(value)` for a JSON-shaped value. */
+export function truthy(value) {
+    if (value === null || value === undefined || value === false || value === "")
+        return false;
+    if (typeof value === "number")
+        return value !== 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value instanceof Map)
+        return value.size > 0;
+    if (typeof value === "object")
+        return Object.keys(value).length > 0;
+    return true;
+}
+/** `a or b or …`: the first truthy operand, else the last one. */
+export function pyOr(...values) {
+    for (const value of values)
+        if (truthy(value))
+            return value;
+    return values[values.length - 1];
+}
+/**
+ * Does the dict itself hold `key`? — `key in d` for a Python dict.
+ *
+ * NOT JavaScript's `in`, which walks the prototype chain: `"constructor" in
+ * {}` and `"toString" in {}` are both true, so `get(node, "constructor")`
+ * would answer `Object`'s constructor FUNCTION where `dict.get` answers
+ * `None`, and `item()` would hand back a function instead of raising
+ * `KeyError`. Either one puts a function where the caller expects JSON, and
+ * `pyJsonStringify` then refuses to serialize it — a build that dies on a
+ * connector field named `constructor`. The event buckets were moved to a `Map`
+ * for this same reason (`events.ts`); these helpers are the shared version of
+ * the hazard, reached by every `get`/`item` in the generator.
+ */
+function hasKey(d, key) {
+    return Object.prototype.hasOwnProperty.call(d, key);
+}
+/**
+ * `d.get(key, default)`. A present key answers its value even when that value
+ * is `null`; an absent key answers `dflt`, which is `null` (Python's `None`)
+ * unless given — never `undefined`, because `undefined` would vanish from the
+ * written JSON where Python would have written `null`.
+ *
+ * Calling `.get` on a non-dict raises in Python, and does here.
+ */
+export function get(d, key, dflt = null) {
+    if (!isRecord(d)) {
+        throw new TypeError(`'${pyTypeName(d)}' object has no attribute 'get'`);
+    }
+    if (!hasKey(d, key))
+        return dflt;
+    const value = d[key];
+    return value === undefined ? dflt : value;
+}
+/** `d[key]`: raises on a missing key the way Python's `KeyError` does. */
+export function item(d, key) {
+    if (!isRecord(d)) {
+        throw new TypeError(`'${pyTypeName(d)}' object is not subscriptable`);
+    }
+    if (!hasKey(d, key) || d[key] === undefined)
+        throw new Error(`KeyError: '${key}'`);
+    return d[key];
+}
+/** `for x in value`: a list yields items, a dict its keys, a string its characters. */
+export function pyIter(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "string")
+        return [...value];
+    if (value instanceof Map)
+        return [...value.keys()];
+    if (isRecord(value))
+        return Object.keys(value);
+    throw new TypeError(`'${pyTypeName(value)}' object is not iterable`);
+}
+function pyTypeName(value) {
+    if (value === null || value === undefined)
+        return "NoneType";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    return "dict";
+}
+/**
+ * `a == b` on JSON-loaded values: dicts compare by key set and value, in any
+ * order; lists element by element; `True == 1` as in Python.
+ */
+export function pyEquals(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a === "boolean" && typeof b === "number")
+        return Number(a) === b;
+    if (typeof a === "number" && typeof b === "boolean")
+        return a === Number(b);
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, i) => pyEquals(item, b[i]));
+    }
+    if (isRecord(a) && isRecord(b)) {
+        const keysA = Object.keys(a).filter((k) => a[k] !== undefined);
+        const keysB = Object.keys(b).filter((k) => b[k] !== undefined);
+        if (keysA.length !== keysB.length)
+            return false;
+        // `hasKey`, not `k in b`, for the reason given on it: `"toString" in b` is
+        // true for every object, so the prototype could answer for a key the dict
+        // does not carry.
+        return keysA.every((k) => hasKey(b, k) && pyEquals(a[k], b[k]));
+    }
+    return false;
+}
+/** `json.loads(json.dumps(value))`: the generator's deep copy, JSON-shaped values only. */
+export function deepCopy(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/** `repr(str)`: single quotes unless the text holds one and no double quote. */
+export function pyReprStr(s) {
+    const quote = s.includes("'") && !s.includes('"') ? '"' : "'";
+    let out = quote;
+    for (const ch of s) {
+        if (ch === "\\")
+            out += "\\\\";
+        else if (ch === quote)
+            out += `\\${quote}`;
+        else if (ch === "\n")
+            out += "\\n";
+        else if (ch === "\r")
+            out += "\\r";
+        else if (ch === "\t")
+            out += "\\t";
+        else
+            out += ch;
+    }
+    return out + quote;
+}
+/** `repr(list_of_str)`: `['a', 'b']`. */
+export function pyReprStrList(items) {
+    return `[${items.map(pyReprStr).join(", ")}]`;
+}
+/** `s[start:end]` by code point. */
+export function codePointSlice(s, start, end) {
+    return [...s].slice(start, end).join("");
+}
+/** `str.partition(sep)`. */
+export function partition(s, sep) {
+    const at = s.indexOf(sep);
+    return at < 0 ? [s, "", ""] : [s.slice(0, at), sep, s.slice(at + sep.length)];
+}

package/dist/registry/library-build/schema-action.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `schema_action` and `_order_by_dependency`: the design-time action that
+ * resolves an operation's REAL field set, recorded as what a caller has to do.
+ *
+ * Some operations do not have one field list. Jira `create-issue` describes to
+ * 2 fields with nothing supplied — just the parents that select the schema —
+ * and to 32 once a project and an issue type are given. Studio Web runs the
+ * connector's api-type ObjectAction automatically as those parents change, and
+ * `uip is resources describe -f name=value` ports the same call. Neither is
+ * discoverable from the catalog, because the library drops
+ * `connectorMethodInfo.design`; this is what keeps the recipe.
+ */
+import { type Dict } from "./py.js";
+/**
+ * Cascade order for parent fields: a parent another one needs comes first.
+ *
+ * The action's `rules` are not in cascade order — Jira lists
+ * `fields.issuetype.id` before `fields.project.key` — but the order is
+ * recoverable, because the dependent field's own lookup path carries the
+ * other's name (`/project/{fields.project.key}/issuetypes`). `dependsOn` is
+ * honoured too where a connector sets it. Layers are emitted in `parents`
+ * order, and a cycle emits the rest rather than looping.
+ */
+export declare function orderByDependency(parents: readonly string[], fields: readonly unknown[]): string[];
+/**
+ * The `operation.schemaAction` record, or `null` when the node declares none:
+ *
+ * - `parents`  the fields whose values select the schema, in cascade order
+ * - `trigger`  a rule field carrying no `refFieldValues` is a button, not
+ *              data: Salesforce's `generateSchema` has to be invoked
+ *              explicitly, whereas Jira fires on the parents alone
+ * - `replaces` which half the result replaces — `input`, `output` or `both`
+ *
+ * A node can declare more than one api action; the smallest parent set wins,
+ * ties keeping declaration order (SAP OData offers GenerateSchemaWithExpand
+ * beside GenerateSchema, and the first read would demand `$expand`).
+ */
+export declare function schemaAction(connectorMethodInfo: unknown, inputFields: readonly unknown[]): Dict | null;

package/dist/registry/library-build/schema-action.js

@@ -0,0 +1,107 @@
+/**
+ * `schema_action` and `_order_by_dependency`: the design-time action that
+ * resolves an operation's REAL field set, recorded as what a caller has to do.
+ *
+ * Some operations do not have one field list. Jira `create-issue` describes to
+ * 2 fields with nothing supplied — just the parents that select the schema —
+ * and to 32 once a project and an issue type are given. Studio Web runs the
+ * connector's api-type ObjectAction automatically as those parents change, and
+ * `uip is resources describe -f name=value` ports the same call. Neither is
+ * discoverable from the catalog, because the library drops
+ * `connectorMethodInfo.design`; this is what keeps the recipe.
+ */
+import { get, isRecord, pyIter, pyOr, truthy } from "./py.js";
+/**
+ * Cascade order for parent fields: a parent another one needs comes first.
+ *
+ * The action's `rules` are not in cascade order — Jira lists
+ * `fields.issuetype.id` before `fields.project.key` — but the order is
+ * recoverable, because the dependent field's own lookup path carries the
+ * other's name (`/project/{fields.project.key}/issuetypes`). `dependsOn` is
+ * honoured too where a connector sets it. Layers are emitted in `parents`
+ * order, and a cycle emits the rest rather than looping.
+ */
+export function orderByDependency(parents, fields) {
+    const depends = new Map();
+    for (const field of fields) {
+        const name = get(field, "name");
+        if (typeof name !== "string" || !parents.includes(name))
+            continue;
+        const reference = pyOr(get(field, "reference"), {});
+        const path = String(pyOr(get(reference, "path"), ""));
+        const explicit = pyOr(get(reference, "dependsOn"), []);
+        const explicitList = pyIter(explicit);
+        depends.set(name, new Set(parents.filter((other) => other !== name && (path.includes(`{${other}}`) || explicitList.includes(other)))));
+    }
+    const ordered = [];
+    let remaining = [...parents];
+    while (remaining.length > 0) {
+        const remainingSet = new Set(remaining);
+        const free = remaining.filter((p) => ![...(depends.get(p) ?? new Set())].some((d) => remainingSet.has(d)));
+        if (free.length === 0) {
+            ordered.push(...remaining);
+            break;
+        }
+        ordered.push(...free);
+        remaining = remaining.filter((p) => !free.includes(p));
+    }
+    return ordered;
+}
+/**
+ * The `operation.schemaAction` record, or `null` when the node declares none:
+ *
+ * - `parents`  the fields whose values select the schema, in cascade order
+ * - `trigger`  a rule field carrying no `refFieldValues` is a button, not
+ *              data: Salesforce's `generateSchema` has to be invoked
+ *              explicitly, whereas Jira fires on the parents alone
+ * - `replaces` which half the result replaces — `input`, `output` or `both`
+ *
+ * A node can declare more than one api action; the smallest parent set wins,
+ * ties keeping declaration order (SAP OData offers GenerateSchemaWithExpand
+ * beside GenerateSchema, and the first read would demand `$expand`).
+ */
+export function schemaAction(connectorMethodInfo, inputFields) {
+    const design = pyOr(get(pyOr(connectorMethodInfo, {}), "design"), {});
+    const candidates = [];
+    for (const action of pyIter(pyOr(get(design, "actions"), []))) {
+        if (get(action, "actionType") !== "api")
+            continue;
+        const parents = [];
+        let trigger = null;
+        for (const rule of pyIter(pyOr(get(action, "rules"), []))) {
+            const name = get(rule, "refFieldName");
+            if (!truthy(name))
+                continue;
+            if (truthy(get(rule, "refFieldValues")))
+                parents.push(name);
+            else if (trigger === null)
+                trigger = name;
+        }
+        if (parents.length === 0)
+            continue;
+        candidates.push({ action: action, parents, trigger });
+    }
+    if (candidates.length === 0)
+        return null;
+    let chosen = candidates[0];
+    for (const candidate of candidates)
+        if (candidate.parents.length < chosen.parents.length)
+            chosen = candidate;
+    const { action, parents, trigger } = chosen;
+    const remap = pyOr(get(pyOr(get(action, "onSuccess"), {}), "remapConfiguration"), {});
+    const record = {
+        name: pyOr(get(action, "name"), ""),
+        parents: orderByDependency(parents, inputFields),
+    };
+    if (truthy(trigger))
+        record.trigger = trigger;
+    const replacesInput = isRecord(remap) && get(remap, "input") === "replace";
+    const replacesOutput = isRecord(remap) && get(remap, "output") === "replace";
+    if (replacesInput && replacesOutput)
+        record.replaces = "both";
+    else if (replacesInput)
+        record.replaces = "input";
+    else if (replacesOutput)
+        record.replaces = "output";
+    return record;
+}

package/dist/registry/library-build/write.d.ts

@@ -0,0 +1,6 @@
+import type { TriggerCatalogueRow } from "../model/library.js";
+import { type LibraryPlan } from "./plan.js";
+/** Write the plan under `outputDir` (removed first). Returns the entry count, as `write_library` did. */
+export declare function writePlan(plan: LibraryPlan, outputDir: string): number;
+/** Write the trigger catalogue to `outputPath`, creating its directory. Returns the row count. */
+export declare function writeTriggerSideFile(rows: readonly TriggerCatalogueRow[], outputPath: string): number;

package/dist/registry/library-build/write.js

@@ -0,0 +1,26 @@
+/**
+ * Putting a {@link LibraryPlan} on disk, the way `write_library` did: the
+ * output directory is removed first, then every planned file is written under
+ * it. The trigger side-file goes wherever the caller says.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { triggerCatalogueDocument } from "./plan.js";
+/** Write the plan under `outputDir` (removed first). Returns the entry count, as `write_library` did. */
+export function writePlan(plan, outputDir) {
+    if (existsSync(outputDir))
+        rmSync(outputDir, { recursive: true, force: true });
+    mkdirSync(outputDir, { recursive: true });
+    for (const [relative, text] of plan.files) {
+        const path = join(outputDir, ...relative.split("/"));
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, text, "utf8");
+    }
+    return plan.written;
+}
+/** Write the trigger catalogue to `outputPath`, creating its directory. Returns the row count. */
+export function writeTriggerSideFile(rows, outputPath) {
+    mkdirSync(dirname(outputPath) || ".", { recursive: true });
+    writeFileSync(outputPath, triggerCatalogueDocument(rows), "utf8");
+    return rows.length;
+}