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

package/dist/{packager-tool-4p11fvf4.js → packager-tool-b2q8m9pq.js}

@@ -1,23 +1,21 @@
 import {
-  CONNECTOR_TASK_TYPES
-} from "./packager-tool-93mdeqay.js";
+  CONNECTOR_TASK_TYPES,
+  EXTERNAL_TASK_TYPES
+} from "./packager-tool-7x1tmb8a.js";
 import {
   NAME_BOUND_TASK_TYPES
-} from "./packager-tool-87y6xw3a.js";
+} from "./packager-tool-nfhtwa72.js";
 
 // src/services/sdd-convert/resources.ts
 var SDD_TASK_TYPES = new Set([
   ...NAME_BOUND_TASK_TYPES,
   ...CONNECTOR_TASK_TYPES,
+  ...EXTERNAL_TASK_TYPES,
   "wait-for-timer",
-  "http-request"
-]);
-var UNAUTHORABLE_TASK_TYPES = new Set([
-  "document-extraction",
-  "external-agent",
-  "external-workflow",
-  "script"
+  "http-request",
+  "document-extraction"
 ]);
+var UNAUTHORABLE_TASK_TYPES = new Set(["script"]);
 var RESOURCE_KINDS = new Map([
   ["agent", { resource: "process", subType: "Agent" }],
   ["process", { resource: "process", subType: "ProcessOrchestration" }],
@@ -60,7 +58,6 @@ var bindingPairFor = (resourceName, folderPath, type, ordinal) => {
     }
   };
 };
