@uipath/case-tool 1.204.0 → 1.205.0-preview.258

package/dist/migration-diagnosis-ns5cw4e3.js

@@ -0,0 +1,99 @@
+import"./packager-tool-1yh8g550.js";
+
+// src/services/migration-diagnosis.ts
+var LEGACY_NODE_TYPES = [
+  "case-management:Trigger",
+  "case-management:Stage",
+  "case-management:ExceptionStage",
+  "case-management:StickyNote"
+];
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var discriminatorNodeTypes = (migrationError, parsed) => {
+  if (!migrationError.includes("discriminator"))
+    return [];
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const offending = new Set;
+  for (const raw of nodes) {
+    const type = asRecord(raw)?.type;
+    if (typeof type !== "string" || type === "")
+      continue;
+    if (LEGACY_NODE_TYPES.includes(type))
+      continue;
+    offending.add(type);
+  }
+  return [...offending];
+};
+var legacySpellingFor = (type) => {
+  const lower = type.toLowerCase();
+  if (lower.includes("exception"))
+    return "case-management:ExceptionStage";
+  if (lower.includes("stickynote") || lower.includes("sticky"))
+    return "case-management:StickyNote";
+  if (lower.includes("trigger"))
+    return "case-management:Trigger";
+  if (lower.includes("stage"))
+    return "case-management:Stage";
+  return;
+};
+var diagnoseMigrationFailure = (parsed, migrationError, validate) => {
+  const offending = discriminatorNodeTypes(migrationError, parsed);
+  if (offending.length === 0)
+    return;
+  const probe = JSON.parse(JSON.stringify(parsed));
+  const nodes = Array.isArray(probe.nodes) ? probe.nodes : [];
+  let rewrote = false;
+  for (const raw of nodes) {
+    const node = asRecord(raw);
+    const type = node?.type;
+    if (node === undefined || typeof type !== "string")
+      continue;
+    if (!offending.includes(type))
+      continue;
+    const legacy = legacySpellingFor(type);
+    if (legacy === undefined)
+      continue;
+    node.type = legacy;
+    rewrote = true;
+  }
+  if (!rewrote)
+    return { offending, typeIsTheBlocker: false };
+  const result = validate(JSON.stringify(probe));
+  if (result.valid)
+    return { offending, typeIsTheBlocker: true };
+  const remaining = result.migrationError ?? result.issues.map((issue) => `${issue.path}: ${issue.message}`)[0];
+  return { offending, typeIsTheBlocker: false, remainingError: remaining };
+};
+var CURRENT_NAMES_MAJOR = 21;
+var CURRENT_NODE_TYPES = new Set([
+  "uipath.case.trigger"
+]);
+var named = (types) => types.map((type) => `\`${type}\``).join(", ");
+var migrationHeadline = (migrationError) => {
+  const dump = migrationError.indexOf(": [");
+  return dump === -1 ? migrationError : migrationError.slice(0, dump);
+};
+var migrationFailureMessage = (migrationError, diagnosis, declaredMajor, legacyFields) => {
+  if (diagnosis === undefined)
+    return migrationError;
+  if (!diagnosis.typeIsTheBlocker) {
+    return diagnosis.remainingError === undefined ? `${migrationError} The node type is not the only blocker: ${named(diagnosis.offending)} could not be mapped to a legacy name to test.` : `${migrationError} The node type is a symptom, not the cause: with ${named(diagnosis.offending)} written as its legacy name the document still fails, on ${diagnosis.remainingError}. Fix that first.`;
+  }
+  if (declaredMajor === undefined || declaredMajor < CURRENT_NAMES_MAJOR) {
+    return `${migrationError} This document is valid with ${named(diagnosis.offending)} written as the legacy \`case-management:*\` name, so the node type is what this schema version rejects — the migration step that rejected it accepts only those four names, and it ran because the document matched an older version.`;
+  }
+  const current = diagnosis.offending.filter((type) => CURRENT_NODE_TYPES.has(type));
+  const unknown = diagnosis.offending.filter((type) => !CURRENT_NODE_TYPES.has(type));
+  if (unknown.length > 0) {
+    const keep = current.length > 0 ? ` ${named(current)} is the right node type at schema ${declaredMajor}, so do not rename it.` : "";
+    return `${migrationHeadline(migrationError)}. ${named(unknown)} is not a node type schema ${declaredMajor} has: write it as its legacy \`case-management:*\` name, which is what the document is valid with.${keep}`;
+  }
+  const cause = legacyFields > 0 ? ` The ${legacyFields} legacy field(s) reported above are written in an older version's form, which is what makes a document match one: fix those first.` : " Find the field written in an older version's form; the node type is not it.";
+  return `${migrationHeadline(migrationError)}. The document declares schema ${declaredMajor}, where ${named(diagnosis.offending)} is the right node type, so do not rename it. The schema package reads a document's version from its shape, not its \`version\` field: a field in this document does not match schema ${declaredMajor}, so it was read as an older version and migrated from there, and that step accepts only the legacy names.${cause}`;
+};
+export {
+  diagnoseMigrationFailure,
+  discriminatorNodeTypes,
+  migrationFailureMessage
+};
+
+//# debugId=E877AA09EE327A5764756E2164756E21

