@uipath/case-tool 1.202.0 → 1.203.0-preview.160

package/dist/{strict-case-rules-303vjvas.js → strict-case-rules-x6t0vb40.js}

@@ -1,8 +1,13 @@
 import {
+  ACTIVITY_TYPE_ID_PATH,
+  BINDING_REFERENCE_PREFIX,
+  NAME_BOUND_TASK_TYPES,
+  RESOLVED_IDENTITY_KEYS,
+  activityTypeIdMessage,
   contextEntry,
   missingContextKeys,
   readActivityTypeId
-} from "./packager-tool-ty1t2byf.js";
+} from "./packager-tool-d4sjk46c.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/strict-case-rules.ts
@@ -32,31 +37,6 @@ var checkStagesHaveTasks = (nodes) => {
   }
   return issues;
 };
-var checkNoUnresolvedXrefs = (value, path, issues) => {
-  if (typeof value === "string") {
-    if (value.includes("$xref(")) {
-      issues.push({
-        code: "STRICT_XREF_UNRESOLVED",
-        path,
-        severity: "error",
-        message: `Unresolved authoring marker in "${value}". "$xref(...)" ` + "is a placeholder the converter does not expand — resolve " + "it to the real id before packing."
-      });
-    }
-    return;
-  }
-  if (Array.isArray(value)) {
-    value.forEach((entry, index) => {
-      checkNoUnresolvedXrefs(entry, `${path}[${index}]`, issues);
-    });
-    return;
-  }
-  const record = asRecord(value);
-  if (!record)
-    return;
-  for (const [key, entry] of Object.entries(record)) {
-    checkNoUnresolvedXrefs(entry, `${path}.${key}`, issues);
-  }
-};
 var jsSyntaxError = (source) => {
   try {
     new Script(source);
@@ -96,42 +76,6 @@ var checkJsExpressionsParse = (value, path, issues) => {
     checkJsExpressionsParse(entry, `${path}.${key}`, issues);
   }
 };
-var checkConditionExpressionPlacement = (conditions, path) => {
-  const issues = [];
-  asArray(conditions).forEach((condition, index) => {
-    const record = asRecord(condition);
-    if (!record)
-      return;
-    if (typeof record.conditionExpression !== "string")
-      return;
-    issues.push({
-      code: "STRICT_CONDITION_EXPR_HOISTED",
-      path: `${path}[${index}].conditionExpression`,
-      severity: "error",
-      message: '"conditionExpression" sits on the condition object. The ' + "scheduler reads it from a rule inside rules[][], so here it " + "is ignored and the condition fires ungated — move it onto " + "the rule it is meant to guard."
-    });
-  });
-  return issues;
-};
-var collectConditionIssues = (nodes, metadata) => {
-  const issues = [];
-  for (const node of nodes) {
-    const id = typeof node.id === "string" ? node.id : "?";
-    const data = asRecord(node.data);
-    issues.push(...checkConditionExpressionPlacement(data?.entryConditions, `nodes[${id}].data.entryConditions`), ...checkConditionExpressionPlacement(data?.exitConditions, `nodes[${id}].data.exitConditions`));
-    for (const lane of asArray(data?.tasks)) {
-      for (const task of asArray(lane)) {
-        const taskRecord = asRecord(task);
-        if (!taskRecord)
-          continue;
-        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
-        issues.push(...checkConditionExpressionPlacement(taskRecord.entryConditions, `nodes[${id}].data.tasks[${taskId}].entryConditions`));
-      }
-    }
-  }
-  issues.push(...checkConditionExpressionPlacement(metadata?.caseExitRules, "metadata.caseExitRules"));
-  return issues;
-};
 var checkVariableContract = (variables) => {
   const issues = [];
   for (const slot of ["inputs", "outputs", "inputOutputs"]) {
@@ -210,50 +154,13 @@ var checkInputOutputCompanions = (variables, nodes) => {
   }
   return issues;
 };
-var checkOutputIdUniqueness = (nodes) => {
-  const issues = [];
-  const seen = new Map;
-  const reported = new Set;
-  for (const node of nodes) {
-    const nodeId = typeof node.id === "string" ? node.id : "?";
-    const data = asRecord(node.data);
-    for (const lane of asArray(data?.tasks)) {
-      for (const task of asArray(lane)) {
-        const taskRecord = asRecord(task);
-        if (!taskRecord)
-          continue;
-        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
-        const taskData = asRecord(taskRecord.data);
-        for (const output of asArray(taskData?.outputs)) {
-          const id = asRecord(output)?.id;
-          if (typeof id !== "string" || id === "")
-            continue;
-          const owner = `${nodeId}/${taskId}`;
-          const previous = seen.get(id);
-          if (previous !== undefined && !reported.has(id)) {
-            reported.add(id);
-            issues.push({
-              code: "STRICT_OUTPUT_ID_DUPLICATE",
-              path: `nodes[${nodeId}].data.tasks[${taskId}].data.outputs[${id}]`,
-              severity: "error",
-              message: `Output id "${id}" is used by two tasks ` + `(${previous} and ${owner}). Output ids are ` + "the write target, so the second write lands " + "on the first task's variable."
-            });
-          }
-          if (previous === undefined)
-            seen.set(id, owner);
-        }
-      }
-    }
-  }
-  return issues;
-};
 var checkConnectorRuleContext = (nodes) => {
   const issues = [];
   const visitRule = (rule, path) => {
     if (rule.rule !== "wait-for-connector")
       return;
     const context = asRecord(rule.uipath)?.context;
-    const missing = missingContextKeys(context);
+    const missing = missingContextKeys(context, true);
     if (missing.length > 0) {
       issues.push({
         code: "STRICT_CONNECTOR_CONTEXT_INCOMPLETE",
@@ -267,9 +174,9 @@ var checkConnectorRuleContext = (nodes) => {
     if (readActivityTypeId(context) === undefined) {
       issues.push({
         code: "STRICT_CONNECTOR_ACTIVITY_TYPE_ID",
-        path: `${path}.uipath.context[metadata].body.activityPropertyConfiguration.UiPathActivityTypeId`,
+        path: `${path}.uipath.context[metadata].${ACTIVITY_TYPE_ID_PATH}`,
         severity: "error",
-        message: `Connector rule "${String(rule.id ?? "?")}" has metadata ` + "with no UiPathActivityTypeId. The connection id alone " + "does not identify the event to wait for."
+        message: activityTypeIdMessage(`rule "${typeof rule.id === "string" ? rule.id : "?"}"`, context, "The connection id alone does not identify the event to " + "wait for.")
       });
     }
   };
@@ -350,28 +257,153 @@ var checkActionRecipientShape = (nodes) => nodes.flatMap((node) => {
     return recipientIssues(recipient, `nodes[${nodeId}].data.tasks[${taskId}].data.recipient`);
   }));
 });
+var RESOURCE_TASK_TYPES = new Set([
+  "action",
+  "agent",
+  "api-workflow",
+  "case-management",
+  "execute-connector-activity",
+  "process",
+  "rpa",
+  "wait-for-connector"
+]);
+var collectBindingReferences = (value, path, found) => {
+  if (typeof value === "string") {
+    if (value.startsWith(BINDING_REFERENCE_PREFIX)) {
+      const id = value.slice(BINDING_REFERENCE_PREFIX.length);
+      if (id !== "" && !found.has(id))
+        found.set(id, path);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      collectBindingReferences(entry, `${path}[${index}]`, found);
+    });
+    return;
+  }
+  const record = asRecord(value);
+  if (record === undefined)
+    return;
+  for (const [key, entry] of Object.entries(record)) {
+    collectBindingReferences(entry, `${path}.${key}`, found);
+  }
+};
+var isBindingReference = (value) => typeof value === "string" && value.startsWith(BINDING_REFERENCE_PREFIX);
+var checkTaskBindings = (nodes) => {
+  const issues = [];
+  for (const node of nodes) {
+    const stage = asRecord(node.data);
+    const stageName = typeof stage?.label === "string" ? stage.label : "";
+    for (const lane of asArray(stage?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        const type = taskRecord?.type;
+        const data = asRecord(taskRecord?.data);
+        if (typeof type !== "string" || !NAME_BOUND_TASK_TYPES.has(type) || data === undefined) {
+          continue;
+        }
+        const identity = RESOLVED_IDENTITY_KEYS.filter((key) => data[key] !== undefined);
+        if (identity.length === 0)
+          continue;
+        const unbound = ["name", "folderPath"].filter((field) => !isBindingReference(data[field]));
+        if (unbound.length === 0)
+          continue;
+        const taskName = typeof taskRecord?.displayName === "string" ? taskRecord.displayName : type;
+        issues.push({
+          code: "STRICT_BINDINGS_TASK_UNBOUND",
+          path: `nodes[${stageName}].data.tasks[${taskName}].data`,
+          severity: "error",
+          message: `Task "${taskName}" (${type}) pins its resource with ` + `${identity.join(", ")}, but ${unbound.join(" and ")} ` + `${unbound.length === 1 ? `is not a ${BINDING_REFERENCE_PREFIX} reference` : `are not ${BINDING_REFERENCE_PREFIX} references`}. A resolved ` + "resource task binds both: `name` and `folderPath` " + "each point at a root bindings entry, and " + "bindings_v2.json is derived from those. A raw id " + "binds nothing, so the solution ships resolving this " + "task to nothing, and the id itself does not survive " + "a move to another tenant. Bind the pair and drop the " + "raw id."
+        });
+      }
+    }
+  }
+  return issues;
+};
+var resourceTaskCount = (nodes) => {
+  let count = 0;
+  for (const node of nodes) {
+    for (const lane of asArray(asRecord(node.data)?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        const type = taskRecord?.type;
+        if (typeof type === "string" && RESOURCE_TASK_TYPES.has(type) && Object.keys(asRecord(taskRecord?.data) ?? {}).length > 0) {
+          count += 1;
+        }
+      }
+    }
+  }
+  return count;
+};
+var checkResourceBindings = (parsed, nodes) => {
+  const issues = [];
+  const bindings = asArray(parsed.bindings).map((entry) => asRecord(entry)).filter((entry) => entry !== undefined);
+  const bindingIds = new Set(bindings.map((entry) => entry.id).filter((id) => typeof id === "string"));
+  const seenIds = new Set;
+  const reportedIds = new Set;
+  for (const entry of bindings) {
+    const id = entry.id;
+    if (typeof id !== "string" || id === "")
+      continue;
+    if (!seenIds.has(id)) {
+      seenIds.add(id);
+      continue;
+    }
+    if (reportedIds.has(id))
+      continue;
+    reportedIds.add(id);
+    issues.push({
+      code: "STRICT_BINDINGS_ID_DUPLICATE",
+      path: `bindings[${id}]`,
+      severity: "error",
+      message: `Two or more bindings share the id "${id}". A ` + `${BINDING_REFERENCE_PREFIX}${id} reference resolves to ` + "whichever entry a consumer scans first, so the one that " + "wins depends on array order — and the losing entry still " + "reads as though it applies. Give each entry its own id."
+    });
+  }
+  const references = new Map;
+  collectBindingReferences(parsed.nodes, "nodes", references);
+  collectBindingReferences(parsed.metadata, "metadata", references);
+  for (const [id, path] of references) {
+    if (bindingIds.has(id))
+      continue;
+    issues.push({
+      code: "STRICT_BINDINGS_REFERENCE_UNRESOLVED",
+      path,
+      severity: "error",
+      message: `"${BINDING_REFERENCE_PREFIX}${id}" points at no entry in the ` + "root bindings array, so nothing resolves it at run time. Add " + `a binding with id "${id}", or correct the reference.`
+    });
+  }
+  const resourceTasks = resourceTaskCount(nodes);
+  if (bindings.length > 0) {
+    issues.push(...checkTaskBindings(nodes));
+  } else if (resourceTasks > 0) {
+    issues.push({
+      code: "STRICT_BINDINGS_ABSENT",
+      path: "bindings",
+      severity: "warning",
+      message: `The root bindings array is empty, but ${resourceTasks} task(s) ` + "name a platform resource (process, agent, rpa, action, " + "api-workflow, child case or connector). Every such task needs " + "a name/folderPath binding pair — or, for a connector, a " + "connection and folder key — and bindings_v2.json is derived " + "from that array, so an empty one publishes a solution that " + "resolves none of them."
+    });
+  }
+  return issues;
+};
 var runStrictCaseRules = (parsed) => {
   const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
   const variables = asRecord(parsed.variables);
   const metadata = asRecord(parsed.metadata);
-  const xrefIssues = [];
-  checkNoUnresolvedXrefs(parsed, "(root)", xrefIssues);
   const jsSyntaxIssues = [];
   checkJsExpressionsParse(parsed, "(root)", jsSyntaxIssues);
   return [
     ...checkStagesHaveTasks(nodes),
-    ...xrefIssues,
     ...jsSyntaxIssues,
-    ...collectConditionIssues(nodes, metadata),
     ...checkVariableContract(variables),
     ...checkInputOutputCompanions(variables, nodes),
-    ...checkOutputIdUniqueness(nodes),
     ...checkConnectorRuleContext(nodes),
-    ...checkActionRecipientShape(nodes)
+    ...checkActionRecipientShape(nodes),
+    ...checkResourceBindings(parsed, nodes)
   ];
 };
 export {
   runStrictCaseRules
 };
 
-//# debugId=A26096E08E3DBD7464756E2164756E21
+//# debugId=C4B6D297A9F4627964756E2164756E21