@uipath/case-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/{sdd-lookup-x08j9g9m.js → sdd-lookup-vpjej1kt.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} 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/sdd-lookup.ts

package/dist/sdd-resolve-service-4hx64x3z.js

@@ -0,0 +1,288 @@
+import {
+  comparableFolder
+} from "./packager-tool-21qfsbxn.js";
+import {
+  namedValue
+} from "./packager-tool-f78ntj5g.js";
+import {
+  MISSING_RESOURCE_INDEX,
+  loadIndexMetadata,
+  loadResourceIndex
+} from "./packager-tool-0p3td5zv.js";
+import {
+  byCodeUnit
+} from "./packager-tool-5qp9xza1.js";
+import {
+  catchError
+} from "./packager-tool-58kx79ta.js";
+import"./packager-tool-xdxr3ync.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/sdd-resolve-service.ts
+var CACHE_MAX_AGE_SECONDS = 3600;
+var TYPE_INDEX = {
+  agent: {
+    cacheFile: "agent",
+    identifierField: "entityKey",
+    creatable: true
+  },
+  process: {
+    cacheFile: "processOrchestration",
+    identifierField: "entityKey",
+    creatable: false
+  },
+  rpa: {
+    cacheFile: "process",
+    identifierField: "entityKey",
+    creatable: false
+  },
+  "api-workflow": {
+    cacheFile: "api",
+    identifierField: "entityKey",
+    creatable: true
+  },
+  "case-management": {
+    cacheFile: "caseManagement",
+    identifierField: "entityKey",
+    creatable: false
+  },
+  function: {
+    cacheFile: "function",
+    identifierField: "entityKey",
+    creatable: false
+  },
+  action: {
+    cacheFile: "action-apps",
+    identifierField: "id",
+    creatable: false
+  },
+  "wait-for-timer": null,
+  "wait-for-connector": {
+    cacheFile: "typecache-triggers",
+    identifierField: "uiPathActivityTypeId",
+    creatable: false
+  },
+  "execute-connector-activity": {
+    cacheFile: "typecache-activities",
+    identifierField: "uiPathActivityTypeId",
+    creatable: false
+  }
+};
+var namesOf = (entry) => ["name", "deploymentTitle", "title", "displayName"].map((field) => entry[field]).filter((value) => typeof value === "string" && value !== "");
+var foldersOf = (entry) => {
+  const deployment = entry.deploymentFolder;
+  if (typeof deployment?.fullyQualifiedName === "string") {
+    return [deployment.fullyQualifiedName];
+  }
+  const folders = entry.folders;
+  return (Array.isArray(folders) ? folders : []).map((one) => one?.fullyQualifiedName).filter((name) => typeof name === "string");
+};
+var sameFolder = (candidate, wanted) => candidate !== undefined && comparableFolder(candidate) === comparableFolder(wanted);
+var matchesFor = (entry, identifierField, wanted) => {
+  const identifier = entry[identifierField];
+  if (typeof identifier !== "string" || identifier === "")
+    return [];
+  const base = { name: namesOf(entry)[0] ?? "", identifierField, identifier };
+  const all = foldersOf(entry);
+  if (all.length === 0)
+    return [base];
+  const answering = all.find((one) => sameFolder(one, wanted));
+  if (answering !== undefined)
+    return [{ ...base, folder: answering }];
+  return all.map((folder) => ({ ...base, folder }));
+};
+var rationaleFor = (params) => {
+  const { selected, matches, candidates, folder, narrowed } = params;
+  if (selected !== null) {
+    return folder !== "" && narrowed === 1 && matches.length > 1 ? `${matches.length} entries carry this name; the folder "${folder}" leaves one` : "exactly one entry carries this name";
+  }
+  if (candidates.length === 0)
+    return "no entry carries this name";
+  const entries = new Set(candidates.map((match) => match.identifier)).size;
+  const folders = [
+    ...new Set(candidates.map((match) => match.folder).filter((one) => one !== undefined))
+  ];
+  const subject = entries === 1 ? "one entry carries this name" : `${entries} entries carry this name`;
+  const inFolders = entries === 1 && folders.length > 1 ? `, in ${folders.map((one) => `"${one}"`).join(" and ")}` : "";
+  if (folder === "") {
+    return `${subject}${inFolders} and the task block names no folder to narrow by, so the choice is not the document's to make`;
+  }
+  if (narrowed === 0) {
+    const where = entries === 1 ? "it is not" : "none of them";
+    return `${subject}${inFolders}, and ${where} in the folder "${folder}" the task block names, so the choice is not the document's to make`;
+  }
+  return `${subject} in the folder "${folder}", so the choice is not the document's to make`;
+};
+var resolveSddResources = async (model, options = {}) => {
+  const resolved = [];
+  const indexes = new Map;
+  const pulledAt = new Map;
+  const missingIndexes = new Set;
+  const indexFor = async (cacheFile) => {
+    const cached = indexes.get(cacheFile);
+    if (cached !== undefined)
+      return cached;
+    if (missingIndexes.has(cacheFile))
+      return;
+    const [error, entries] = await catchError(loadResourceIndex(cacheFile));
+    if (error !== undefined && error.message !== MISSING_RESOURCE_INDEX) {
+      throw error;
+    }
+    if (error !== undefined || entries === null) {
+      missingIndexes.add(cacheFile);
+      return;
+    }
+    const rows = entries;
+    indexes.set(cacheFile, rows);
+    const [, meta] = await catchError(loadIndexMetadata(cacheFile));
+    const lastSync = meta?.lastSync;
+    pulledAt.set(cacheFile, typeof lastSync === "number" && !Number.isNaN(new Date(lastSync).getTime()) ? lastSync : null);
+    return rows;
+  };
+  for (const stage of model.stages) {
+    for (const task of stage.tasks) {
+      const taskType = String(task.type ?? "");
+      const mapping = TYPE_INDEX[taskType];
+      const name = namedValue(task.resourceName);
+      const folder = namedValue(task.folder);
+      const base = {
+        stage: stage.name,
+        task: task.name,
+        taskType,
+        searchQuery: { name, ...folder !== "" && { folder } }
+      };
+      const empty = {
+        matches: [],
+        selected: null
+      };
+      if (mapping === null) {
+        resolved.push({
+          ...base,
+          ...empty,
+          cacheFile: null,
+          rationale: `a "${taskType}" task runs no tenant resource, so there is nothing to resolve`
+        });
+        continue;
+      }
+      if (mapping === undefined) {
+        resolved.push({
+          ...base,
+          ...empty,
+          cacheFile: null,
+          rationale: `no cache index is defined for the task type "${taskType}"`
+        });
+        continue;
+      }
+      if (name === "") {
+        resolved.push({
+          ...base,
+          ...empty,
+          cacheFile: mapping.cacheFile,
+          rationale: "the task block names no resource, so there is nothing to search for"
+        });
+        continue;
+      }
+      const entries = await indexFor(mapping.cacheFile);
+      if (entries === undefined) {
+        resolved.push({
+          ...base,
+          ...empty,
+          cacheFile: mapping.cacheFile,
+          rationale: `the \`${mapping.cacheFile}\` index is not pulled, so this task was not searched — run \`uip maestro case registry pull\``
+        });
+        continue;
+      }
+      const matches = entries.filter((entry) => namesOf(entry).some((candidate) => candidate === name)).flatMap((entry) => matchesFor(entry, mapping.identifierField, folder));
+      const narrowed = folder === "" ? matches : matches.filter((match) => sameFolder(match.folder, folder));
+      const candidates = narrowed.length > 0 ? narrowed : matches;
+      const selected = candidates.length === 1 && candidates === narrowed ? candidates[0] : null;
+      resolved.push({
+        ...base,
+        cacheFile: mapping.cacheFile,
+        matches,
+        selected,
+        rationale: rationaleFor({
+          selected,
+          matches,
+          candidates,
+          folder,
+          narrowed: narrowed.length
+        })
+      });
+    }
+  }
+  const groups = new Map;
+  for (const entry of resolved) {
+    if (entry.selected !== null || entry.cacheFile === null)
+      continue;
+    if (entry.searchQuery.name === "")
+      continue;
+    if (missingIndexes.has(entry.cacheFile))
+      continue;
+    const key = JSON.stringify([entry.searchQuery.name, entry.taskType]);
+    const group = groups.get(key) ?? {
+      name: entry.searchQuery.name,
+      taskType: entry.taskType,
+      reason: entry.matches.length > 0 ? "ambiguous" : "absent",
+      usages: [],
+      candidates: entry.matches,
+      creatable: TYPE_INDEX[entry.taskType]?.creatable === true
+    };
+    group.usages.push({ stage: entry.stage, task: entry.task });
+    groups.set(key, group);
+  }
+  return {
+    resolved,
+    unresolved: [...groups.values()],
+    scope: {
+      indexes: [...indexes.keys()].sort(byCodeUnit),
+      missingIndexes: [...missingIndexes].sort(byCodeUnit),
+      siblingsChecked: false,
+      cache: cacheAge(pulledAt, options.now ?? Date.now())
+    }
+  };
+};
+var cacheAge = (recorded, now) => {
+  const pulledAt = new Map([...recorded].map(([name, at]) => [
+    name,
+    at !== null && at > now ? null : at
+  ]));
+  const names = [...pulledAt.keys()].sort(byCodeUnit);
+  const known = names.map((name) => pulledAt.get(name)).filter((at) => typeof at === "number");
+  const oldest = known.length === 0 ? undefined : Math.min(...known);
+  const ageSeconds = oldest === undefined ? null : Math.max(0, Math.floor((now - oldest) / 1000));
+  const unknown = names.some((name) => pulledAt.get(name) === null);
+  return {
+    pulledAt: Object.fromEntries(names.map((name) => {
+      const at = pulledAt.get(name);
+      return [
+        name,
+        typeof at === "number" ? new Date(at).toISOString() : null
+      ];
+    })),
+    oldestPulledAt: oldest === undefined ? null : new Date(oldest).toISOString(),
+    ageSeconds,
+    stale: unknown || ageSeconds !== null && ageSeconds > CACHE_MAX_AGE_SECONDS,
+    maxAgeSeconds: CACHE_MAX_AGE_SECONDS
+  };
+};
+var staleCacheWarning = (cache) => {
+  if (cache?.stale !== true)
+    return;
+  const unrecorded = Object.entries(cache.pulledAt).filter(([, at]) => at === null).map(([name]) => `\`${name}\``);
+  const reasons = [];
+  if (unrecorded.length > 0) {
+    reasons.push(`there is no usable \`registry pull\` time for the ${unrecorded.join(", ")} index${unrecorded.length === 1 ? "" : "es"}, so ${unrecorded.length === 1 ? "its" : "their"} age is unknown`);
+  }
+  if (cache.ageSeconds !== null && cache.ageSeconds > cache.maxAgeSeconds) {
+    reasons.push(`the registry cache is ${Math.round(cache.ageSeconds / 3600)} hour(s) old (pulled ${cache.oldestPulledAt})`);
+  }
+  return `Resolved against a cache that may not match the tenant: ${reasons.join("; and ")}. Run \`uip maestro case registry pull --force\`, then resolve again.`;
+};
+export {
+  CACHE_MAX_AGE_SECONDS,
+  resolveSddResources,
+  staleCacheWarning
+};
+
+//# debugId=7D51E2AE2E0A790564756E2164756E21