package/dist/{node-strategy-5pz40tee.js → node-strategy-v442hwgd.js}

@@ -9,7 +9,7 @@ import {
 } from "./packager-tool-yc4kw997.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
+} from "./packager-tool-hdxtgckw.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";

package/dist/node-sync-service-1wkcyn1n.js

@@ -0,0 +1,57 @@
+import {
+  MANIFEST_VALIDATION_NEXT_STEP,
+  TenantManifestInvalidError,
+  filterNodesByKeyword,
+  findNodeByType,
+  getLocalNodeEnriched,
+  getLocalSolutionSnapshot,
+  getNode,
+  getNodeEnriched,
+  isTenantManifestInvalidError,
+  listNodes,
+  loadCurrentTenantNodes,
+  localContractWarning,
+  pullNodes,
+  pullRemoteNodes,
+  searchNodeSummariesWithAvailability,
+  searchNodes,
+  searchNodesWithFilters
+} from "./packager-tool-29x6vran.js";
+import"./packager-tool-ezds6t5e.js";
+import"./packager-tool-r6b5ktzb.js";
+import"./packager-tool-7hw344bt.js";
+import"./packager-tool-n7w9wx62.js";
+import"./packager-tool-yct6zp4m.js";
+import"./packager-tool-4rtktkhv.js";
+import"./packager-tool-pcvhcn2k.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-6z1hsm2h.js";
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-yn33pw57.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-83v804p7.js";
+import"./packager-tool-hdxtgckw.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  MANIFEST_VALIDATION_NEXT_STEP,
+  TenantManifestInvalidError,
+  filterNodesByKeyword,
+  findNodeByType,
+  getLocalNodeEnriched,
+  getLocalSolutionSnapshot,
+  getNode,
+  getNodeEnriched,
+  isTenantManifestInvalidError,
+  listNodes,
+  loadCurrentTenantNodes,
+  localContractWarning,
+  pullNodes,
+  pullRemoteNodes,
+  searchNodeSummariesWithAvailability,
+  searchNodes,
+  searchNodesWithFilters
+};
+
+//# debugId=02B8A88C1949C2BC64756E2164756E21

package/dist/out-target-wjgmna0r.js

