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

package/dist/packager-tool-gy4yjqhf.js

@@ -0,0 +1,178 @@
+import {
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  eventTriggerResourceKey,
+  buildEventTriggerResource,
+  packageStoredBinding,
+  buildParameterPropertyResource
+} from "./packager-tool-h2ar8xf8.js";
+import {
+  CONNECTION_ID_PROPERTY2
+} from "./packager-tool-kz7zz79p.js";
+
+// src/services/case-event-trigger-bindings.ts
+var ENTRY_POINTS_FILE_NAME = "entry-points.json";
+var EVENT_TRIGGER_SERVICE_TYPE = "Intsvc.EventTrigger";
+var TRIGGER_NODE_TYPES = new Set([
+  "uipath.case.trigger",
+  "case-management:Trigger"
+]);
+var BINDING_REFERENCE_PREFIX = "=bindings.";
+var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var asString = (value) => typeof value === "string" && value !== "" ? value : undefined;
+var nonEmpty = (value) => {
+  const record = asRecord(value);
+  return record !== undefined && Object.keys(record).length > 0 ? record : undefined;
+};
+function entryPointIdsByNode2(entryPoints) {
+  const ids = new Map;
+  const list = asRecord(entryPoints)?.entryPoints;
+  if (!Array.isArray(list))
+    return ids;
+  for (const item of list) {
+    const entry = asRecord(item);
+    const filePath = asString(entry?.filePath);
+    const uniqueId = asString(entry?.uniqueId);
+    const hash = filePath?.lastIndexOf("#") ?? -1;
+    if (filePath === undefined || uniqueId === undefined || hash < 0)
+      continue;
+    const node = filePath.slice(hash + 1);
+    if (!ids.has(node))
+      ids.set(node, uniqueId);
+  }
+  return ids;
+}
+async function readEntryPointIds2(casePlanPath) {
+  const fs = getFileSystem2();
+  const path = fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), ENTRY_POINTS_FILE_NAME);
+  if (!await fs.exists(path))
+    return { ids: new Map };
+  const [readError, raw] = await catchError2(fs.readFile(path, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      error: `Could not read ${path}: ${readError?.message ?? "the file is no longer there"}`,
+      path
+    };
+  }
+  const [parseError, parsed] = catchError2(() => JSON.parse(raw));
+  if (parseError) {
+    return {
+      error: `${path} is not valid JSON: ${parseError.message}`,
+      path
+    };
+  }
+  return { ids: entryPointIdsByNode2(parsed) };
+}
+function readTrigger(node) {
+  const record = asRecord(node);
+  const nodeId = asString(record?.id);
+  if (nodeId === undefined || !TRIGGER_NODE_TYPES.has(String(record?.type)))
+    return;
+  const data = asRecord(record?.data);
+  const container = [asRecord(data?.inputs), asRecord(data?.uipath)].find((candidate) => candidate?.serviceType === EVENT_TRIGGER_SERVICE_TYPE);
+  if (container === undefined || !Array.isArray(container.context))
+    return;
+  const context = new Map;
+  for (const item of container.context) {
+    const entry = asRecord(item);
+    const name = asString(entry?.name);
+    if (name !== undefined)
+      context.set(name, entry?.value ?? entry?.body);
+  }
+  const bodyInput = Array.isArray(container.inputs) ? container.inputs.map(asRecord).find((input) => input?.name === "body") : undefined;
+  return {
+    nodeId,
+    activityName: asString(asRecord(data?.display)?.label) ?? asString(data?.label) ?? asString(context.get("operation")),
+    context,
+    body: asRecord(bodyInput?.body),
+    metadataBody: asRecord(context.get("metadata"))
+  };
+}
+function findConnectionBinding(trigger, bindings) {
+  const connections = bindings.filter((binding) => binding.resource === "Connection" && binding.propertyAttribute === CONNECTION_ID_PROPERTY2);
+  const reference = asString(trigger.context.get("connection"));
+  if (reference?.startsWith(BINDING_REFERENCE_PREFIX)) {
+    const id = reference.slice(BINDING_REFERENCE_PREFIX.length);
+    const byId = connections.find((binding) => binding.id === id);
+    if (byId !== undefined)
+      return byId;
+  }
+  const resourceKey = asString(trigger.context.get("resourceKey"));
+  return connections.find((binding) => binding.resourceKey === resourceKey);
+}
+function eventTriggerResource(trigger, connectionId, entryPointId) {
+  const apc = asRecord(trigger.metadataBody?.activityPropertyConfiguration);
+  return buildEventTriggerResource({
+    connectionKey: connectionId,
+    nodeId: trigger.nodeId,
+    entryPointId,
+    connector: asString(trigger.context.get("connectorKey")),
+    activityName: trigger.activityName,
+    objectName: objectName(trigger),
+    operation: asString(trigger.context.get("operation")),
+    filterExpression: asString(apc?.filterExpression) ?? asString(asRecord(trigger.body?.filters)?.expression)
+  });
+}
+var objectName = (trigger) => asString(trigger.context.get("objectName")) ?? asString(asRecord(trigger.metadataBody?.activityPropertyConfiguration)?.objectName);
+function storedPropertyResources(trigger, parentResourceKey) {
+  const stored = trigger.metadataBody?.bindings;
+  if (!Array.isArray(stored) || stored.length === 0)
+    return;
+  return stored.flatMap((raw) => {
+    const entry = asRecord(raw);
+    if (typeof entry?.resource !== "string" || typeof entry.key !== "string")
+      return [];
+    return [
+      packageStoredBinding(entry, {
+        nodeId: trigger.nodeId,
+        activityName: trigger.activityName,
+        parentResourceKey
+      })
+    ];
+  });
+}
+function propertyResources(trigger, parentResourceKey) {
+  const stored = storedPropertyResources(trigger, parentResourceKey);
+  if (stored !== undefined)
+    return stored;
+  const parameters = nonEmpty(trigger.body?.queryParams) ?? nonEmpty(trigger.body?.parameters);
+  const operation = asString(trigger.context.get("operation"));
+  if (parameters === undefined || operation === undefined)
+    return [];
+  return [
+    buildParameterPropertyResource({
+      key: operation,
+      nodeId: trigger.nodeId,
+      parameters,
+      activityName: trigger.activityName,
+      objectName: objectName(trigger),
+      parentResourceKey
+    })
+  ];
+}
+function deriveEventTriggerResources2(nodes, bindings, entryPointIds) {
+  if (!Array.isArray(nodes))
+    return [];
+  return nodes.flatMap((node) => {
+    const trigger = readTrigger(node);
+    if (trigger === undefined)
+      return [];
+    const binding = findConnectionBinding(trigger, bindings);
+    if (binding === undefined)
+      return [];
+    const connectionId = binding.default ?? binding.resourceKey;
+    const key = eventTriggerResourceKey(connectionId, trigger.nodeId);
+    return [
+      eventTriggerResource(trigger, connectionId, entryPointIds.get(trigger.nodeId)),
+      ...propertyResources(trigger, `EventTrigger.${key}`)
+    ];
+  });
+}
+
+export { entryPointIdsByNode2, readEntryPointIds2, deriveEventTriggerResources2 };
+
+//# debugId=DE6B26E58776F4C864756E2164756E21