-var RECIPIENT_TYPES = new Map([["email", 2]]);
 var connectionPairFor = (connectionId, ordinal) => {
   const shared = {
     type: "string",
@@ -87,6 +84,6 @@ var connectionPairFor = (connectionId, ordinal) => {
   };
 };
 
-export { SDD_TASK_TYPES, UNAUTHORABLE_TASK_TYPES, bindingPairFor, RECIPIENT_TYPES, connectionPairFor };
+export { SDD_TASK_TYPES, UNAUTHORABLE_TASK_TYPES, bindingPairFor, connectionPairFor };
 
-//# debugId=A3011B792DCD067F64756E2164756E21
+//# debugId=E5629A67B36C6C4564756E2164756E21

package/dist/packager-tool-bg3tdpva.js

@@ -0,0 +1,27 @@
+import {
+  getAuthContext2
+} from "./packager-tool-dn9d4ywm.js";
+
+// ../solution-sdk/src/solution-auth.ts
+async function getSolutionAuthContext2(options) {
+  const ctx = await getAuthContext2({
+    tenant: options.tenant,
+    ensureTokenValidityMinutes: options.loginValidity ?? 10,
+    envFilePath: options.envFilePath,
+    requireOrganizationId: true,
+    requireTenantName: true
+  });
+  const { organizationId, tenantName } = ctx;
+  const basePath = `${ctx.baseUrl}/${encodeURIComponent(organizationId)}/${encodeURIComponent(tenantName)}/automationsolutions_`;
+  return {
+    accessToken: ctx.accessToken,
+    basePath,
+    organizationId,
+    tenantName,
+    identity: ctx.identity
+  };
+}
+
+export { getSolutionAuthContext2 };
+
+//# debugId=59B6698CEFEA9F4764756E2164756E21

package/dist/packager-tool-bpkkg4z2.js

@@ -0,0 +1,295 @@
+import {
+  catchError2,
+  logger
+} from "./packager-tool-psmb758n.js";
+import {
+  ConnectionsApi,
+  ElementsApi,
+  createApiClient,
+  isV4ActivityConfiguration,
+  getConnectorActivityMetadataV4
+} from "./packager-tool-4wn3b7qp.js";
+
+// ../maestro-sdk/src/registry/integration-service-fetcher.ts
+function parseContext(node) {
+  const context = node.model?.context;
+  if (!Array.isArray(context))
+    return null;
+  const connectorKey = context.find((c) => c.name === "connectorKey")?.value;
+  const objectName = context.find((c) => c.name === "objectName")?.value;
+  const method = context.find((c) => c.name === "method")?.value ?? "POST";
+  const operation = context.find((c) => c.name === "operation")?.value;
+  if (!connectorKey || !objectName)
+    return null;
+  return { connectorKey, objectName, method, operation };
+}
+function applyOptionalFieldProps(compact, field) {
+  if (field.enum?.length)
+    compact.enum = field.enum;
+  if (field.reference) {
+    compact.reference = {
+      objectName: field.reference.objectName,
+      lookupValue: field.reference.lookupValue,
+      lookupNames: field.reference.lookupNames,
+      path: field.reference.path,
+      childPath: field.reference.childPath,
+      scriptRef: field.reference.scriptRef
+    };
+  }
+}
+function extractFields(metadata, method, requestOnly) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => {
+    const methodInfo = field.method?.[method];
+    if (!methodInfo)
+      return false;
+    return requestOnly ? methodInfo.request === true || methodInfo.requestCurated === true : methodInfo.response === true || methodInfo.responseCurated === true;
+  }).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: requestOnly ? field.method?.[method]?.required === true : false,
+      description: field.description
+    };
+    if (!requestOnly)
+      compact.responseOnly = true;
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function isConnectorNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector") || false;
+}
+function isConnectorTriggerNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector.trigger") || false;
+}
+function toCompactField(field, required) {
+  const compact = {
+    name: field.name,
+    displayName: field.displayName,
+    type: field.type,
+    dataType: field.type,
+    required,
+    description: field.description
+  };
+  applyOptionalFieldProps(compact, field);
+  return compact;
+}
+function extractTriggerEventParameters(metadata, operationName) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => !!field.events?.[operationName]).map((field) => toCompactField(field, field.events?.[operationName]?.required === true));
+}
+function extractTriggerFilterFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => field.order === 1).map((field) => toCompactField(field, false));
+}
+function extractActivityFilterFields(metadata, _method) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => field.searchable === true).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: false,
+      description: field.description
+    };
+    if (field.searchableOperators?.length) {
+      compact.searchableOperators = [...field.searchableOperators];
+    }
+    if (field.searchableNames?.length) {
+      compact.searchableNames = [...field.searchableNames];
+    }
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function extractTriggerOutputFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.map((field) => {
+    const compact = toCompactField(field, false);
+    compact.responseOnly = true;
+    return compact;
+  });
+}
+async function fetchConnectorTriggerMetadata(connectorKey, operationName, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  const triggerMetadata = await api.getInstanceEventObjectMetadata({
+    connectionOrInstanceId: connectionId,
+    elementKey: connectorKey,
+    operationName,
+    objectName,
+    allFields: true
+  });
+  return triggerMetadata;
+}
+function getConfigurationString(node) {
+  const modelConfig = node.model?.configuration;
+  if (modelConfig)
+    return modelConfig;
+  const form = node.form;
+  for (const section of form?.sections ?? []) {
+    for (const field of section.fields ?? []) {
+      const config = field.componentProps?.connectorDetail?.configuration;
+      if (config)
+        return config;
+    }
+  }
+  return;
+}
+function getConnectorConfiguration(node) {
+  const configStr = getConfigurationString(node);
+  if (!configStr)
+    return null;
+  const [err, parsed] = catchError2(() => JSON.parse(configStr));
+  return err ? null : parsed;
+}
+class ConnectionConnectorMismatchError2 extends Error {
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "ConnectionConnectorMismatchError";
+  }
+}
+function assertConnectionConnector(connectionId, info, connectorKey, subject) {
+  if (!info.connectorKey || !connectorKey || info.connectorKey.toLowerCase() === connectorKey.toLowerCase()) {
+    return;
+  }
+  throw new ConnectionConnectorMismatchError2(`Connection "${connectionId}" is a ${info.connectorKey} connection, but ${subject} runs on ${connectorKey}.`, `Pass a ${connectorKey} connection: 'uip is connections list ${connectorKey} --all-folders'.`);
+}
+async function fetchConnectionInfo(connectionId) {
+  const api = await createApiClient(ConnectionsApi);
+  const response = await api.apiV1ConnectionsConnectionIdGet({
+    connectionId
+  });
+  const connector = response.connector;
+  return {
+    id: response.id ?? connectionId,
+    name: response.name ?? connectionId,
+    connectorKey: connector?.key ?? "",
+    connectorName: connector?.name ?? "",
+    connectorVersion: response.elementVersion ?? null,
+    pollingInterval: response.pollingIntervalInMinutes ?? null,
+    byoaConnection: response.byoaConnection === true,
+    elementInstanceId: response.elementInstanceId ?? null,
+    folderKey: response.folder?.key ?? null
+  };
+}
+async function fetchConnectorMetadata2(connectorKey, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  if (connectionId) {
+    const response = await api.getInstanceObjectMetadataRaw({
+      connectionOrInstanceId: connectionId,
+      elementKey: connectorKey,
+      objectName,
+      includeParentArray: true
+    });
+    return await response.raw.json();
+  }
+  const response = await api.getObjectMetadataRaw({
+    elementKey: connectorKey,
+    objectName,
+    includeParentArray: true
+  });
+  return await response.raw.json();
+}
+async function fetchConnectorActivityMetadataV4(connectorKey, objectName) {
+  return await getConnectorActivityMetadataV4(undefined, connectorKey, objectName);
+}
+function buildEnrichedActivityNode(node, metadata, method) {
+  const connectorMethodInfo = metadata?.metadata?.method?.[method];
+  const inputFields = extractFields(metadata, method, true);
+  const outputFields = extractFields(metadata, method, false);
+  const filterFields = extractActivityFilterFields(metadata, method);
+  return {
+    ...node,
+    ...connectorMethodInfo && { connectorMethodInfo },
+    inputDefinition: node.inputDefinition && Object.keys(node.inputDefinition).length > 0 ? node.inputDefinition : { fields: inputFields },
+    outputResponseDefinition: { fields: outputFields },
+    ...filterFields.length > 0 && {
+      filterFields: { fields: filterFields }
+    }
+  };
+}
+async function enrichConnectorActivityNode(node, connectionId) {
+  const parsed = parseContext(node);
+  const config = getConnectorConfiguration(node);
+  if (isV4ActivityConfiguration(config)) {
+    return enrichV4ConnectorActivityNode(node, connectionId, config);
+  }
+  if (!parsed)
+    return node;
+  const { connectorKey, objectName, method } = parsed;
+  const [error, metadata] = await catchError2(fetchConnectorMetadata2(connectorKey, objectName, connectionId));
+  if (error) {
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichV4ConnectorActivityNode(node, connectionId, config) {
+  const connectorKey = config?.connectorKey;
+  const objectName = config?.objectName;
+  const method = config?.httpMethod;
+  if (!connectorKey || !objectName || !method) {
+    logger.warn("v4 IS enrichment skipped: node configuration carries no connectorKey/objectName/httpMethod.");
+    return node;
+  }
+  if (connectionId) {
+    logger.warn("v4 metadata endpoints are not connection-scoped — --connection-id is ignored for 4.0.0 enrichment.");
+  }
+  const [error, metadata] = await catchError2(fetchConnectorActivityMetadataV4(connectorKey, objectName));
+  if (error) {
+    logger.warn(`IS v4 enrichment failed: ${error.message}`);
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichConnectorNode(node, connectionId) {
+  if (!isConnectorNode(node))
+    return node;
+  return isConnectorTriggerNode(node) ? enrichConnectorTriggerNode(node, connectionId) : enrichConnectorActivityNode(node, connectionId);
+}
+async function enrichConnectorTriggerNode(node, connectionId) {
+  if (!connectionId) {
+    throw new Error("Trigger nodes require --connection-id for IS enrichment. Provide it with --connection-id <id>.");
+  }
+  const parsed = parseContext(node);
+  if (!parsed?.operation)
+    return node;
+  const { connectorKey, objectName, operation } = parsed;
+  const metadata = await fetchConnectorTriggerMetadata(connectorKey, operation, objectName, connectionId);
+  const eventParameters = extractTriggerEventParameters(metadata, operation);
+  const filterFields = extractTriggerFilterFields(metadata);
+  const outputFields = extractTriggerOutputFields(metadata);
+  let byoaConnection = false;
+  let elementInstanceId = null;
+  if (connectionId) {
+    const [connErr, connInfo] = await catchError2(fetchConnectionInfo(connectionId));
+    if (!connErr) {
+      byoaConnection = connInfo.byoaConnection;
+      elementInstanceId = connInfo.elementInstanceId;
+    } else {
+      logger.warn(`Failed to fetch connection info for ${connectionId}: ${connErr.message}`);
+    }
+  }
+  return {
+    ...node,
+    eventMode: metadata.eventMode,
+    byoaConnection,
+    elementInstanceId,
+    eventParameters: { fields: eventParameters },
+    filterFields: { fields: filterFields },
+    outputResponseDefinition: { fields: outputFields }
+  };
+}
+
+export { extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, ConnectionConnectorMismatchError2, assertConnectionConnector, fetchConnectionInfo, fetchConnectorMetadata2, enrichConnectorNode };
+
+//# debugId=1F5E5EEBDAE1651764756E2164756E21