@uipath/maestro-sdk 1.199.0 → 1.201.0-preview.115

package/dist/bpmn-validation/project-validator.js

@@ -444,20 +444,24 @@ var bpmn_spec_default = {
       extensionTag: "uipath:activity",
       contextFields: [
         {
-          name: "activity",
-          displayName: "Activity",
+          name: "activityConfigurationVersion",
+          displayName: "Activity configuration version",
           type: "string",
-          required: true,
-          hidden: false,
-          isPrimaryKey: true,
+          required: false,
+          hidden: true,
+          isPrimaryKey: false,
           binding: false,
-          defaultValue: null
+          defaultValue: "v1",
+          enum: [
+            "v1"
+          ],
+          description: "Marks the Integration Service activity format used by this template"
         },
         {
           name: "connectorKey",
           displayName: "Connector key",
           type: "string",
-          required: false,
+          required: true,
           hidden: true,
           isPrimaryKey: false,
           binding: false,
@@ -471,7 +475,12 @@ var bpmn_spec_default = {
           hidden: true,
           isPrimaryKey: false,
           binding: true,
-          defaultValue: null
+          defaultValue: null,
+          bindingInfo: {
+            resource: "Connection",
+            resourceKeyPattern: "${resourceKey}",
+            propertyAttribute: "ConnectionId"
+          }
         },
         {
           name: "folderKey",
@@ -480,61 +489,105 @@ var bpmn_spec_default = {
           required: false,
           hidden: true,
           isPrimaryKey: false,
+          binding: true,
+          defaultValue: null,
+          bindingInfo: {
+            resource: "Connection",
+            resourceKeyPattern: "${resourceKey}",
+            propertyAttribute: "folderKey"
+          }
+        },
+        {
+          name: "operation",
+          displayName: "Operation",
+          type: "string",
+          required: true,
+          hidden: true,
+          isPrimaryKey: true,
           binding: false,
-          defaultValue: null
+          defaultValue: null,
+          description: "Activity catalog Name used as the runtime operation"
+        },
+        {
+          name: "objectName",
+          displayName: "Object name",
+          type: "string",
+          required: true,
+          hidden: true,
+          isPrimaryKey: false,
+          binding: false,
+          defaultValue: null,
+          description: "Activity catalog ObjectName"
         },
         {
           name: "method",
           displayName: "Method",
           type: "string",
-          required: false,
+          required: true,
           hidden: true,
           isPrimaryKey: false,
           binding: false,
-          defaultValue: null
+          defaultValue: null,
+          description: "Activity catalog MethodName"
         },
         {
           name: "path",
           displayName: "Path",
           type: "string",
+          required: true,
+          hidden: true,
+          isPrimaryKey: false,
+          binding: false,
+          defaultValue: null,
+          description: "Request path returned by resource metadata"
+        },
+        {
+          name: "metadata",
+          displayName: "Metadata",
+          type: "json",
           required: false,
           hidden: true,
           isPrimaryKey: false,
           binding: false,
-          defaultValue: null
+          defaultValue: {},
+          description: "Optional activity metadata"
         }
       ],
+      inputFields: [],
       inputPattern: "separateInputs",
       inputName: "body",
       inputTarget: "body",
-      outputSource: ".",
-      outputType: "custom",
-      outputName: "result",
+      outputSource: "=response",
+      outputType: "jsonSchema",
+      outputName: "response",
       useRelativeSource: false,
       bindingPattern: "connection",
       requiresDiscovery: true,
       isDynamic: true,
-      xmlTemplate: `<bpmn:SendTask id="{id}" name="{name}">
+      xmlTemplate: `<bpmn:sendTask id="{id}" name="{name}">
   <bpmn:extensionElements>
     <uipath:activity version="v1">
       <uipath:type value="Intsvc.ActivityExecution" version="v1" />
       <uipath:context>
-        <uipath:input name="activity" value="{activity}" />
-        <uipath:input name="connectorKey" value="{connectorKey}" />
-        <uipath:input name="connection" value="=bindings.{bindingId}" />
-        <uipath:input name="folderKey" value="{folderKey}" />
-        <uipath:input name="method" value="{method}" />
-        <uipath:input name="path" value="{path}" />
+        <uipath:input name="connectorKey" type="string" value="{connectorKey}" />
+        <uipath:input name="connection" type="string" value="=bindings.{connectionBindingId}" />
+        <uipath:input name="folderKey" type="string" value="=bindings.{folderBindingId}" />
+        <uipath:input name="operation" type="string" value="{operation}" />
+        <uipath:input name="objectName" type="string" value="{objectName}" />
+        <uipath:input name="method" type="string" value="{method}" />
+        <uipath:input name="path" type="string" value="{path}" />
+        <uipath:input name="activityConfigurationVersion" type="string" value="v1" />
+        <uipath:input name="metadata" type="json"><![CDATA[{}]]></uipath:input>
       </uipath:context>
-      <uipath:input name="body" type="json" target="body"><![CDATA[{}]]></uipath:input>
-      <uipath:output name="result" type="custom" source="." var="{varId}" />
+      <uipath:output name="response" type="jsonSchema" source="=response" var="{varId}" />
     </uipath:activity>
   </bpmn:extensionElements>
   <bpmn:incoming>{incomingEdge}</bpmn:incoming>
   <bpmn:outgoing>{outgoingEdge}</bpmn:outgoing>
-</bpmn:SendTask>`,
-      discoveryNotes: "Uses getConnectorConnections(connectorKey) to list available connections. Activity/connector metadata comes from Integration Service catalog.",
-      inputNotes: "isSplitInputs=false in design schema; inputs are sent as separate <uipath:input> elements, not merged into a single JSON body",
+</bpmn:sendTask>`,
+      discoveryNotes: "Use `uip is activities list <connector-key> --output json` to select an activity. Set operation from Name, then describe ObjectName to get its current path, parameters, and fields.",
+      inputNotes: "Add each request field from the selected operation as its own uipath:input. Keep the field's type and target: path, query, body, or file.",
+      contextFieldNotes: "connection points to a root binding for a Connection resource. When folder scoping is required, folderKey points to a second binding for the same resourceKey. Use propertyAttribute ConnectionId for connection and folderKey for folderKey. Omit folderKey when the selected activity has no folder scoping, and omit both fields only when it does not use a connection.",
       extensionTagNotes: "In isExecution array, NOT in isEvents array, so uses uipath:activity"
     },
     "Intsvc.HttpExecution": {
@@ -2995,10 +3048,18 @@ var SUPPORTED_UIPATH_EXTENSION_TAG_NAMES = Object.freeze([
 ].sort());
 var SUPPORTED_UIPATH_EXTENSION_TAGS = Object.freeze(SUPPORTED_UIPATH_EXTENSION_TAG_NAMES.map((tag) => `uipath:${tag}`));
 
+// ../common/src/guid.ts
+var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isGuid(value) {
+  return GUID_REGEX.test(value);
+}
+
 // src/bpmn-validation/project-validator.ts
 var KNOWN_UIPATH_TAGS = new Set(SUPPORTED_UIPATH_EXTENSION_TAGS);
 var SEMANTIC_VALIDATION_ERROR = "BPMN_VALIDATION_ERROR";
 var BPMN_MODEL_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/MODEL";
+var ACTIVITY_CONFIGURATION_VERSION = "activityConfigurationVersion";
+var ACTIVITY_CONFIGURATION_V1 = "v1";
 
 class BpmnValidateService {
   fileSystem;
@@ -3102,11 +3163,30 @@ class BpmnValidateService {
           instruction: "Add a bpmn:StartEvent to each process."
         });
       }
+      this.validateRootEntryPointIds(file, process, diagnostics);
     }
     const availableBindings = new Map(bindings);
     collectInlineBindings(definitions, availableBindings);
     this.validateUiPathTags(file, definitions, availableBindings, diagnostics);
   }