package/dist/packager-tool-h2ar8xf8.js

@@ -0,0 +1,222 @@
+// ../integrationservice-sdk/src/dap/bindings-v2.ts
+var BINDINGS_VERSION = "2.2";
+var JSON_STRING_PREFIX = "=jsonString:";
+var guardJsonString = (json) => `${JSON_STRING_PREFIX}${json}`;
+var stripJsonStringGuard = (value) => value.startsWith(JSON_STRING_PREFIX) ? value.slice(JSON_STRING_PREFIX.length) : value;
+function mapStringsDeep(value, map) {
+  if (typeof value === "string")
+    return map(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => mapStringsDeep(entry, map));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      mapStringsDeep(entry, map)
+    ]));
+  }
+  return value;
+}
+var restoreJsonStringsDeep = (value) => mapStringsDeep(value, stripJsonStringGuard);
+var CONN_BINDING_ID_PLACEHOLDER = "{{CONN_BINDING_ID}}";
+var FOLDER_BINDING_ID_PLACEHOLDER = "{{FOLDER_BINDING_ID}}";
+var RESOURCE_BINDING_ID_PREFIX = "{{RESOURCE_BINDING_ID:";
+var resourceBindingIdPlaceholder = (field) => `${RESOURCE_BINDING_ID_PREFIX}${field}}}`;
+var optional = (key, value) => value ? { [key]: value } : {};
+var eventTriggerResourceKey = (connectionKey, nodeId) => [connectionKey, nodeId].filter(Boolean).join("_");
+function buildEventTriggerResource(spec) {
+  const key = eventTriggerResourceKey(spec.connectionKey, spec.nodeId);
+  return {
+    resource: "EventTrigger",
+    key,
+    id: `EventTrigger${key}`,
+    value: {
+      ConnectionId: {
+        defaultValue: spec.connectionKey,
+        isExpression: false
+      },
+      ...spec.entryPointId && {
+        EntryPointUniqueId: {
+          defaultValue: spec.entryPointId,
+          isExpression: false
+        }
+      }
+    },
+    metadata: {
+      UseConnectionService: "true",
+      ...optional("Connector", spec.connector),
+      ...optional("ActivityName", spec.activityName),
+      BindingsVersion: BINDINGS_VERSION,
+      ...optional("ObjectName", spec.objectName),
+      ...optional("Operation", spec.operation),
+      FilterExpression: spec.filterExpression ?? ""
+    }
+  };
+}
+function packageStoredBinding(row, owner) {
+  const clone = restoreJsonStringsDeep(structuredClone(row));
+  const metadata = {
+    ...isRecord(clone.metadata) ? clone.metadata : {},
+    ...optional("ActivityName", owner.activityName)
+  };
+  clone.metadata = metadata;
+  if (clone.resource === "Property") {
+    clone.id = `Property_${owner.nodeId}`;
+    if (owner.operation && owner.parentResourceKey && clone.key === owner.operation) {
+      clone.key = `${owner.operation}_${owner.parentResourceKey}`;
+    }
+    metadata.ParentResourceKey = owner.parentResourceKey;
+  }
+  return clone;
+}
+function buildParameterPropertyResource(spec) {
+  const names = Object.keys(spec.parameters).join(",");
+  return {
+    resource: "Property",
+    key: spec.key,
+    id: `Property_${spec.nodeId}`,
+    value: Object.fromEntries(Object.entries(spec.parameters).map(([name, raw]) => [
+      name,
+      { defaultValue: String(raw), isExpression: false }
+    ])),
+    metadata: {
+      TriggerCreateParameters: names,
+      DebugQueryParameters: names,
+      ...optional("ActivityName", spec.activityName),
+      BindingsVersion: BINDINGS_VERSION,
+      ...optional("ObjectName", spec.objectName),
+      ParentResourceKey: spec.parentResourceKey
+    }
+  };
+}
+function upsertResourceBinding(bindings, row, mintId) {
+  const existing = bindings.find((binding) => binding.resource === row.resource && binding.resourceKey === row.resourceKey && binding.propertyAttribute === row.propertyAttribute);
+  if (existing) {
+    if (typeof existing.id !== "string" || existing.id === "") {
+      existing.id = mintId();
+    }
+    existing.name = row.name;
+    existing.default = row.default;
+    return { binding: existing, created: false };
+  }
+  const binding = {
+    id: mintId(),
+    name: row.name,
+    type: "string",
+    resource: row.resource,
+    resourceKey: row.resourceKey,
+    ...row.default ? { default: row.default } : {},
+    propertyAttribute: row.propertyAttribute
+  };
+  return { binding, created: true };
+}
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+// ../integrationservice-sdk/src/dap/activity-bindings.ts
+var DROPPED_RESOURCES = ["connection", "eventtrigger"];
+var isResourceType = (resource, types) => types.includes((resource ?? "").toLowerCase());
+function storedActivityBindings(bindings) {
+  return bindings.filter((binding) => !isResourceType(binding.resource, DROPPED_RESOURCES));
+}
+function planResourceBindings(stored, resolved) {
+  const plans = [];
+  for (const { field, companion, selection } of resolved) {
+    const entry = stored.find((binding) => binding.key?.toLowerCase() === selection.key.toLowerCase() && !isResourceType(binding.resource, ["property"]));
+    if (entry === undefined)
+      continue;
+    const displayName = entry.value?.name?.displayName ?? field;
+    const rows = [
+      {
+        field,
+        propertyAttribute: "name",
+        name: displayName,
+        default: selection.name
+      }
+    ];
+    if (entry.value?.folderKey && selection.folderKey) {
+      rows.push({
+        field: companion,
+        propertyAttribute: "folderKey",
+        name: `${displayName} folder`,
+        default: selection.folderKey
+      });
+    }
+    plans.push({
+      resource: entry.resource,
+      resourceKey: selection.key,
+      rows
+    });
+  }
+  return plans;
+}
+
+// ../integrationservice-sdk/src/dap/external-execution.ts
+function externalExecutionOf(metadata) {
+  if (typeof metadata !== "object" || metadata === null)
+    return;
+  const record = metadata;
+  const executionType = record.executionType;
+  if (typeof executionType !== "string" || executionType === "") {
+    return;
+  }
+  if (executionType !== "async" && executionType !== "hybrid") {
+    return { executionType };
+  }
+  const events = record.metadata?.events;
+  const eventMode = Array.isArray(events?.eventMode) ? String(events.eventMode[0] ?? "") : undefined;
+  const source = eventMode === "webhooks" ? events?.webhook : eventMode === "polling" ? events?.polling : undefined;
+  const eventTypes = source?.eventTypes;
+  return {
+    executionType,
+    ...eventMode && { eventMode },
+    ...eventTypes?.[0]?.operation && {
+      eventType: eventTypes[0].operation
+    }
+  };
+}
+function externalExecutionWarning(external, target) {
+  const { executionType, eventType } = external;
+  if (executionType === "sync" || eventType)
+    return;
+  return executionType === "async" || executionType === "hybrid" ? `"${target}" runs ${executionType}, but its metadata names no event it answers with, so the node has nothing to wait on and may never finish.` : `"${target}" has execution type "${executionType}", which is neither sync nor async, so it is saved as is and may not run.`;
+}
+var EXTERNAL_SERVICE_TYPES = {
+  agent: {
+    sync: "Intsvc.SyncAgentExecution",
+    async: "Intsvc.AsyncAgentExecution"
+  },
+  workflow: {
+    sync: "Intsvc.SyncWorkflowExecution",
+    async: "Intsvc.AsyncWorkflowExecution"
+  }
+};
+function externalServiceType(kind, executionType) {
+  const mode = executionType === "hybrid" ? "async" : executionType;
+  return mode === "sync" || mode === "async" ? EXTERNAL_SERVICE_TYPES[kind][mode] : undefined;
+}
+
+// ../integrationservice-sdk/src/dap/managed-http.ts
+var MANAGED_HTTP_METHODS = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+var MANAGED_HTTP_KEYS = new Set([
+  "authentication",
+  "method",
+  "url",
+  "connectionId",
+  "folderKey",
+  "targetConnector",
+  "headers",
+  "query",
+  "body"
+]);
+
+export { storedActivityBindings, planResourceBindings, BINDINGS_VERSION, guardJsonString, stripJsonStringGuard, mapStringsDeep, CONN_BINDING_ID_PLACEHOLDER, FOLDER_BINDING_ID_PLACEHOLDER, RESOURCE_BINDING_ID_PREFIX, resourceBindingIdPlaceholder, eventTriggerResourceKey, buildEventTriggerResource, packageStoredBinding, buildParameterPropertyResource, upsertResourceBinding, externalExecutionOf, externalExecutionWarning, EXTERNAL_SERVICE_TYPES, externalServiceType };
+
+//# debugId=55B5A01E97B21A5664756E2164756E21

