@uipath/maestro-builder-sdk 6.49.2 → 6.49.3

package/dist/core/connector-inputs.js

@@ -106,10 +106,12 @@ export function buildConnectorInputs(rc, inputs, opts) {
     // container the runtime composes from `bodyParameters`, so it is listed without
     // a value and is never an author input — see `readFields` in core/library.ts.
     const partValues = new Map();
+    const bare = bareArraySpellings(fields, byName);
     for (const f of fields) {
-        const flat = Object.prototype.hasOwnProperty.call(inputs, f.name);
+        const flatKey = flatInputKey(inputs, f.name, bare, dialect);
+        const flat = flatKey !== undefined;
         let nested = flat
-            ? { found: true, value: inputs[f.name], projectedArrays: 0 }
+            ? { found: true, value: inputs[flatKey], projectedArrays: 0 }
             : readConnectorPath(inputs, f.name, dialect);
         if (!nested.found) {
             // A required LOOKUP field is missing far more often because the author does
@@ -326,6 +328,51 @@ function place(target, parts, index, value) {
     target[part.key] = next;
     place(next, parts, index + 1, value);
 }
+/**
+ * The flat key the product writes for each array LEAF field, by its wire name:
+ * `fields.components_arrayRemap_name` for `fields.components_arrayRemap_name[*]`.
+ *
+ * Product-authored flows key `bodyParameters` either way (86 Slack
+ * `create-group-direct-message` nodes in the eval archive, almost all from the v1
+ * CLI arm, carry bare `users`; 85 carry `users[*]`; a Studio Web save in
+ * #1402 carried a bare Jira key), and the runtime reads both the same for an array
+ * value (flow-v1 `convertDotNotationToNested`). The nested reader already strips
+ * the marker, so `{ users: [...] }` compiled, but a DOTTED bare key reached only
+ * the exact flat lookup and was refused as unknown — so a designer-saved Jira
+ * flow decompiled to source that did not compile back (#1402).
+ *
+ * Only a trailing `[*]` with none before it: `contacts.id` is not `contacts[*].id`
+ * (the runtime nests it as an object, not a list). A bare name that is itself a
+ * declared field keeps its own meaning.
+ */
+function bareArraySpellings(fields, declared) {
+    const bare = new Map();
+    for (const f of fields) {
+        if (!f.name.endsWith('[*]'))
+            continue;
+        const key = f.name.slice(0, -3);
+        if (key.includes('[*]') || declared.has(key))
+            continue;
+        bare.set(f.name, key);
+    }
+    return bare;
+}
+/**
+ * The flat key `inputs` carries field `name` under: its wire name, or its bare
+ * spelling when the value there is an array or opaque. A bare SCALAR is left to
+ * the nested reader, which refuses it ("expected array"), as before: under
+ * `users[*]` the runtime would wrap `"U1,U2"` into `["U1,U2"]`, a different
+ * request from the one the bare key sends.
+ */
+function flatInputKey(inputs, name, bare, dialect) {
+    if (Object.prototype.hasOwnProperty.call(inputs, name))
+        return name;
+    const key = bare.get(name);
+    if (key === undefined || !Object.prototype.hasOwnProperty.call(inputs, key))
+        return undefined;
+    const value = inputs[key];
+    return Array.isArray(value) || dialect.isOpaque(value) ? key : undefined;
+}
 function connectorPath(name) {
     return name.split('.').map((raw) => ({
         key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,
@@ -385,6 +432,7 @@ function buildConnectorInputTrie(fields) {
 function validateNestedConnectorKeys(fields, inputs, exact, dialect) {
     const root = buildConnectorInputTrie(fields);
     const errs = [];
+    const bare = new Set(bareArraySpellings(fields, exact).values());
     const visit = (value, node, path) => {
         if (dialect.isOpaque(value))
             return;
@@ -422,6 +470,13 @@ function validateNestedConnectorKeys(fields, inputs, exact, dialect) {
         if (exact.has(key))
             continue; // backwards-compatible flat authoring
         const node = root.children.get(key);
+        // A dotted bare array key (`fields.labels` for `fields.labels[*]`); a
+        // top-level one (`users`) is a trie child and is checked by `visit` below.
+        if (!node && bare.has(key)) {
+            if (!Array.isArray(value) && !dialect.isOpaque(value))
+                errs.push(`input "${key}" expected array, got ${typeof value}`);
+            continue;
+        }
         if (!node) {
             const near = nearestField(key, [...exact.keys()]);
             errs.push(`unknown input "${key}"${near ? ` — did you mean "${near}"?` : ''}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.49.2",
+  "version": "6.49.3",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "72292af393e64e04ffe0ce42e31992e3ea9a3980"
+  "gitref": "0187c4bea37cd0a8fd78aae6125b040583097f96"
 }