@uipath/case-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/{case-splice-service-s5gccctq.js → case-splice-service-6y35w83e.js}

@@ -1,26 +1,35 @@
 import {
-  CONNECTOR_TASK_TYPES,
-  SERVICE_TYPE_BY_TASK
-} from "./packager-tool-93mdeqay.js";
+  mapStringsDeep,
+  CONN_BINDING_ID_PLACEHOLDER,
+  FOLDER_BINDING_ID_PLACEHOLDER,
+  RESOURCE_BINDING_ID_PREFIX,
+  upsertResourceBinding
+} from "./packager-tool-h2ar8xf8.js";
 import {
-  BINDING_REFERENCE_PREFIX
-} from "./packager-tool-87y6xw3a.js";
+  EXTERNAL_TASK_TYPES,
+  CONNECTOR_CALL_TASK_TYPES,
+  isMappedExecution,
+  serviceTypeFor
+} from "./packager-tool-7x1tmb8a.js";
 import {
-  dedupedId
-} from "./packager-tool-9kvkzc05.js";
+  BINDING_REFERENCE_PREFIX
+} from "./packager-tool-nfhtwa72.js";
 import {
   camelizeDisplayName
-} from "./packager-tool-ydyvtknp.js";
-import"./packager-tool-9y1w2wds.js";
+} from "./packager-tool-0w4fsdzv.js";
+import"./packager-tool-z070caqq.js";
+import"./packager-tool-psmb758n.js";
+import"./packager-tool-fcektt1g.js";
+import {
+  dedupedId
+} from "./packager-tool-5w0gjcck.js";
 import {
   createConnectorBindings
-} from "./packager-tool-sq931c23.js";
+} from "./packager-tool-e1tx5mqg.js";
 import {
   prefixedId
-} from "./packager-tool-mknccck5.js";
-import"./packager-tool-83v804p7.js";
-import"./packager-tool-hdxtgckw.js";
-import"./packager-tool-1yh8g550.js";
+} from "./packager-tool-1h7abxw6.js";
+import"./packager-tool-68648y3j.js";
 
 // src/services/splice-output-ids.ts
 var outputIdBase = (name) => {
@@ -59,8 +68,6 @@ var takenIdsIn = (document) => {
 var mintOutputId = (name, taken) => dedupedId(outputIdBase(name), taken);
 
 // src/services/case-splice-service.ts
-var CONNECTION_SENTINEL = "{{CONN_BINDING_ID}}";
-var FOLDER_SENTINEL = "{{FOLDER_BINDING_ID}}";
 var CONNECTION_RESOURCE = "Connection";
 var FOLDER_KEY_ATTRIBUTE = "folderKey";
 var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -115,25 +122,10 @@ var connectorKeyOf = (context) => {
   }
   return;
 };
-var substituteSentinels = (value, connectionId, folderId) => {
-  if (typeof value === "string") {
-    let next = value.replaceAll(CONNECTION_SENTINEL, connectionId);
-    if (folderId !== undefined) {
-      next = next.replaceAll(FOLDER_SENTINEL, folderId);
-    }
-    return next;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => substituteSentinels(entry, connectionId, folderId));
-  }
-  const record = asRecord(value);
-  if (!record)
-    return value;
-  return Object.fromEntries(Object.entries(record).map(([key, entry]) => [
-    key,
-    substituteSentinels(entry, connectionId, folderId)
-  ]));
-};
+var substituteSentinels = (value, connectionId, folderId) => mapStringsDeep(value, (text) => {
+  const next = text.replaceAll(CONN_BINDING_ID_PLACEHOLDER, connectionId);
+  return folderId === undefined ? next : next.replaceAll(FOLDER_BINDING_ID_PLACEHOLDER, folderId);
+});
 var existingBinding = (bindings, connectionId, propertyAttribute) => {
   for (const raw of bindings) {
     const binding = asRecord(raw);
@@ -205,10 +197,12 @@ var spliceConnectorShape = (document, caseShape, options) => {
   }
   const { task } = found;
   const taskType = typeof task.type === "string" ? task.type : "";
-  if (!CONNECTOR_TASK_TYPES.has(taskType)) {
+  const spliceable = [...CONNECTOR_CALL_TASK_TYPES];
+  if (!spliceable.includes(taskType)) {
+    const allowed = spliceable.map((type) => `\`${type}\``).join(", ");
     return {
       message: `Task "${options.taskId}" is a \`${taskType || "(untyped)"}\` task, not a connector task`,
-      instructions: `A connector shape only belongs on ${[...CONNECTOR_TASK_TYPES].map((type) => `\`${type}\``).join(" or ")}. Change the task's type first, or splice into a different task.`
+      instructions: `A connector shape only belongs on ${allowed}. Change the task's type first, or splice into a different task.`
     };
   }
   const context = asArray(caseShape.context);
@@ -218,6 +212,12 @@ var spliceConnectorShape = (document, caseShape, options) => {
       instructions: "Re-run `uip maestro case spec` without `--skip-case-shape`. A trigger spec may not build a context yet, in which case there is nothing to splice."
     };
   }