+  validateRootEntryPointIds(file, process, diagnostics) {
+    const rootStartEvents = findChildren(process, (node) => hasLocalName(node, "startEvent"));
+    for (const startEvent of rootStartEvents) {
+      const entryPointIds = findDescendants(startEvent, (node) => node.name === "uipath:entryPointId");
+      for (const entryPointId of entryPointIds) {
+        const value = entryPointId.attributes.value ?? "";
+        if (isGuid(value)) {
+          continue;
+        }
+        diagnostics.push({
+          file,
+          element: describeElement(startEvent),
+          message: `Root start event uipath:entryPointId value "${value}" must be a GUID.`,
+          instruction: "Set uipath:entryPointId value to a GUID and use the same value for the matching entry-points.json uniqueId."
+        });
+      }
+    }
+  }
   validateUiPathTags(file, root, bindings, diagnostics) {
     const uipathNodes = findDescendants(root, (node) => node.name.startsWith("uipath:"));
     for (const node of uipathNodes) {
@@ -3120,12 +3200,25 @@ class BpmnValidateService {
         });
       }
     }
+    for (const loopCharacteristics of uipathNodes.filter((node) => node.name === "uipath:loopCharacteristics")) {
+      const extensionElements = loopCharacteristics.parent;
+      const owner = extensionElements && hasLocalName(extensionElements, "extensionElements") ? extensionElements.parent : undefined;
+      if (owner && hasLocalName(owner, "multiInstanceLoopCharacteristics")) {
+        continue;
+      }
+      diagnostics.push({
+        file,
+        element: describeElement(loopCharacteristics),
+        message: "uipath:loopCharacteristics must be nested under bpmn:multiInstanceLoopCharacteristics.",
+        instruction: "Move it into bpmn:multiInstanceLoopCharacteristics/bpmn:extensionElements and remove any copy from the activity's extensionElements."
+      });
+    }
     const payloads = uipathNodes.filter((node) => ["uipath:activity", "uipath:event", "uipath:mapping"].includes(node.name));
     for (const payload of payloads) {
-      this.validatePayload(file, payload, bindings, diagnostics);
+      this.validatePayload(file, payload, bindings, getOwningProcessActivityConfigurationVersion(payload), diagnostics);
     }
   }