package/dist/{packager-tool-v2kcgjbf.js → packager-tool-j6nfje7t.js}

@@ -1,10 +1,10 @@
 import {
   prefixedId
-} from "./packager-tool-mknccck5.js";
+} from "./packager-tool-1h7abxw6.js";
 import {
   DEFAULT_TRIGGER_ID,
   DEFAULT_TRIGGER_LABEL
-} from "./packager-tool-nj4seavy.js";
+} from "./packager-tool-35c9npcy.js";
 
 // src/utils/case-document.ts
 function buildMinimalCaseDocument(options) {
@@ -21,7 +21,8 @@ function buildMinimalCaseDocument(options) {
       caseIdentifier: options.caseIdentifier ?? options.name,
       caseAppEnabled: options.caseAppEnabled ?? false,
       caseIdentifierType: options.identifierType ?? "constant",
-      publishVersion: 2
+      publishVersion: 2,
+      intsvcActivityConfig: "v2"
     },
     nodes: [
       {
@@ -40,4 +41,4 @@ function buildMinimalCaseDocument(options) {
 
 export { buildMinimalCaseDocument };
 
-//# debugId=F5C6C653548DE78B64756E2164756E21
+//# debugId=BD5AEFBF8DD3701064756E2164756E21

package/dist/packager-tool-kz7zz79p.js

@@ -0,0 +1,71 @@
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  byCodeUnit
+} from "./packager-tool-1c30ttpm.js";
+
+// src/services/bindings-v2.ts
+var BINDINGS_V2_FILE_NAME2 = "bindings_v2.json";
+var BINDINGS_V2_VERSION = "2.0";
+var CONNECTION_ID_PROPERTY2 = "ConnectionId";
+var FOLDER_KEY_PROPERTY2 = "folderKey";
+var sortBindingsV2Resources = (resources) => [...resources].sort((a, b) => byCodeUnit(a.resource, b.resource) || byCodeUnit(a.key, b.key));
+var serializeBindingsV2File2 = (resources) => {
+  const file = {
+    version: BINDINGS_V2_VERSION,
+    resources: sortBindingsV2Resources(resources)
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+};
+var readBindingsV2Resources2 = (raw) => {
+  const [error, parsed] = catchError2(() => JSON.parse(raw));
+  if (error)
+    return;
+  if (parsed === null || typeof parsed !== "object")
+    return;
+  const resources = parsed.resources;
+  if (!Array.isArray(resources))
+    return;
+  return resources.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.key === "string");
+};
+var identity = (entry) => `${entry.resource}:${entry.key}`;
+var asSaved = (entry, found) => {
+  let saved = entry;
+  if (entry.resource === "Connection" && entry.value[FOLDER_KEY_PROPERTY2] !== undefined && found.value?.[FOLDER_KEY_PROPERTY2] === undefined) {
+    const { [FOLDER_KEY_PROPERTY2]: _dropped, ...value } = entry.value;
+    saved = { ...saved, value };
+  }
+  if (saved.metadata?.ActivityName !== undefined && found.metadata?.ActivityName === undefined) {
+    const { ActivityName: _label, ...metadata } = saved.metadata;
+    saved = { ...saved, metadata };
+  }
+  return saved;
+};
+var diffBindingsV22 = (expected, actual) => {
+  const expectedByKey = new Map(expected.map((e) => [identity(e), e]));
+  const actualByKey = new Map(actual.map((e) => [identity(e), e]));
+  const missing = [];
+  const changed = [];
+  for (const [key, entry] of expectedByKey) {
+    const found = actualByKey.get(key);
+    if (found === undefined) {
+      missing.push(entry.key);
+    } else if (JSON.stringify(found) !== JSON.stringify(asSaved(entry, found))) {
+      changed.push(entry.key);
+    }
+  }
+  const extra = [...actualByKey.values()].filter((entry) => !expectedByKey.has(identity(entry))).map((entry) => entry.key);
+  const alphabetically = (left, right) => left.localeCompare(right);
+  return {
+    missing: missing.sort(alphabetically),
+    extra: extra.sort(alphabetically),
+    changed: changed.sort(alphabetically)
+  };
+};
+var hasBindingsV2Difference2 = (difference) => difference.missing.length > 0 || difference.extra.length > 0 || difference.changed.length > 0;
+
+export { BINDINGS_V2_FILE_NAME2, CONNECTION_ID_PROPERTY2, FOLDER_KEY_PROPERTY2, serializeBindingsV2File2, readBindingsV2Resources2, diffBindingsV22, hasBindingsV2Difference2 };
+
+//# debugId=A1ABBB615ABF984E64756E2164756E21