@uipath/case-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{case-pack-service-29rza2q2.js → case-pack-service-47yrvmg0.js}

@@ -1,10 +1,3 @@
-import {
-  loadCaseSchemaAsync
-} from "./packager-tool-p7jgrm5r.js";
-import {
-  NugetPackager,
-  ensureProjectId
-} from "./packager-tool-sfkyb4kz.js";
 import {
   CasePlanFileNames,
   buildCasePackageDescriptor,
@@ -13,19 +6,26 @@ import {
   findCasePlanFileName,
   misnamedEntryPointBpmn,
   resolveDeclaredFileName
-} from "./packager-tool-83qnybab.js";
+} from "./packager-tool-wj9d9mqe.js";
+import {
+  NugetPackager,
+  ensureProjectId
+} from "./packager-tool-4rqd21wc.js";
 import"./packager-tool-b098y4a2.js";
 import {
   VALID_PACKAGE_NAME_REGEX
 } from "./packager-tool-vepqrsse.js";
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-cmwets3m.js";
 import {
   catchError,
   logger,
   mapPackageMetadataOptions
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-pack-service.ts
@@ -159,4 +159,4 @@ export {
   CasePackService
 };
 
-//# debugId=AFB0C029C8C764C664756E2164756E21
+//# debugId=B41124A85EC9DB4964756E2164756E21

package/dist/case-shape-reader-mw58avr0.js

@@ -0,0 +1,13 @@
+import {
+  readCaseShape,
+  readIoRows,
+  readSpecFolderKey
+} from "./packager-tool-8a9yqfq7.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  readCaseShape,
+  readIoRows,
+  readSpecFolderKey
+};
+
+//# debugId=45CD419A5F389BCF64756E2164756E21

package/dist/case-splice-service-9zvw19ca.js

