@uipath/maestro-builder-sdk 6.66.3 → 6.66.4

package/dist/decompile.js

@@ -48,6 +48,7 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
+import { referencedBindingNames } from './core/contribution-bindings.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -89,6 +90,8 @@ let runRawManifests = [];
  * definition and the node keeps its version even when the author edits it.
  */
 let runCarried = new Map();
+/** The file's top-level `bindings[]` rows, by id, for {@link resolveTemplateBindings}. */
+let runBindings = new Map();
 let runStrict = false;
 /** `DecompileOptions.warn` for the current run, and the messages already sent to it (one line per finding). */
 let runWarn;
@@ -1040,6 +1043,81 @@ function emitEventSubscription(node, imp, inputNames) {
         ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
+/**
+ * The definition a `rawNode` carries for `node`. A per-tenant template
+ * (`<bindings.NAME>` placeholders, empty `resourceKey`) comes back as a copy
+ * resolved with the node's own key and defaults (#1512); any other `def` comes
+ * back unchanged.
+ *
+ * For instance, a template context row `queueName: "<bindings.name>"`, on a node
+ * whose `queueName` row is `=bindings.bQueueName`, takes `bQueueName`'s
+ * `resourceKey` and `default`. The placeholders stay, for compile to close.
+ *
+ * `reason` says why a template was left unresolved, when the node is bound but
+ * not fully: compile's refusal names only the empty key, not what the node lacks.
+ */
+function resolveTemplateBindings(def, node) {
+    const model = def?.model;
+    const names = referencedBindingNames(model);
+    const resource = model?.bindings?.resource;
+    if (names.length === 0 || typeof resource !== 'string' || !resource || resource === 'connection')
+        return { def };
+    if (typeof model.bindings.resourceKey === 'string' && model.bindings.resourceKey)
+        return { def };
+    const nodeModel = node.model;
+    const nodeContext = Array.isArray(nodeModel?.context) ? nodeModel.context : [];
+    const nodeValues = Array.isArray(nodeModel?.bindings?.values) ? nodeModel.bindings.values : [];
+    const keys = new Map();
+    const defaults = new Map();
+    const missing = [];
+    for (const name of names) {
+        // Matched by the context row's own `name` (`queueName`): the canvas rewrites its value.
+        const fields = model.context.filter((c) => c?.value === `<bindings.${name}>`).map((c) => c?.name);
+        const ref = nodeContext.find((c) => fields.includes(c?.name) && typeof c?.value === 'string');
+        const id = typeof ref?.value === 'string' ? /^=bindings\.(.+)$/.exec(ref.value)?.[1] : undefined;
+        const row = id !== undefined ? runBindings.get(id) : undefined;
+        let key = row?.resource === resource ? row.resourceKey : undefined;
+        let value = row?.resource === resource ? row.default : undefined;
+        if (typeof key !== 'string' || !key)
+            key = nodeModel?.bindings?.resource === resource ? nodeModel.bindings.resourceKey : undefined;
+        if (typeof value !== 'string')
+            value = nodeValues.find((v) => v?.name === name)?.default;
+        if (typeof key === 'string' && key)
+            keys.set(name, key);
+        else
+            missing.push(`no resourceKey for "${name}"`);
+        if (typeof value === 'string')
+            defaults.set(name, value);
+        else
+            missing.push(`no default for "${name}"`);
+    }
+    const label = `node "${node.id}" (${def?.nodeType}@${def?.version})`;
+    // Nothing bound at all: compile's own refusal already says what to do.
+    if (keys.size === 0 && defaults.size === 0)
+        return { def };
+    if (missing.length > 0) {
+        return { def, reason: `${label} is bound to a ${resource}, but its binding has ${missing.join(', ')}, so its definition stays the template.` };
+    }
+    const distinct = [...new Set(keys.values())];
+    if (distinct.length !== 1) {
+        const each = [...keys].map(([n, k]) => `"${n}" → ${k}`).join(', ');
+        return { def, reason: `${label} names more than one ${resource} (${each}), so its definition stays the template.` };
+    }
+    const values = Array.isArray(model.bindings.values) ? model.bindings.values : [];
+    return {
+        def: {
+            ...def,
+            model: {
+                ...model,
+                bindings: {
+                    ...model.bindings,
+                    resourceKey: distinct[0],
+                    values: values.map((v) => (defaults.has(v?.name) ? { ...v, default: defaults.get(v.name) } : v)),
+                },
+            },
+        },
+    };
+}
 /** Best-effort placeholder for a node type the reverse-map does not yet cover. */
 function unsupportedSpec(node, imp, o) {
     // The file's own definition for this node — the manifest the platform served.
@@ -1053,7 +1131,10 @@ function unsupportedSpec(node, imp, o) {
         // `mock()` for a flow that genuinely contains one.
         const constName = `${camel(node.id)}Definition`;
         if (!runRawManifests.some(([n]) => n === constName)) {
-            runRawManifests.push([constName, JSON.stringify(def, null, 2)]);
+            const resolved = resolveTemplateBindings(def, node);
+            if (resolved.reason !== undefined)
+                warnOnce(resolved.reason);
+            runRawManifests.push([constName, JSON.stringify(resolved.def, null, 2)]);
         }
         const inputs = node.inputs ?? {};
         const inputsSrc = Object.keys(inputs).length > 0 ? JSON.stringify(inputs, null, 2) : undefined;
@@ -2937,6 +3018,11 @@ export function decompile(flow, options = {}) {
             runDefs.set(d.nodeType, d);
     }
     runCarried = carriedPairs(flow);
+    // Best effort: a malformed `bindings` section (not an array) indexes nothing.
+    const rows = flow.bindings;
+    runBindings = new Map((Array.isArray(rows) ? rows : [])
+        .filter((b) => typeof b?.id === 'string')
+        .map((b) => [b.id, b]));
     const imp = new Imports();
     const graph = new Graph(flow.nodes ?? [], flow.edges ?? [], flow.variables);
     const globals = readFlowGlobals(flow.variables, runStrict);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.66.3",
+  "version": "6.66.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "e7e32040e5596319cf1bccea2a6caa9124d79bbb"
+  "gitref": "af11f232febf9ed683dec9f44b4ae7fe3c2426fe"
 }