-  validatePayload(file, payload, bindings, diagnostics) {
+  validatePayload(file, payload, bindings, workflowActivityConfigurationVersion, diagnostics) {
     const owner = findBpmnOwner(payload);
     if (!owner) {
       diagnostics.push({
@@ -3187,7 +3280,11 @@ class BpmnValidateService {
       return;
     }
     this.validateContractPlacement(file, payload, owner, contract, diagnostics);
-    this.validateContext(file, payload, owner, contract, diagnostics);
+    const isActivityExecutionV1 = extensionType === "Intsvc.ActivityExecution" && isIntsvcActivityExecutionV1(getContextInputs(payload).find((input) => input.attributes.name === ACTIVITY_CONFIGURATION_VERSION)?.attributes.value, workflowActivityConfigurationVersion);
+    this.validateContext(file, payload, owner, contract, isActivityExecutionV1, diagnostics);
+    if (isActivityExecutionV1) {
+      this.validateActivityExecutionV1Bindings(file, payload, owner, bindings, diagnostics);
+    }
     if (contract.extensionType === "Orchestrator.StartAgentJob") {
       this.validateStartAgentJobBindings(file, payload, owner, bindings, diagnostics);
     }
@@ -3214,24 +3311,33 @@ class BpmnValidateService {
       });
     }
   }
-  validateContext(file, payload, owner, contract, diagnostics) {
-    const contexts = childElements(payload, "uipath:context");
-    const contextInputs = contexts.flatMap((context) => childElements(context, "uipath:input"));
+  validateContext(file, payload, owner, contract, isActivityExecutionV1, diagnostics) {
+    const contextInputs = getContextInputs(payload);
     const actual = new Map(contextInputs.map((input) => [input.attributes.name, input]));
     const fields = contract.contextFields ?? [];
     const allowDynamicPayloadShape = usesCanvasOwnedDynamicPayload(contract);
     const allowed = new Set(fields.map((field) => field.name));
+    const requireDeclaredFields = !allowDynamicPayloadShape || isActivityExecutionV1;
+    const contractLabel = isActivityExecutionV1 ? "Integration Service activity" : contract.extensionType;
     for (const field of fields) {
       const input = actual.get(field.name);
-      if (!allowDynamicPayloadShape && field.required && !hasAttributeValue(input, "value")) {
+      if (requireDeclaredFields && field.required && !hasAttributeValue(input, "value")) {
         diagnostics.push({
           file,
           element: describeElement(owner),
-          message: `${contract.extensionType} is missing required context input "${field.name}".`,
+          message: `${contractLabel} is missing required context input "${field.name}".`,
           instruction: `Add <uipath:input name="${field.name}" value="..." /> inside uipath:context.`
         });
       }
       if (input) {
+        if (isActivityExecutionV1 && field.type === "string" && input.attributes.type !== "string") {
+          diagnostics.push({
+            file,
+            element: describeElement(input),
+            message: `${contractLabel} context input "${field.name}" must use type="string".`,
+            instruction: 'Add type="string" to this context input.'
+          });
+        }
         validateTypedValue(file, input, field.type, input.attributes.value, `context input "${field.name}"`, diagnostics);
       }
     }
@@ -3254,6 +3360,77 @@ class BpmnValidateService {
       }
     }
   }
+  validateActivityExecutionV1Bindings(file, payload, owner, bindings, diagnostics) {
+    const contextByName = new Map(getContextInputs(payload).map((input) => [
+      input.attributes.name,
+      input
+    ]));
+    const bindingFields = [
+      {
+        contextName: "connection",
+        propertyAttribute: "ConnectionId"
+      },
+      {
+        contextName: "folderKey",
+        propertyAttribute: "folderKey"
+      }
+    ];
+    const resourceKeys = new Map;
+    for (const field of bindingFields) {
+      const contextInput = contextByName.get(field.contextName);
+      if (!contextInput) {
+        continue;
+      }
+      const value = contextInput.attributes.value?.trim() ?? "";
+      if (!value) {
+        continue;
+      }
+      if (!value.startsWith("=bindings.")) {
+        diagnostics.push({
+          file,
+          element: describeElement(owner),
+          message: `Integration Service activity context input "${field.contextName}" must reference a root binding.`,
+          instruction: `Set ${field.contextName} to =bindings.<bindingId> and declare that binding with resource="Connection" and propertyAttribute="${field.propertyAttribute}".`
+        });
+        continue;
+      }
+      const bindingId = value.slice("=bindings.".length);
+      const binding = bindings.get(bindingId);
+      if (!binding) {
+        continue;
+      }
+      const hasInvalidBindingShape = binding.resource !== "Connection" || binding.propertyAttribute !== field.propertyAttribute;
+      if (hasInvalidBindingShape) {
+        diagnostics.push({
+          file,
+          element: describeElement(owner),
+          message: `Integration Service activity ${field.contextName} binding "${bindingId}" must use resource="Connection" and propertyAttribute="${field.propertyAttribute}".`,
+          instruction: `Set resource="Connection" and propertyAttribute="${field.propertyAttribute}" on that binding.`
+        });
+      }
+      const resourceKey = binding.resourceKey?.trim();
+      if (!resourceKey) {
+        diagnostics.push({
+          file,
+          element: describeElement(owner),
+          message: `Integration Service activity ${field.contextName} binding "${bindingId}" is missing resourceKey.`,
+          instruction: "Set resourceKey on that root binding."
+        });
+      } else if (!hasInvalidBindingShape) {
+        resourceKeys.set(field.contextName, resourceKey);
+      }
+    }
+    const connectionResourceKey = resourceKeys.get("connection");
+    const folderResourceKey = resourceKeys.get("folderKey");
+    if (connectionResourceKey && folderResourceKey && connectionResourceKey !== folderResourceKey) {
+      diagnostics.push({
+        file,
+        element: describeElement(owner),
+        message: "Integration Service activity connection and folder bindings refer to different connection resources.",
+        instruction: "Set the same resourceKey on both root bindings."
+      });
+    }
+  }
   validateInputs(file, payload, owner, contract, diagnostics) {
     const directInputs = childElements(payload, "uipath:input");
     const actual = new Map(directInputs.map((input) => [input.attributes.name, input]));
@@ -3702,6 +3879,24 @@ function findBpmnOwner(payload) {
   }
   return;
 }
+function getContextInputs(payload) {
+  return childElements(payload, "uipath:context").flatMap((context) => childElements(context, "uipath:input"));
+}
+function isIntsvcActivityExecutionV1(nodeVersion, workflowVersion) {
+  const version = nodeVersion ?? workflowVersion;
+  return version === undefined || version === ACTIVITY_CONFIGURATION_V1;
+}
+function getOwningProcessActivityConfigurationVersion(payload) {
+  let current = payload.parent;
+  while (current && !hasLocalName(current, "process")) {
+    current = current.parent;
+  }
+  if (!current) {
+    return;
+  }
+  const extensionElements = findChildren(current, (node) => hasLocalName(node, "extensionElements"));
+  return extensionElements.flatMap((node) => childElements(node, "uipath:intsvcActivityConfig")).at(0)?.attributes.version;
+}
 function describeElement(node) {
   const id = node.attributes.id ? `#${node.attributes.id}` : "";
   const name = node.attributes.name ? ` "${node.attributes.name}"` : "";
@@ -3823,6 +4018,7 @@ function collectInlineBindings(root, bindings) {
     bindings.set(id, {
       id,
       resource: binding.attributes.resource,
+      resourceKey: binding.attributes.resourceKey,
       resourceSubType: binding.attributes.resourceSubType,
       propertyAttribute: binding.attributes.propertyAttribute
     });
@@ -3848,6 +4044,7 @@ function collectBindingRecords(value, bindings) {
     bindings.set(id, {
       id,
       resource: getStringField(value, "resource"),
+      resourceKey: getStringField(value, "resourceKey"),
       resourceSubType: getStringField(value, "resourceSubType"),
       propertyAttribute: getStringField(value, "propertyAttribute")
     });
@@ -3877,7 +4074,8 @@ function decodeXmlEntities(value) {
   return value.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
 }
 export {
+  isIntsvcActivityExecutionV1,
   BpmnValidateService
 };
 
-//# debugId=DE15716967BCD42764756E2164756E21
+//# debugId=13E65BAAC441571B64756E2164756E21