@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/packager-tool-vyavrbym.js

@@ -0,0 +1,488 @@
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  STAGE_SELECTOR_RULES,
+  TASK_SELECTOR_RULES,
+  parseIfCell,
+  expandXrefs,
+  canonicalExpression,
+  unquoteLiteral
+} from "./packager-tool-1nfdj0zm.js";
+import {
+  BINDING_REFERENCE_PREFIX
+} from "./packager-tool-nfhtwa72.js";
+import {
+  connectionPairFor
+} from "./packager-tool-b2q8m9pq.js";
+import {
+  referenceSpellings,
+  indexKey,
+  scopedSlaKey
+} from "./packager-tool-5w0gjcck.js";
+import {
+  prefixedId
+} from "./packager-tool-1h7abxw6.js";
+import {
+  v2ConfigurationVersionEntry
+} from "./packager-tool-68648y3j.js";
+
+// src/services/sdd-convert/business-events.ts
+var JSON_SCHEMA_DRAFT_7 = "http://json-schema.org/draft-07/schema#";
+var payloadSchema = (text) => {
+  const [error, parsed] = catchError2(() => JSON.parse(text));
+  if (error)
+    return { error: "is not JSON" };
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { error: "is not a JSON Schema object" };
+  }
+  const schema = parsed;
+  const properties = schema.properties;
+  const declares = schema.type === "array" || typeof properties === "object" && properties !== null && Object.keys(properties).length > 0;
+  if (!declares)
+    return {};
+  return {
+    schema: JSON.stringify({
+      ...schema,
+      $schema: schema.$schema ?? JSON_SCHEMA_DRAFT_7
+    })
+  };
+};
+var emitBusinessEvents = (document, events, unresolved) => {
+  if (events === undefined || events.length === 0)
+    return 0;
+  const plan = document;
+  plan.metadata ??= {};
+  const metadata = plan.metadata;
+  metadata.businessEvents = events.map((event) => {
+    const read = event.payload === undefined ? {} : payloadSchema(event.payload);
+    if (read.error !== undefined) {
+      unresolved.push({
+        kind: "business-event",
+        where: `metadata.businessEvents[${event.name}]`,
+        detail: `business event "${event.name}"'s Payload ${read.error}, so the event is declared with no payload schema; write it as a JSON Schema object such as \`{"type": "object", "properties": {"amount": {"type": "number"}}}\``
+      });
+    }
+    return {
+      name: event.name,
+      ...event.description !== undefined && {
+        description: event.description
+      },
+      ...read.schema !== undefined && { schema: read.schema }
+    };
+  });
+  return events.length;
+};
+var applyApiEvent = (base, argumentList, context) => {
+  const name = argumentList[0];
+  if (name === undefined) {
+    context.unresolved.push({
+      kind: "selector-target",
+      where: context.where,
+      detail: '`api-event` names no business event, so the rule listens for nothing; write `api-event("<name>")` with a name from `### Business Events`'
+    });
+    return;
+  }
+  base.businessEventType = name;
+  if (context.businessEvents?.has(name) !== true) {
+    context.unresolved.push({
+      kind: "selector-target",
+      where: context.where,
+      detail: `\`api-event\` listens for a business event named "${name}", which \`### Business Events\` does not declare; rules match on the exact name, so declare it there`
+    });
+  }
+};
+
+// src/services/exit-condition-types.ts
+var EXIT_CONDITION_TYPES = new Set([
+  "exit-only",
+  "wait-for-user",
+  "return-to-origin"
+]);
+
+// src/services/sdd-convert/connector.ts
+var connectorInputs = (inputs, connector, elementId, where, unresolved) => {
+  if (connector === undefined)
+    return inputs;
+  if (inputs.length === 0) {
+    if (String(connector.serviceType ?? "") !== "Intsvc.WaitForEvent") {
+      return inputs;
+    }
+    const id = prefixedId("v", 8);
+    return [
+      { name: "body", type: "json", value: "", id, var: id, elementId }
+    ];
+  }
+  if (connector.method === undefined) {
+    unresolved.push({
+      kind: "connector-context",
+      where,
+      detail: `${inputs.length} connector input(s) stay flat: the document states no method for this activity, so which of pathParameters/queryParameters/body each belongs in is not decidable from it`
+    });
+    return inputs;
+  }
+  const bodies = new Map;
+  const kept = [];
+  for (const input of inputs) {
+    const field = String(input.name ?? "");
+    const container = containerFor(field, connector);
+    if (container === undefined) {
+      kept.push(input);
+      continue;
+    }
+    const body = bodies.get(container) ?? {};
+    body[field] = unquoteLiteral(String(input.value ?? ""));
+    bodies.set(container, body);
+  }
+  if (bodies.size === 0)
+    return kept;
+  if (!bodies.has("pathParameters"))
+    bodies.set("pathParameters", {});
+  const containers = [];
+  for (const name of ["pathParameters", "queryParameters", "body"]) {
+    const body = bodies.get(name);
+    if (body === undefined)
+      continue;
+    const id = prefixedId("v", 8);
+    containers.push({
+      name,
+      type: "json",
+      target: name,
+      body,
+      id,
+      var: id,
+      elementId
+    });
+  }
+  return [...containers, ...kept];
+};
+var connectorContextFor = (connector, where, connections, bindings, unresolved) => {
+  const entry = (name, value) => typeof value === "string" && value !== "" ? [{ name, type: "string", value }] : [];
+  const connectionId = String(connector.connectionId ?? "");
+  const context = [
+    ...entry("connectorKey", connector.connectorKey),
+    ...entry("resourceKey", connectionId),
+    ...entry("objectName", connector.objectName),
+    ...entry("operation", connector.operation ?? connector.method),
+    ...entry("method", connector.method),
+    ...entry("path", connector.path)
+  ];
+  if (connectionId !== "") {
+    let ref = connections.get(connectionId);
+    if (ref === undefined) {
+      const pair = connectionPairFor(connectionId, connections.size + 1);
+      bindings.push(pair.connection, pair.folder);
+      ref = pair.connectionRef;
+      connections.set(connectionId, ref);
+    }
+    context.push({
+      name: "connection",
+      type: "string",
+      value: `${BINDING_REFERENCE_PREFIX}${ref}`
+    });
+  } else {
+    unresolved.push({
+      kind: "connector-connection",
+      where,
+      detail: "the document names no connection id, so nothing can be bound for this activity"
+    });
+  }
+  const activityTypeId = String(connector.activityTypeId ?? "");
+  if (activityTypeId !== "") {
+    context.push({
+      name: "metadata",
+      type: "json",
+      body: {
+        activityPropertyConfiguration: {
+          uiPathActivityTypeId: activityTypeId
+        }
+      }
+    }, v2ConfigurationVersionEntry());
+  }
+  unresolved.push({
+    kind: "connector-context",
+    where,
+    detail: `\`folderKey\` binds the folder's GUID and \`metadata.activityPropertyConfiguration.configuration\` carries the connector version and instance parameters; the document states a folder path and no schema, so ${activityTypeId === "" ? "those and the activity type id" : "both"} come from \`case spec\` against a tenant`
+  });
+  return context;
+};
+var QUERY_METHODS = new Set(["GET", "HEAD", "DELETE", "OPTIONS"]);
+var containerFor = (field, connector) => {
+  const method = String(connector?.method ?? "").toUpperCase();
+  if (method === "")
+    return;
+  const path = String(connector?.path ?? "");
+  if (path.includes(`{${field}}`))
+    return "pathParameters";
+  return QUERY_METHODS.has(method) ? "queryParameters" : "body";
+};
+
+// src/services/sdd-convert/rules.ts
+var RULE_VOCABULARY = new Set([
+  "wait-for-connector",
+  "case-entered",
+  "selected-stage-completed",
+  "selected-stage-exited",
+  "selected-tasks-completed",
+  "current-stage-entered",
+  "adhoc",
+  "required-stages-completed",
+  "required-tasks-completed",
+  "user-selected-stage",
+  "runs-sequentially",
+  "sla-status-change",
+  "api-event"
+]);
+var parseWhen = (cell) => {
+  const text = cell.replaceAll("`", "").trim();
+  const bare = /^([a-z-]+)/i.exec(text);
+  const rule = bare ? bare[1] : "";
+  const open = text.indexOf("(");
+  if (rule === "" || open === -1)
+    return { rule, argumentList: [] };
+  let depth = 0;
+  let close = -1;
+  for (let at = open;at < text.length; at += 1) {
+    if (text[at] === "(")
+      depth += 1;
+    else if (text[at] === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        close = at;
+        break;
+      }
+    }
+  }
+  const inner = text.slice(open + 1, close === -1 ? undefined : close);
+  const quoted = [...inner.matchAll(/"([^"]*)"/g)].map((match) => match[1].trim());
+  if (quoted.length > 0) {
+    return { rule, argumentList: quoted.filter((one) => one !== "") };
+  }
+  const plain = inner.split("(")[0].trim();
+  return { rule, argumentList: plain === "" ? [] : [plain] };
+};
+var resolveStage = (argument, stages) => {
+  for (const variant of referenceSpellings(argument)) {
+    const found = stages.get(indexKey(variant));
+    if (found !== undefined)
+      return found;
+  }
+  const prefix = indexKey(argument);
+  const matches = [...stages.entries()].filter(([name]) => name.startsWith(prefix) && /^[\s\-:_]/.test(name.slice(prefix.length)));
+  return matches.length === 1 ? matches[0][1] : undefined;
+};
+var ruleFor = (condition, idPrefix, context) => {
+  const whenCell = typeof condition.when === "string" ? condition.when : "";
+  const { rule, argumentList } = parseWhen(whenCell);
+  const parsedIf = parseIfCell(typeof condition.ifExpression === "string" ? condition.ifExpression : "");
+  const ifExpression = parsedIf.expression;
+  if (!RULE_VOCABULARY.has(rule)) {
+    context.unresolved.push({
+      kind: "condition-rule",
+      where: context.where,
+      detail: whenCell === "" ? "the condition row names no WHEN rule, so the condition is left out" : `the WHEN cell "${whenCell}" is not one of the rules the plan accepts, so the condition is left out`
+    });
+    return;
+  }
+  const base = { id: prefixedId(`${idPrefix}r`, 6), rule };
+  if (ifExpression !== "" && ifExpression !== "—") {
+    base.conditionExpression = canonicalExpression(expandXrefs(ifExpression, context));
+  }
+  const argument = argumentList[0];
+  const selectorMiss = (what, named) => {
+    context.unresolved.push({
+      kind: "selector-target",
+      where: context.where,
+      detail: `\`${rule}\` selects ${named === undefined ? `no ${what}` : `a ${what} named "${named}", which this SDD does not declare`}`
+    });
+  };
+  if (STAGE_SELECTOR_RULES.has(rule)) {
+    const wanted = parsedIf.stage ?? argument;
+    const id = wanted === undefined ? undefined : resolveStage(wanted, context.stages);
+    if (id === undefined)
+      selectorMiss("stage", parsedIf.stage ?? argument);
+    else
+      base.selectedStageIds = [id];
+  } else if (TASK_SELECTOR_RULES.has(rule)) {
+    const named = parsedIf.tasks === undefined ? argumentList : parsedIf.tasks.split(",").map((one) => one.trim());
+    const ids = [];
+    for (const name of named) {
+      const exact = context.tasks.get(name);
+      const folded = exact === undefined ? context.taskNameConflicts?.get(indexKey(name)) : undefined;
+      const id = exact ?? (folded === undefined ? context.tasks.get(indexKey(name)) : undefined);
+      if (id !== undefined && context.stageTasks?.has(id) === false) {
+        context.unresolved.push({
+          kind: "selector-target",
+          where: context.where,
+          detail: `\`${rule}\` selects a task named "${name}", which is in another stage. A stage's rules and its tasks' rules select only that stage's own tasks, so name one of them`
+        });
+        continue;
+      }
+      if (id !== undefined) {
+        ids.push(id);
+        continue;
+      }
+      if (folded === undefined) {
+        selectorMiss("task", name);
+        continue;
+      }
+      const shared = new Set(folded).size < folded.length;
+      if (shared) {
+        context.unresolved.push({
+          kind: "selector-target",
+          where: context.where,
+          detail: `\`${rule}\` selects a task named "${name}", and ${folded.length} tasks answer to it (${[
+            ...new Set(folded)
+          ].map((one) => `"${one}"`).join(", ")}). Task names are unique across the case, so rename all but one and point the selector at the one it means`
+        });
+        continue;
+      }
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `\`${rule}\` selects a task named "${name}", which matches none of this SDD's task names exactly and more than one when case and surrounding space are ignored (${folded.map((one) => `"${one}"`).join(", ")}) — task names are compared exactly, so the selector has to spell one of them`
+      });
+    }
+    if (ids.length === 0 && named.length === 0) {
+      selectorMiss("task");
+    }
+    if (ids.length > 0)
+      base.selectedTasksIds = ids;
+  } else if (rule === "api-event") {
+    applyApiEvent(base, argumentList, context);
+  } else if (rule === "sla-status-change") {
+    const title = argumentList.at(-1);
+    const found = title === undefined ? undefined : context.slas?.get(indexKey(title));
+    if (found === undefined) {
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `\`sla-status-change\` selects ${title === undefined ? "no SLA" : `an SLA named "${title}", which neither the case nor any stage in this SDD declares`}`
+      });
+    } else {
+      if (argumentList.length < 2) {
+        base.slaId = found.id;
+      } else {
+        const named = argumentList[0];
+        const scope = indexKey(named) === "root" ? "root" : resolveStage(named, context.stages);
+        if (scope === undefined) {
+          selectorMiss("stage", named);
+          base.slaId = found.id;
+        } else {
+          const own = context.slas?.get(scopedSlaKey(scope, indexKey(title ?? "")));
+          if (own !== undefined) {
+            base.slaId = own.id;
+          } else {
+            context.unresolved.push({
+              kind: "selector-target",
+              where: context.where,
+              detail: `\`sla-status-change\` names the SLA "${title}" in ${scope === "root" ? "the case" : `stage "${named}"`}, and that SLA belongs to ${found.stageId === "root" ? "the case" : "another stage"}, so the rule is left without an \`slaId\` rather than watching an SLA it was not written for`
+            });
+          }
+        }
+      }
+    }
+  } else if (rule === "wait-for-connector") {
+    if (context.connector === undefined || context.connections === undefined || context.bindings === undefined) {
+      context.unresolved.push({
+        kind: "connector-connection",
+        where: context.where,
+        detail: "a `wait-for-connector` rule needs its activity's context, and no `**Connector Rule Detail:**` accompanies this stage's entry table, so the rule is written with an empty `context` to fill before debug"
+      });
+      base.uipath = {
+        serviceType: WAIT_FOR_EVENT,
+        context: [],
+        inputs: [],
+        outputs: [],
+        bindings: []
+      };
+    } else {
+      const built = connectorContextFor(context.connector, context.where, context.connections, context.bindings, context.unresolved).filter((entry) => entry.name !== "operation" || context.connector?.operation !== undefined);
+      const missing = missingActivitySlots(built);
+      if (missing.length > 0) {
+        context.unresolved.push({
+          kind: "connector-context",
+          where: context.where,
+          detail: `the document names no ${missing.map((name) => `\`${name}\``).join(" or ")} for this \`wait-for-connector\` rule, so it is left out of the rule's \`context\`, to fill before debug`
+        });
+      }
+      base.uipath = {
+        serviceType: WAIT_FOR_EVENT,
+        context: built,
+        ...missing.length > 0 && {
+          inputs: [],
+          outputs: [],
+          bindings: []
+        }
+      };
+    }
+  }
+  return base;
+};
+var WAIT_FOR_EVENT = "Intsvc.WaitForEvent";
+var ACTIVITY_SLOTS = ["connectorKey", "operation"];
+var missingActivitySlots = (entries) => ACTIVITY_SLOTS.filter((name) => !entries.some((entry) => entry.name === name && typeof entry.value === "string" && entry.value !== ""));
+var displayNameOf = (condition) => {
+  const name = String(condition.displayName ?? "").trim();
+  return name === "" ? {} : { displayName: name };
+};
+var entryConditionFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    isInterrupting: condition.interrupting === true,
+    rules: [[rule]]
+  };
+};
+var caseExitRuleFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    marksCaseComplete: condition.marksComplete === true,
+    rules: [[rule]]
+  };
+};
+var exitConditionFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  const declaredExit = typeof condition.exitType === "string" && condition.exitType !== "" ? condition.exitType.trim() : undefined;
+  const exitType = declaredExit !== undefined && EXIT_CONDITION_TYPES.has(declaredExit) ? declaredExit : undefined;
+  if (declaredExit !== undefined && exitType === undefined) {
+    context.unresolved.push({
+      kind: "case-exit",
+      where: `${context.where}.type`,
+      detail: `the exit type "${declaredExit}" is none of ${[...EXIT_CONDITION_TYPES].map((type) => `\`${type}\``).join(", ")}, so no type is written — the rule still exits, and whichever of those three the document meant has to be chosen`
+    });
+  }
+  const exitTo = typeof condition.exitToStage === "string" ? condition.exitToStage : "";
+  let exitToStageId;
+  if (exitTo !== "") {
+    exitToStageId = resolveStage(exitTo, context.stages);
+    if (exitToStageId === undefined) {
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `the Exit-To Stage cell names "${exitTo}", which this SDD does not declare as a stage, so the exit routes nowhere`
+      });
+    }
+  }
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    ...exitType !== undefined && { type: exitType },
+    ...exitToStageId !== undefined && { exitToStageId },
+    marksStageComplete: condition.marksComplete === true,
+    rules: [[rule]]
+  };
+};
+
+export { emitBusinessEvents, connectorInputs, connectorContextFor, RULE_VOCABULARY, parseWhen, entryConditionFor, caseExitRuleFor, exitConditionFor };
+
+//# debugId=1A5D045F6F14E87464756E2164756E21