+  const executionType = contextValue(context, "executionType");
+  const wrongKind = specKindMismatch(options.taskId, taskType, executionType);
+  if (wrongKind !== undefined)
+    return wrongKind;
+  const serviceType = serviceTypeFor(taskType, executionType);
+  const warning = EXTERNAL_TASK_TYPES.has(taskType) ? guessedExecutionWarning(executionType, serviceType) : undefined;
   const connectorKey = connectorKeyOf(context);
   if (connectorKey === undefined) {
     return {
@@ -256,14 +256,14 @@ var spliceConnectorShape = (document, caseShape, options) => {
   }
   const folderKey = options.folderKey ?? (declaresEntry(context, "folderKey") ? specFolderKey : undefined);
   const foundFolder = folderKey === undefined ? undefined : existingBinding(bindings, connectionId, "folderKey");
-  for (const found2 of [foundConnection, foundFolder]) {
-    if (found2 === undefined)
+  for (const found of [foundConnection, foundFolder]) {
+    if (found === undefined)
       continue;
-    const id = found2.id;
+    const id = found.id;
     if (typeof id === "string" && id !== "")
       continue;
     return {
-      message: `The existing \`${String(found2.propertyAttribute ?? "")}\` binding for connection ${connectionId} has ${id === undefined ? "no `id`" : `an empty \`id\``}, so nothing can reference it`,
+      message: `The existing \`${String(found.propertyAttribute ?? "")}\` binding for connection ${connectionId} has ${id === undefined ? "no `id`" : `an empty \`id\``}, so nothing can reference it`,
       instructions: "A task addresses a binding as `=bindings.<id>`, so an " + "entry with no id resolves to nothing. Give that entry in " + "`bindings[]` a unique id, or delete it and re-run this " + "command to have a fresh pair written."
     };
   }
@@ -302,20 +302,49 @@ var spliceConnectorShape = (document, caseShape, options) => {
   }
   const elementId = typeof task.elementId === "string" && task.elementId !== "" ? task.elementId : options.taskId;
   const data = asRecord(task.data) ?? {};
-  const splicedContext = substituteSentinels(context, connectionBindingId, folderBindingId);
-  const leftover = JSON.stringify(splicedContext).includes(FOLDER_SENTINEL) ? FOLDER_SENTINEL : JSON.stringify(splicedContext).includes(CONNECTION_SENTINEL) ? CONNECTION_SENTINEL : undefined;
+  const resources = applyResourceBindings(nextBindings, options.resourceBindings ?? []);
+  const splicedContext = replacePlaceholders(substituteSentinels(context, connectionBindingId, folderBindingId), resources.ids);
+  const splicedInputs = replacePlaceholders(asArray(caseShape.inputs), resources.ids);
+  const contextText = JSON.stringify(splicedContext);
+  const leftover = [
+    FOLDER_BINDING_ID_PLACEHOLDER,
+    CONN_BINDING_ID_PLACEHOLDER
+  ].find((placeholder) => contextText.includes(placeholder));
+  const unresolved = /\{\{RESOURCE_BINDING_ID:[^}]*\}\}/.exec(JSON.stringify([splicedContext, splicedInputs]))?.[0];
+  if (unresolved !== undefined) {
+    return {
+      message: `This spec references ${unresolved}, but its ResourceBindings define no row for it`,
+      instructions: "Pass the whole `uip maestro case spec` result to --spec, including its ResourceBindings, or re-fetch the spec; the picker binding is only defined there."
+    };
+  }
   if (leftover !== undefined) {
     return {
       message: `This spec's context carries ${leftover}, and nothing was given to resolve it`,
-      instructions: leftover === FOLDER_SENTINEL ? "Pass `--folder-key <key>`. The shape asks for a folder-key binding, so splicing without one would leave an unresolved reference in the task." : "Pass `--connection-id <id>` for the connection this spec was fetched for."
+      instructions: leftover === FOLDER_BINDING_ID_PLACEHOLDER ? "Pass `--folder-key <key>`. The shape asks for a folder-key binding, so splicing without one would leave an unresolved reference in the task." : "Pass `--connection-id <id>` for the connection this spec was fetched for."
     };
   }
+  const priorTaskBindings = asArray(data.bindings);
+  const staleIds = new Set(priorTaskBindings.flatMap((raw) => {
+    const entry = asRecord(raw);
+    const id = String(entry?.id);
+    return entry !== undefined && entry.resource !== CONNECTION_RESOURCE && !resources.usedIds.has(id) ? [id] : [];
+  }));
+  const taskBindings = [
+    ...priorTaskBindings.filter((raw) => {
+      const id = String(asRecord(raw)?.id);
+      return !resources.usedIds.has(id) && !staleIds.has(id);
+    }),
+    ...resources.used
+  ];
   task.data = {
     ...data,
-    serviceType: SERVICE_TYPE_BY_TASK[taskType],
+    serviceType,
     context: splicedContext,
-    inputs: withVarIds(asArray(caseShape.inputs), asArray(data.inputs), elementId),
-    outputs: mergeOutputs(asArray(caseShape.outputs), asArray(data.outputs), elementId, takenIdsIn(document))
+    inputs: withVarIds(splicedInputs, asArray(data.inputs), elementId),
+    outputs: mergeOutputs(asArray(caseShape.outputs), asArray(data.outputs), elementId, takenIdsIn(document)),
+    ...(priorTaskBindings.length > 0 || resources.used.length > 0) && {
+      bindings: taskBindings
+    }
   };
   const dropped = [];
   const prunedBindings = folderKey === undefined && !declaresEntry(context, "folderKey") ? nextBindings.filter((entry) => {
@@ -330,13 +359,20 @@ var spliceConnectorShape = (document, caseShape, options) => {
     dropped.push(String(binding.name ?? id ?? ""));
     return false;
   }) : nextBindings;
-  document.bindings = prunedBindings;
+  document.bindings = prunedBindings.filter((entry) => {
+    const binding = asRecord(entry);
+    const id = String(binding?.id);
+    if (!staleIds.has(id) || isReferenced(document, id))
+      return true;
+    dropped.push(typeof binding?.name === "string" ? binding.name : id);
+    return false;
+  });
   return {
     document,
     summary: {
       taskId: options.taskId,
       taskType,
-      serviceType: SERVICE_TYPE_BY_TASK[taskType],
+      serviceType,
       contextEntries: splicedContext.length,
       inputs: asArray(caseShape.inputs).length,
       outputs: asArray(caseShape.outputs).length,
@@ -344,14 +380,66 @@ var spliceConnectorShape = (document, caseShape, options) => {
       ...folderBindingId !== undefined && { folderBindingId },
       bindingsReused: foundConnection !== undefined,
       bindingsCompleted: completed,
-      bindingsDropped: dropped
+      bindingsDropped: dropped,
+      resourceBindingIds: [...resources.usedIds],
+      ...warning !== undefined && { warning }
     }
   };
 };
+function specKindMismatch(taskId, taskType, executionType) {
+  if (EXTERNAL_TASK_TYPES.has(taskType) || executionType === undefined) {
+    return;
+  }
+  return {
+    message: `Task "${taskId}" is a \`${taskType}\` task, but this spec is for an external agent or automation (executionType "${executionType}")`,
+    instructions: "Change the task's type to `external-agent` or `external-workflow`, or fetch a connector activity's spec."
+  };
+}
+function guessedExecutionWarning(executionType, serviceType) {
+  if (executionType === undefined) {
+    return `The spec's context has no executionType, so the task was written as ${serviceType}, the Designer's default. If the spec is for a plain connector activity, splice it into an \`execute-connector-activity\` task instead.`;
+  }
+  if (isMappedExecution(executionType))
+    return;
+  return `The spec's executionType "${executionType}" is not sync, async or hybrid, so the task was written as ${serviceType}, the Designer's default. Check the connector's execution type before relying on it.`;
+}
+function applyResourceBindings(bindings, resourceBindings) {
+  const ids = new Map;
+  const used = [];
+  for (const resource of resourceBindings) {
+    for (const row of resource.rows) {
+      const { binding, created } = upsertResourceBinding(bindings.filter((entry) => asRecord(entry) !== undefined), {
+        resource: resource.resource,
+        resourceKey: resource.resourceKey,
+        propertyAttribute: row.propertyAttribute,
+        name: row.name,
+        default: row.default
+      }, () => prefixedId("b", 8));
+      if (created)
+        bindings.push(binding);
+      ids.set(row.bindingIdPlaceholder, String(binding.id));
+      if (!used.some((entry) => entry.id === binding.id))
+        used.push(binding);
+    }
+  }
+  return {
+    ids,
+    used,
+    usedIds: new Set(used.map((entry) => String(entry.id)))
+  };
+}
+var replacePlaceholders = (value, ids) => mapStringsDeep(value, (text) => {
+  if (!text.includes(RESOURCE_BINDING_ID_PREFIX))
+    return text;
+  let out = text;
+  for (const [placeholder, id] of ids)
+    out = out.replaceAll(placeholder, id);
+  return out;
+});
 var isSpliceFailure = (value) => ("message" in value);
 export {
   isSpliceFailure,
   spliceConnectorShape
 };
 
-//# debugId=0226F0A402EC388E64756E2164756E21
+//# debugId=A4201D0AD800A05764756E2164756E21