@@ -0,0 +1,111 @@
+import {
+  byCodeUnit
+} from "./packager-tool-5qp9xza1.js";
+import {
+  catchError
+} from "./packager-tool-83v804p7.js";
+import"./packager-tool-hdxtgckw.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/sdd-convert/out-target.ts
+var isCaseProject = async (fs, dir) => {
+  const [error, text] = await catchError(fs.readFile(fs.path.join(dir, "project.uiproj"), "utf-8"));
+  if (error || typeof text !== "string")
+    return false;
+  const [parseError, parsed] = await catchError(Promise.resolve().then(() => JSON.parse(text)));
+  if (parseError || typeof parsed !== "object" || parsed === null) {
+    return false;
+  }
+  return parsed.ProjectType === "CaseManagement";
+};
+var planInProject = async (fs, dir) => {
+  const [error, entries] = await catchError(fs.readdir(dir));
+  if (error || entries === undefined) {
+    throw new Error(`Could not list "${dir}" (${error?.message ?? "no entries returned"}) to find the case plan it holds.`);
+  }
+  const { findCasePlanFileName } = await import("./index-n9qvnx4x.js");
+  return findCasePlanFileName(entries);
+};
+var otherPlanInProject = async (fs, out) => {
+  const { CasePlanFileNames } = await import("./index-n9qvnx4x.js");
+  const name = fs.path.basename(out);
+  if (!CasePlanFileNames.includes(name)) {
+    return;
+  }
+  const dir = fs.path.dirname(out);
+  const marker = fs.path.join(dir, "project.uiproj");
+  if (await fs.exists(marker)) {
+    const [error, text] = await catchError(fs.readFile(marker, "utf-8"));
+    if (error || typeof text !== "string") {
+      throw new Error(`Could not read "${marker}" (${error?.message ?? "no content returned"}) to tell whether ${dir} is a case project.`);
+    }
+    const [parseError, parsed] = catchError(() => JSON.parse(text));
+    if (parseError || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`"${marker}" is not a JSON object${parseError ? ` (${parseError.message})` : ""}, so convert cannot tell whether ${dir} is a case project.`);
+    }
+    const type = parsed.ProjectType;
+    if (typeof type !== "string" || type === "") {
+      throw new Error(`"${marker}" carries no ProjectType, so convert cannot tell whether ${dir} is a case project.`);
+    }
+  }
+  if (!await isCaseProject(fs, dir))
+    return;
+  const plan = await planInProject(fs, dir);
+  return plan === undefined || plan === name ? undefined : fs.path.join(dir, plan);
+};
+var projectsBelowOut = async (fs, out) => {
+  const { CasePlanFileNames } = await import("./index-n9qvnx4x.js");
+  if (!CasePlanFileNames.includes(fs.path.basename(out))) {
+    return [];
+  }
+  const dir = fs.path.dirname(out);
+  if (await isCaseProject(fs, dir))
+    return [];
+  const [error, entries] = await catchError(fs.readdir(dir));
+  if (error || entries === undefined)
+    return [];
+  const found = [];
+  for (const entry of [...entries].sort(byCodeUnit)) {
+    const candidate = fs.path.join(dir, entry);
+    const [statError, stat] = await catchError(fs.stat(candidate));
+    if (statError || stat?.isDirectory() !== true)
+      continue;
+    if (await isCaseProject(fs, candidate)) {
+      const [, plan] = await catchError(planInProject(fs, candidate));
+      found.push(fs.path.join(candidate, plan ?? fs.path.basename(out)));
+    }
+  }
+  return found;
+};
+var shellArg = (value) => {
+  if (value.startsWith("-") || /["$`%]/.test(value))
+    return;
+  return /^[\w@+=:,./-]+$/.test(value) ? value : `"${value}"`;
+};
+var correctedConvert = (file, out, resolved) => {
+  const quotedFile = shellArg(file);
+  const quotedOut = shellArg(out);
+  const quotedResolved = resolved === undefined ? undefined : shellArg(resolved);
+  if (quotedFile === undefined || quotedOut === undefined)
+    return;
+  if (resolved !== undefined && quotedResolved === undefined) {
+    return;
+  }
+  return [
+    "uip maestro case sdd convert",
+    quotedFile,
+    ...quotedResolved === undefined ? [] : ["--resolved", quotedResolved],
+    "--out",
+    quotedOut
+  ].join(" ");
+};
+export {
+  correctedConvert,
+  otherPlanInProject,
+  projectsBelowOut,
+  shellArg
+};
+
+//# debugId=7BAD6A36CA16DDEC64756E2164756E21

package/dist/{packager-tool-85q4f3pq.js → packager-tool-1pcmxqny.js}

@@ -1,16 +1,16 @@
 import {
   loadResourceIndex
-} from "./packager-tool-s6619wtx.js";
+} from "./packager-tool-9sd483vs.js";
 import {
   ConnectorsApi,
   createApiClient
-} from "./packager-tool-w1b5pyj6.js";
+} from "./packager-tool-r6b5ktzb.js";
 import {
   TYPECACHE_PACKAGE_INDEX_TYPES
 } from "./packager-tool-7nxppa3d.js";
 import {
   catchError
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 
 // src/services/connector-lookup-service.ts
 async function lookupTypeCacheEntry(uiPathActivityTypeId, type) {

package/dist/{packager-tool-8a9yqfq7.js → packager-tool-1yfw674x.js}

@@ -65,12 +65,14 @@ var readIoRows = (document) => {
   const outputs = pick(data, "outputs", "Outputs");
   if (!Array.isArray(inputs) && !Array.isArray(outputs))
     return;
+  const version = pick(data, "version", "Version");
   return {
     inputs: canonicalList(inputs),
-    outputs: canonicalList(outputs)
+    outputs: canonicalList(outputs),
+    ...typeof version === "string" && { version }
   };
 };
 
 export { readCaseShape, readSpecFolderKey, readIoRows };
 
-//# debugId=FE16A0F1921E68AD64756E2164756E21
+//# debugId=F25BE2C9DB54B39864756E2164756E21