@@ -0,0 +1,312 @@
+import {
+  CONNECTOR_TASK_TYPES,
+  SERVICE_TYPE_BY_TASK
+} from "./packager-tool-dthjwajc.js";
+import {
+  BINDING_REFERENCE_PREFIX
+} from "./packager-tool-d7jjng8a.js";
+import {
+  createConnectorBindings
+} from "./packager-tool-sq931c23.js";
+import {
+  prefixedId
+} from "./packager-tool-mknccck5.js";
+import"./packager-tool-1yh8g550.js";
+
+// 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;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var findTask = (document, taskId) => {
+  for (const rawNode of asArray(document.nodes)) {
+    const node = asRecord(rawNode);
+    if (!node)
+      continue;
+    for (const lane of asArray(asRecord(node.data)?.tasks)) {
+      for (const rawTask of asArray(lane)) {
+        const task = asRecord(rawTask);
+        if (task?.id === taskId)
+          return { node, task };
+      }
+    }
+  }
+  return;
+};
+var contextValue = (context, name) => {
+  for (const raw of context) {
+    const entry = asRecord(raw);
+    if (entry?.name !== name)
+      continue;
+    const value = entry.value;
+    return typeof value === "string" && value !== "" ? value : undefined;
+  }
+  return;
+};
+var declaresEntry = (context, name) => context.some((raw) => asRecord(raw)?.name === name);
+var isReferenced = (document, id) => {
+  const needle = `${BINDING_REFERENCE_PREFIX}${id}`;
+  const walk = (value) => {
+    if (typeof value === "string")
+      return value === needle;
+    if (Array.isArray(value))
+      return value.some(walk);
+    const record = asRecord(value);
+    if (record === undefined)
+      return false;
+    return Object.entries(record).some(([key, entry]) => key !== "bindings" && walk(entry));
+  };
+  return walk(document);
+};
+var connectorKeyOf = (context) => {
+  for (const raw of context) {
+    const entry = asRecord(raw);
+    if (entry?.name !== "connectorKey")
+      continue;
+    const value = entry.value;
+    return typeof value === "string" && value !== "" ? value : undefined;
+  }
+  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 existingBinding = (bindings, connectionId, propertyAttribute) => {
+  for (const raw of bindings) {
+    const binding = asRecord(raw);
+    if (!binding)
+      continue;
+    if (binding.resource === CONNECTION_RESOURCE && binding.resourceKey === connectionId && binding.propertyAttribute === propertyAttribute) {
+      return binding;
+    }
+  }
+  return;
+};
+var DOCUMENT_OWNED_OUTPUT_FIELDS = [
+  "value",
+  "source",
+  "target",
+  "originalVar"
+];
+var mergeOutputs = (specRows, existing, elementId) => {
+  const byName = new Map;
+  for (const raw of existing) {
+    const row = asRecord(raw);
+    if (typeof row?.name === "string" && row.name !== "") {
+      byName.set(row.name, row);
+    }
+  }
+  const merged = withVarIds(specRows, existing, elementId).map((row) => {
+    const kept = typeof row.name === "string" ? byName.get(row.name) : undefined;
+    if (kept === undefined)
+      return row;
+    const owned = Object.fromEntries(DOCUMENT_OWNED_OUTPUT_FIELDS.filter((field) => kept[field] !== undefined).map((field) => [field, kept[field]]));
+    return { ...row, ...owned };
+  });
+  const specNames = new Set(merged.map((row) => row.name));
+  const unmatched = existing.map(asRecord).filter((row) => row !== undefined && !specNames.has(row.name));
+  return [...merged, ...unmatched];
+};
+var withVarIds = (rows, existing, elementId) => {
+  const byName = new Map;
+  for (const raw of existing) {
+    const row = asRecord(raw);
+    if (row === undefined)
+      continue;
+    const name = row.name;
+    if (typeof name === "string" && name !== "")
+      byName.set(name, row);
+  }
+  return rows.map((raw) => {
+    const row = asRecord(raw) ?? {};
+    const name = typeof row.name === "string" ? row.name : "";
+    const kept = byName.get(name);
+    const keptId = typeof kept?.id === "string" && kept.id !== "" ? kept.id : undefined;
+    const id = keptId ?? (typeof row.id === "string" && row.id !== "" ? row.id : prefixedId("v", 8));
+    const keptVar = typeof kept?.var === "string" && kept.var !== "" ? kept.var : undefined;
+    return {
+      ...row,
+      id,
+      var: keptVar ?? (typeof row.var === "string" && row.var !== "" ? row.var : id),
+      elementId
+    };
+  });
+};
+var spliceConnectorShape = (document, caseShape, options) => {
+  const found = findTask(document, options.taskId);
+  if (found === undefined) {
+    return {
+      message: `No task with id "${options.taskId}" in this case plan`,
+      instructions: "Pass the task's `id` from `nodes[].data.tasks[][]`. `uip maestro case tasks list` prints them."
+    };
+  }
+  const { task } = found;
+  const taskType = typeof task.type === "string" ? task.type : "";
+  if (!CONNECTOR_TASK_TYPES.has(taskType)) {
+    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.`
+    };
+  }
+  const context = asArray(caseShape.context);
+  if (context.length === 0) {
+    return {
+      message: "This spec carries no `caseShape.context`",
+      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 connectorKey = connectorKeyOf(context);
+  if (connectorKey === undefined) {
+    return {
+      message: "This `caseShape.context` declares no `connectorKey`",
+      instructions: "The connection binding is named after the connector, so the key has to come from the spec. Re-fetch the spec rather than editing its context by hand."
+    };
+  }
+  const specConnection = contextValue(context, "resourceKey");
+  if (options.connectionId !== undefined && specConnection !== undefined && specConnection !== options.connectionId) {
+    return {
+      message: `This spec was fetched for connection ${specConnection}, not ${options.connectionId}`,
+      instructions: "Pass the connection the spec was fetched for, or re-fetch the spec with `uip maestro case spec --connection-id` for the connection you mean. Splicing the pair as given writes a task whose context and bindings name different connections."
+    };
+  }
+  const connectionId = options.connectionId ?? specConnection;
+  if (connectionId === undefined) {
+    return {
+      message: "This spec's `caseShape.context` states no `resourceKey`, so the connection it was fetched for is unknown",
+      instructions: "Pass `--connection-id` with the connection the spec was fetched for. `uip maestro case registry get-connection --type typecache-activities --activity-type-id <uuid>` lists the candidates."
+    };
+  }
+  const bindings = asArray(document.bindings);
+  const foundConnection = existingBinding(bindings, connectionId, "ConnectionId");
+  if (options.folderKey !== undefined && !declaresEntry(context, "folderKey")) {
+    return {
+      message: `This spec's connection has no folder — its context carries no \`folderKey\` entry — and --folder-key was given`,
+      instructions: "Drop `--folder-key`. The connector spec says this connection is not folder-scoped, so a folder binding would reference nothing."
+    };
+  }
+  const specFolderKey = options.specFolderKey;
+  if (options.folderKey !== undefined && specFolderKey !== undefined && options.folderKey.toLowerCase() !== specFolderKey.toLowerCase()) {
+    return {
+      message: `This spec's connection is in folder ${specFolderKey}, not ${options.folderKey}`,
+      instructions: "Drop `--folder-key` to use the spec's folder, or re-fetch the spec with `uip maestro case spec --connection-id` for the connection you mean."
+    };
+  }
+  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)
+      continue;
+    const id = found2.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`,
+      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."
+    };
+  }
+  const [freshConnection, freshFolder] = createConnectorBindings(connectorKey, connectionId, folderKey);
+  const completed = [];
+  const complete = (binding, value) => {
+    const record = binding;
+    if (value === undefined || value === "")
+      return record;
+    const current = record.default;
+    if (current === value)
+      return record;
+    completed.push(String(record.name ?? record.id ?? ""));
+    return { ...record, default: value };
+  };
+  const connectionBinding = complete(foundConnection ?? freshConnection, connectionId);
+  const folderBinding = foundFolder === undefined ? freshFolder : complete(foundFolder, folderKey);
+  const connectionBindingId = String(connectionBinding.id ?? "");
+  const folderBindingId = folderBinding === undefined ? undefined : String(folderBinding.id ?? "");
+  const nextBindings = bindings.map((entry) => {
+    const binding = asRecord(entry);
+    if (binding === undefined)
+      return entry;
+    if (foundConnection !== undefined && binding === foundConnection) {
+      return connectionBinding;
+    }
+    if (foundFolder !== undefined && binding === foundFolder) {
+      return folderBinding;
+    }
+    return entry;
+  });
+  if (foundConnection === undefined)
+    nextBindings.push(connectionBinding);
+  if (foundFolder === undefined && freshFolder !== undefined) {
+    nextBindings.push(freshFolder);
+  }
+  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;
+  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."
+    };
+  }
+  task.data = {
+    ...data,
+    serviceType: SERVICE_TYPE_BY_TASK[taskType],
+    context: splicedContext,
+    inputs: withVarIds(asArray(caseShape.inputs), asArray(data.inputs), elementId),
+    outputs: mergeOutputs(asArray(caseShape.outputs), asArray(data.outputs), elementId)
+  };
+  const dropped = [];
+  const prunedBindings = folderKey === undefined && !declaresEntry(context, "folderKey") ? nextBindings.filter((entry) => {
+    const binding = asRecord(entry);
+    if (binding?.resource !== CONNECTION_RESOURCE || binding.propertyAttribute !== FOLDER_KEY_ATTRIBUTE || binding.resourceKey !== connectionId) {
+      return true;
+    }
+    const id = binding.id;
+    if (typeof id === "string" && isReferenced(document, id)) {
+      return true;
+    }
+    dropped.push(String(binding.name ?? id ?? ""));
+    return false;
+  }) : nextBindings;
+  document.bindings = prunedBindings;
+  return {
+    document,
+    summary: {
+      taskId: options.taskId,
+      taskType,
+      serviceType: SERVICE_TYPE_BY_TASK[taskType],
+      contextEntries: splicedContext.length,
+      inputs: asArray(caseShape.inputs).length,
+      outputs: asArray(caseShape.outputs).length,
+      connectionBindingId,
+      ...folderBindingId !== undefined && { folderBindingId },
+      bindingsReused: foundConnection !== undefined,
+      bindingsCompleted: completed,
+      bindingsDropped: dropped
+    }
+  };
+};
+var isSpliceFailure = (value) => ("message" in value);
+export {
+  isSpliceFailure,
+  spliceConnectorShape
+};
+
+//# debugId=D42AF8729FBF876464756E2164756E21