@uipath/maestro-builder-sdk 6.38.0 → 6.39.0

package/dist/bpmn/check.js

@@ -67,6 +67,7 @@ export function check(built, opts = {}) {
     checkVariableOrder(built, diags);
     checkDocumentIds(built, diags);
     checkFolderBindings(built, diags);
+    checkIntsvcActivities(built, diags);
     checkEntryPointId(built, diags);
     checkMethodParentheses(built, diags);
     checkConnectorRows(built, diags);
@@ -380,6 +381,242 @@ function checkFolderBindings(built, diags) {
         }
     }
 }
+/** The `method` vocabulary of the Integration Service activity catalog (`MethodName`). */
+const INTSVC_METHODS = new Set(['GET', 'GETBYID', 'POST', 'PUT', 'PATCH', 'DELETE']);
+/** The catalog's identity fields on an `Intsvc.ActivityExecution` task, in the order the message names them. */
+const INTSVC_IDENTITY = ['connectorKey', 'objectName', 'operation', 'method', 'path'];
+/**
+ * A hand-filled `Intsvc.ActivityExecution` task: what the catalog, the refresh and
+ * the runtime require of its context that `uip maestro bpmn validate` does not report.
+ *
+ * `.connector()` and `.dataService()` write this task from the library; an author
+ * who reaches for `.activity(id, 'Intsvc.ActivityExecution', …)` — the route the skill
+ * names for a connector the library lacks — fills the identity rows by hand from
+ * `uip is activities list <key>`, and the 2026-10-16 eval run measured what goes wrong
+ * (141 SDK-authored files, 109 such tasks): `objectName: 'N/A'` and `method: 'N/A'`
+ * copied from the catalog's GENERIC rows (5 tasks — `validate` reported them Valid, and
+ * they dispatch to nothing), an empty `operation` (5), `<METHOD_FROM_CLI>`-style template
+ * placeholders left in place, and a `connection` that `uip maestro bpmn refresh` then
+ * refused with `connection must reference a root binding as "=bindings.<id>"`.
+ *
+ * What the registry's own field notes say the rows are: `operation` is the catalog
+ * activity's `Name`, `objectName` its `ObjectName`, `method` its `MethodName`, `path` the
+ * request path `is resources describe` returns, and `connection` "points to a root binding
+ * for a Connection resource" with `folderKey` a second binding for the same key. Real
+ * exports agree on the shape and differ on one spelling: `operation` is the catalog Name
+ * on the canvas (`UpdateEntityRecordV2`) and the CRUD verb in 94 of 108 hand-written v1
+ * tasks (`Create`, `Retrieve`), so that field is held to "an identifier", not a list.
+ * `method` IS a closed list: GET, GETBYID, POST, PUT, PATCH, DELETE, measured over every
+ * task in both arms and the corpus.
+ *
+ * Errors where the task cannot dispatch or the platform refuses it; warnings where it
+ * deploys but the SDK cannot tell it is right.
+ */
+function checkIntsvcActivities(built, diags) {
+    // The bindings the compiled process will carry: the ones declared with `.binding()`,
+    // and the ones `serialize` synthesizes for every `.connector()`, `.eventTrigger()` /
+    // `.waitForEvent()` and external task from the symbolic names they read (ids equal
+    // to the names, `connector.ts` `bindingRef`) — a hand-filled task may reuse those.
+    const declared = new Map(built.bindings.map((b) => [b.id, { resource: String(b.resource ?? ''), propertyAttribute: String(b.propertyAttribute ?? '') }]));
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'connector' && n.kind !== 'connectorEvent' && n.kind !== 'externalTask')
+            continue;
+        if (n.connection && !declared.has(n.connection))
+            declared.set(n.connection, { resource: 'Connection', propertyAttribute: 'ConnectionId' });
+        if (n.folder && !declared.has(n.folder))
+            declared.set(n.folder, { resource: 'Connection', propertyAttribute: 'folderKey' });
+    }
+    const expr = (v) => typeof v === 'string' && v.startsWith('=');
+    const text = (v) => (typeof v === 'string' ? v : v === undefined || v === null ? undefined : String(v));
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'typed' || n.type !== 'Intsvc.ActivityExecution')
+            continue;
+        // `contextRows`, when given, REPLACE `context` at emission (typed-node.ts), so only
+        // the rows are the task's context then; a record field beside them is not emitted.
+        const ctx = {};
+        if (n.contextRows)
+            for (const row of n.contextRows)
+                ctx[row.name] = row.value ?? row.body ?? '';
+        else
+            Object.assign(ctx, n.context);
+        const where = n.id;
+        const key = text(ctx['connectorKey']) ?? '<connector-key>';
+        // 1. A catalog placeholder: `N/A` from a generic row, or a template's `<…>`.
+        for (const field of INTSVC_IDENTITY) {
+            const v = text(ctx[field]);
+            if (v === undefined)
+                continue;
+            const placeholder = /^n\/a$/i.test(v.trim()) || /^(<|&lt;)[^<>]*(>|&gt;)$/.test(v.trim());
+            if (!placeholder)
+                continue;
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_CATALOG_PLACEHOLDER',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", which dispatches to nothing. ` +
+                    (/^n\/a$/i.test(v.trim())
+                        ? `"N/A" is what \`uip is activities list ${key}\` prints on a GENERIC record verb (Create/Retrieve/Update/Delete Record), ` +
+                            `whose object is chosen at design time: set objectName to an object from \`uip is resources list ${key} --connection-id <id>\`, ` +
+                            `method to that verb's HTTP method, and path from \`uip is resources describe ${key} <object> --operation <Verb> --connection-id <id>\`. ` +
+                            `For a curated activity, objectName and method are the row's ObjectName and MethodName.`
+                        : `Replace the placeholder with the catalog's value (\`uip is activities list ${key} --output json\`: Name → operation, ObjectName → objectName, MethodName → method; ` +
+                            `\`uip is resources describe\` → path).`) +
+                    ` Or let the library write the task: \`uip maestro registry prepare ${key} --action <name>\` then \`.connector()\`.`,
+                where,
+            });
+        }
+        // 2. `method` is the catalog's closed vocabulary.
+        const method = text(ctx['method']);
+        // An empty one is EMPTY_REQUIRED_FIELD's (the registry marks it required), as for `operation`.
+        if (method !== undefined && method.trim() !== '' && !expr(method) && !/^n\/a$/i.test(method.trim()) && !/^(<|&lt;)/.test(method.trim()) && !INTSVC_METHODS.has(method.trim())) {
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_METHOD_UNKNOWN',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has method="${method}"; the activity catalog's MethodName is one of ` +
+                    `${[...INTSVC_METHODS].join(', ')}` +
+                    (INTSVC_METHODS.has(method.trim().toUpperCase()) ? ` — write it in upper case: "${method.trim().toUpperCase()}".` : `. Read it from \`uip is activities list ${key} --output json\` (MethodName).`),
+                where,
+            });
+        }
+        // 3. `operation` is the catalog activity's Name (or the CRUD verb hand-written exports use): an identifier.
+        const operation = text(ctx['operation']);
+        if (operation !== undefined && operation.trim() !== '' && !expr(operation) && !/^n\/a$/i.test(operation.trim()) && !/^(<|&lt;)/.test(operation.trim())
+            && !/^[A-Za-z][A-Za-z0-9_]*$/.test(operation.trim())) {
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_OPERATION_NOT_IDENTIFIER',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has operation="${operation}"; the registry defines it as the activity catalog's Name ` +
+                    `(\`uip is activities list ${key}\`: CreateTestSet, QueryEntityRecordsCurated) — an identifier, not a REST slug or a label.`,
+                where,
+            });
+        }
+        // 4. `objectName` spelled as a REST path: validates, dispatches to nothing. Only a
+        // `/` says so — `::` is in curated ObjectNames too (`v2::webSearch`, airdk).
+        const objectName = text(ctx['objectName']);
+        if (objectName !== undefined && !expr(objectName) && objectName.includes('/')) {
+            diags.push({
+                level: 'warning',
+                code: 'INTSVC_OBJECT_NAME_SLUG',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has objectName="${objectName}", which reads as a REST path, not an object. The platform matches ` +
+                    `on the catalog's ObjectName (\`uip is activities list ${key}\`: TestSet, UploadAttachment, v2::webSearch); a path validates and then dispatches to nothing.`,
+                where,
+            });
+        }
+        // 5. The path's placeholders each need a `target: 'path'` input row of that name.
+        const path = text(ctx['path']);
+        if (path !== undefined && !expr(path)) {
+            if (!path.startsWith('/')) {
+                diags.push({
+                    level: 'warning',
+                    code: 'INTSVC_PATH_NOT_ABSOLUTE',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) has path="${path}"; the request path \`is resources describe\` returns starts with "/" (e.g. "/v2/{ProjectId}/testsets").`,
+                    where,
+                });
+            }
+            const params = [...path.matchAll(/\{([^{}]+)\}/g)].map((m) => m[1]);
+            if (params.length > 0) {
+                // Bound by a row of that name targeting the path, or by a path AGGREGATE —
+                // `inputs: { pathParameters: { ProjectId } }` emits one `target="pathParameters"`
+                // row holding every placeholder (an expression-valued aggregate binds them all).
+                const PATH_TARGETS = new Set(['path', 'pathvariable', 'pathparameters']);
+                const bound = new Set();
+                let aggregateExpression = false;
+                const aggregate = (value) => {
+                    if (expr(value))
+                        aggregateExpression = true;
+                    else if (value && typeof value === 'object')
+                        for (const k of Object.keys(value))
+                            bound.add(k);
+                };
+                for (const r of n.inputRows ?? []) {
+                    const target = (r.target ?? '').toLowerCase();
+                    if (target === 'pathparameters' || target === 'pathvariable' || PATH_TARGETS.has(r.name.toLowerCase()))
+                        aggregate(r.body ?? r.value);
+                    if (PATH_TARGETS.has(target))
+                        bound.add(r.name);
+                }
+                if (!n.inputRows)
+                    for (const key of ['pathParameters', 'pathVariable'])
+                        if (key in (n.inputs ?? {}))
+                            aggregate(n.inputs[key]);
+                const unbound = aggregateExpression ? [] : params.filter((p) => !bound.has(p));
+                if (unbound.length > 0) {
+                    diags.push({
+                        level: 'warning',
+                        code: 'INTSVC_PATH_PARAM_UNBOUND',
+                        message: `"${n.id}" (Intsvc.ActivityExecution) path "${path}" has placeholder(s) ${unbound.map((p) => `{${p}}`).join(', ')} with no input row ` +
+                            `of that name targeting the path. Write \`inputs: { pathParameters: { ${unbound[0]}: '…' } }\` (the other fields stay ` +
+                            `beside it), or an \`inputRows\` row \`{ name: '${unbound[0]}', type: 'string', value: '…', target: 'path' }\` — a bare ` +
+                            `\`inputs: { ${unbound[0]} }\` lands in the body and leaves the placeholder unfilled.`,
+                        where,
+                    });
+                }
+            }
+        }
+        // 6. The connection and folder rows: binding references to declared Connection bindings.
+        const bindingRow = (field, attribute) => {
+            const v = text(ctx[field]);
+            if (v === undefined || v.trim() === '')
+                return;
+            if (!v.startsWith('=bindings.')) {
+                // A literal gets the binding to declare with that value; any other
+                // expression (`=vars.connId`) is told what refresh needs instead — a
+                // connection is resolved from a root binding, never computed at run time.
+                const label = field === 'connection' ? 'conn' : 'folder';
+                const refusal = `\`uip maestro bpmn refresh\` refuses it with \`${field} must reference a root binding as "=bindings.<id>"\``;
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_CONNECTION_NOT_BINDING',
+                    message: expr(v)
+                        ? `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", an expression; ${refusal}. A ${field} is resolved from a root binding, ` +
+                            `not computed: declare \`.binding('${label}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '<${field === 'connection' ? 'connection id' : 'folder key'}>' })\` ` +
+                            `and write ${field}: '=bindings.${label}'.`
+                        : `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", a literal; ${refusal}. Declare ` +
+                            `\`.binding('${label}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '${v}' })\` ` +
+                            `and write ${field}: '=bindings.${label}'.`,
+                    where,
+                });
+                return;
+            }
+            const id = v.slice('=bindings.'.length);
+            const b = declared.get(id);
+            if (!b) {
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_BINDING_UNDECLARED',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) reads ${field}="${v}" but the process declares no binding "${id}" ` +
+                        `(\`uip maestro bpmn validate\` reports MISSING_BINDING). Declare it at the root: ` +
+                        `\`.binding('${id}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '<${field === 'connection' ? 'connection id' : 'folder key'}>' })\`` +
+                        (field === 'folderKey' ? ' — keyed by its connection; the builder pairs it with the connection this task reads.' : '.'),
+                    where,
+                });
+                return;
+            }
+            const attr = b.propertyAttribute;
+            const resource = b.resource;
+            if (attr.toLowerCase() !== attribute.toLowerCase() || resource.toLowerCase() !== 'connection') {
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_BINDING_MISMATCH',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) reads ${field}="${v}", but binding "${id}" is resource "${resource}" / ` +
+                        `propertyAttribute "${attr}"; the ${field} row needs resource "Connection" / propertyAttribute "${attribute}".`,
+                    where,
+                });
+            }
+        };
+        bindingRow('connection', 'ConnectionId');
+        bindingRow('folderKey', 'folderKey');
+        if (text(ctx['connection']) === undefined) {
+            diags.push({
+                level: 'warning',
+                code: 'INTSVC_CONNECTION_MISSING',
+                message: `"${n.id}" (Intsvc.ActivityExecution) names no connection. The registry says to omit \`connection\` and \`folderKey\` only ` +
+                    `when the activity uses none; a connector activity almost always does. Declare a Connection binding and read it as ` +
+                    `connection: '=bindings.<id>' (\`uip is connections list ${key} --all-folders --output json\` lists the ids).`,
+                where,
+            });
+        }
+    }
+}
 /**
  * Every `id` in the document must be unique — including across KINDS.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.38.0",
+  "version": "6.39.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "56a00223262864847db6153351a39d877939abb7"
+  "gitref": "df5d45c8b0eb17d5a82da37146e5b8130be03fab"
 }