@uipath/case-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/packager-tool-ncedqc8m.js

@@ -0,0 +1,77 @@
+import {
+  ConnectorsApi,
+  createApiClient
+} from "./packager-tool-5ww9gbj3.js";
+import {
+  loadResourceIndex
+} from "./packager-tool-37ww3cn0.js";
+import {
+  TYPECACHE_PACKAGE_INDEX_TYPES
+} from "./packager-tool-r84ng21s.js";
+import {
+  catchError
+} from "./packager-tool-ygwa3sc0.js";
+
+// src/services/connector-lookup-service.ts
+async function lookupTypeCacheEntry(uiPathActivityTypeId, type) {
+  const types = typeof type === "string" ? [type] : type;
+  let entry;
+  let matchedType = types[0];
+  for (const candidate of types) {
+    const [loadError, entries] = await catchError(loadResourceIndex(candidate));
+    if (loadError) {
+      if (types.length === 1)
+        throw loadError;
+      continue;
+    }
+    const match = entries.find((e) => e.uiPathActivityTypeId === uiPathActivityTypeId);
+    if (match) {
+      entry = match;
+      matchedType = candidate;
+      break;
+    }
+  }
+  if (!entry) {
+    throw new Error(`No entry found in ${types.join(", ")} with uiPathActivityTypeId: ${uiPathActivityTypeId}`);
+  }
+  const [parseError, config] = catchError(() => JSON.parse(entry.configuration));
+  if (parseError) {
+    throw new Error(`Failed to parse configuration for "${entry.displayName}" in ${matchedType}: ${parseError.message}`);
+  }
+  if (!config.connectorKey) {
+    throw new Error(`Configuration for "${entry.displayName}" in ${matchedType} is missing connectorKey`);
+  }
+  return { entry, config, source: matchedType };
+}
+async function lookupConnectorDisplayName(packageId) {
+  if (typeof packageId !== "number")
+    return null;
+  for (const indexType of TYPECACHE_PACKAGE_INDEX_TYPES) {
+    const [err, packages] = await catchError(loadResourceIndex(indexType));
+    if (err)
+      continue;
+    const pkg = packages.find((p) => p.id === packageId);
+    if (pkg)
+      return pkg.displayName;
+  }
+  return null;
+}
+async function fetchConnectorConnections(connectorKey) {
+  const [apiError, api] = await catchError(createApiClient(ConnectorsApi));
+  if (apiError) {
+    throw new Error(`Failed to create Integration Service client: ${apiError.message}`);
+  }
+  const [fetchError, connections] = await catchError(api.apiV1ConnectorsKeyOrIdConnectionsGet({
+    keyOrId: connectorKey,
+    allFolders: true,
+    folderDefaults: true
+  }));
+  if (fetchError) {
+    throw new Error(`Failed to fetch connections for connector "${connectorKey}": ${fetchError.message}`);
+  }
+  return connections;
+}
+
+export { lookupTypeCacheEntry, lookupConnectorDisplayName, fetchConnectorConnections };
+
+//# debugId=FE5109F1FB6EA2FF64756E2164756E21

package/dist/packager-tool-p7jgrm5r.js

@@ -0,0 +1,15 @@
+import {
+  __require,
+  __toESM
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/case-schema-loader.ts
+var cached;
+function loadCaseSchemaAsync() {
+  cached ??= import("./index-k4xz16db.js").then((m)=>__toESM(m.default,1));
+  return cached;
+}
+
+export { loadCaseSchemaAsync };
+
+//# debugId=A9E9F3D03CB693EF64756E2164756E21

package/dist/packager-tool-q24fc6jm.js

@@ -0,0 +1,546 @@
+import {
+  fetchConnectorMetadata
+} from "./packager-tool-1j44c5z3.js";
+import {
+  fetchConnectorConnections,
+  lookupTypeCacheEntry
+} from "./packager-tool-ncedqc8m.js";
+import {
+  ElementsApi,
+  assertActivityMetadataResolved,
+  buildInputMetadata,
+  createApiClient,
+  createConfiguredActivityClient,
+  extractMultipartParameters
+} from "./packager-tool-5ww9gbj3.js";
+import {
+  addVarIdsToInputsOutputs,
+  buildErrorOutput
+} from "./packager-tool-13kkvf2n.js";
+import {
+  createConnectorBindings
+} from "./packager-tool-0mj06yen.js";
+import {
+  catchError
+} from "./packager-tool-ygwa3sc0.js";
+
+// src/services/connector-enrichment-service.ts
+function parseEntryConfiguration(entry) {
+  if (!entry.configuration)
+    return {};
+  try {
+    return JSON.parse(entry.configuration);
+  } catch {
+    return {};
+  }
+}
+async function fetchMetadataSafe(connectorKey, objectName, connectionId) {
+  const [err, result] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
+  return err ? undefined : result;
+}
+async function resolveActivityOperation(connectorKey, displayName, operation) {
+  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+  if (apiError) {
+    return operation;
+  }
+  const [fetchError, activities] = await catchError(api.getActivities({ elementKey: connectorKey }));
+  if (fetchError) {
+    return operation;
+  }
+  if (!Array.isArray(activities)) {
+    return operation;
+  }
+  const list = activities;
+  if (operation) {
+    const match2 = list.find((a) => a.operation === operation && !a.isTrigger);
+    if (match2) {
+      return match2.name;
+    }
+  }
+  const match = list.find((a) => a.displayName === displayName && !a.isTrigger);
+  if (match) {
+    return match.name;
+  }
+  return operation;
+}
+async function fetchObjectSwaggerPath(connectorKey, objectName) {
+  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+  if (apiError) {
+    return;
+  }
+  const [fetchError, swagger] = await catchError(api.getObjectSwagger({
+    elementKey: connectorKey,
+    objectName
+  }));
+  if (fetchError) {
+    return;
+  }
+  const [parseError, parsed] = catchError(() => typeof swagger === "string" ? JSON.parse(swagger) : swagger);
+  if (parseError || !parsed?.paths) {
+    return;
+  }
+  const pathKeys = Object.keys(parsed.paths).filter((k) => k.startsWith("/"));
+  return pathKeys[0];
+}
+async function fetchObjectMethodConfig(connectorKey, objectName, httpMethod) {
+  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+  if (apiError) {
+    return;
+  }
+  const [fetchError, objects] = await catchError(api.getObjects({ elementKey: connectorKey }));
+  if (fetchError) {
+    return;
+  }
+  if (!Array.isArray(objects)) {
+    return;
+  }
+  const match = objects.find((obj) => obj.name === objectName);
+  if (!match) {
+    return;
+  }
+  const metadata = match.metadata;
+  const method = httpMethod ?? "POST";
+  return metadata?.method?.[method];
+}
+async function buildActivityPropertyConfig(params) {
+  const { entry, uiPathActivityTypeId, connectionId } = params;
+  const instanceParameters = parseEntryConfiguration(entry);
+  const activityClient = await createConfiguredActivityClient({
+    instanceParameters,
+    connectionId
+  });
+  const { essentialConfiguration } = activityClient.getEssentialConfiguration();
+  assertActivityMetadataResolved(essentialConfiguration, connectionId);
+  const essentialConfig = { essentialConfiguration };
+  const multipartParams = extractMultipartParameters(params.objectMethodConfig?.parameters ?? []);
+  return {
+    ...multipartParams.length > 0 ? { multipartParameters: multipartParams } : {},
+    configuration: `=jsonString:${JSON.stringify(essentialConfig)}`,
+    uiPathActivityTypeId,
+    errorState: { issues: [] }
+  };
+}
+function buildInputMetadataFromParams(objectMethodConfig, resolvedOperation) {
+  const params = objectMethodConfig?.parameters ?? [];
+  const multipartParams = extractMultipartParameters(params);
+  return buildInputMetadata(multipartParams, resolvedOperation ?? "list") ?? undefined;
+}
+function extractFields(metadata) {
+  if (metadata.fields) {
+    return metadata.fields;
+  }
+  const extended = metadata;
+  if (extended.metadata?.fields) {
+    return extended.metadata.fields;
+  }
+  return;
+}
+function normalizeFields(raw) {
+  if (Array.isArray(raw)) {
+    return raw;
+  }
+  return Object.values(raw);
+}
+var UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function nestDottedKeys(flat) {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    const parts = key.split(".");
+    if (parts.some((p) => UNSAFE_KEYS.has(p)))
+      continue;
+    let current = result;
+    for (let i = 0;i < parts.length - 1; i++) {
+      if (!Object.hasOwn(current, parts[i]) || typeof current[parts[i]] !== "object" || current[parts[i]] === null) {
+        current[parts[i]] = {};
+      }
+      current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+function mapISFieldsToInputOutputs(metadata, httpMethod) {
+  const rawFields = extractFields(metadata);
+  if (!rawFields) {
+    return { inputs: [], outputs: [] };
+  }
+  const fields = normalizeFields(rawFields);
+  const method = httpMethod ?? "POST";
+  const requestFields = [];
+  const responseFields = [];
+  for (const field of fields) {
+    const methodConfig = field.method?.[method];
+    if (!methodConfig) {
+      continue;
+    }
+    if (methodConfig.request || methodConfig.requestCurated) {
+      requestFields.push(field);
+    }
+    if (methodConfig.response || methodConfig.responseCurated) {
+      responseFields.push(field);
+    }
+  }
+  const inputs = [];
+  if (requestFields.length > 0) {
+    inputs.push({
+      name: "body",
+      type: "json",
+      target: "body",
+      body: {}
+    });
+  }
+  const outputs = [];
+  if (responseFields.length > 0) {
+    const properties = {};
+    for (const f of responseFields) {
+      properties[f.name] = {
+        title: f.displayName,
+        type: f.type
+      };
+    }
+    outputs.push({
+      name: "response",
+      displayName: "Response",
+      type: "jsonSchema",
+      source: "=response",
+      _jsonSchema: {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties,
+        definitions: {}
+      }
+    });
+  }
+  outputs.push(buildErrorOutput());
+  return { inputs, outputs };
+}
+function buildParameterInputs(objectMethodConfig, activityPropertyConfig) {
+  const inputs = [];
+  inputs.push({
+    name: "pathParameters",
+    type: "json",
+    target: "pathParameters",
+    body: {}
+  });
+  if (objectMethodConfig) {
+    const parameters = objectMethodConfig.parameters;
+    if (Array.isArray(parameters) && parameters.length > 0) {
+      for (const param of parameters) {
+        if (param.type === "query") {
+          inputs.push({
+            name: "queryParameters",
+            type: "json",
+            target: "queryParameters",
+            body: {}
+          });
+          break;
+        }
+      }
+    }
+  }
+  if (activityPropertyConfig) {
+    const multipartParams = activityPropertyConfig.multipartParameters;
+    if (Array.isArray(multipartParams)) {
+      const hasFile = multipartParams.some((p) => p.dataType === "file");
+      if (hasFile) {
+        inputs.push({
+          name: "file",
+          type: "file",
+          target: "file"
+        });
+      }
+    }
+  }
+  return inputs;
+}
+function httpMethodToOperationType(method) {
+  switch (method?.toUpperCase()) {
+    case "GET":
+      return "read";
+    case "POST":
+      return "create";
+    case "PUT":
+      return "replace";
+    case "PATCH":
+      return "update";
+    case "DELETE":
+      return "delete";
+    default:
+      return "";
+  }
+}
+function buildConnectorContext(params) {
+  const {
+    config,
+    entry,
+    connectionBindingId,
+    folderKeyBindingId,
+    connectionId,
+    objectSwaggerPath,
+    connectorName,
+    activityPropertyConfig,
+    inputMetadata
+  } = params;
+  const context = [
+    {
+      name: "connectorKey",
+      value: config.connectorKey,
+      type: "string"
+    },
+    {
+      name: "connection",
+      value: `=bindings.${connectionBindingId}`,
+      type: "string"
+    },
+    {
+      name: "resourceKey",
+      value: connectionId,
+      type: "string"
+    }
+  ];
+  if (folderKeyBindingId) {
+    context.push({
+      name: "folderKey",
+      value: `=bindings.${folderKeyBindingId}`,
+      type: "string"
+    });
+  }
+  if (config.objectName) {
+    context.push({
+      name: "objectName",
+      value: config.objectName,
+      type: "string"
+    });
+  }
+  if (config.httpMethod) {
+    context.push({
+      name: "method",
+      value: config.httpMethod,
+      type: "string"
+    });
+  }
+  if (objectSwaggerPath) {
+    context.push({
+      name: "path",
+      value: objectSwaggerPath,
+      type: "string"
+    });
+  }
+  const metadataBody = {
+    activityPropertyConfiguration: activityPropertyConfig ?? {},
+    activityMetadata: { activity: entry },
+    inputMetadata: inputMetadata ?? {},
+    telemetryData: {
+      connectorKey: config.connectorKey,
+      connectorName: connectorName ?? entry.displayName,
+      operationType: httpMethodToOperationType(config.httpMethod),
+      objectName: config.objectName ?? "",
+      objectDisplayName: entry.displayName,
+      primaryKeyName: ""
+    }
+  };
+  context.push({
+    name: "metadata",
+    type: "json",
+    body: metadataBody
+  });
+  return context;
+}
+async function extractFieldDefinitions(connectorKey, objectName, httpMethod, prefetched) {
+  const result = {};
+  if (!objectName)
+    return result;
+  const method = httpMethod ?? "POST";
+  const [metadata, methodConfig] = prefetched ? [prefetched.metadata, prefetched.methodConfig] : await Promise.all([
+    fetchMetadataSafe(connectorKey, objectName),
+    fetchObjectMethodConfig(connectorKey, objectName, method)
+  ]);
+  if (metadata) {
+    const rawFields = extractFields(metadata);
+    if (rawFields) {
+      const fields = normalizeFields(rawFields);
+      const bodyDefs = {};
+      for (const field of fields) {
+        const mc = field.method?.[method];
+        if (!mc || !(mc.request || mc.requestCurated))
+          continue;
+        bodyDefs[field.name] = {
+          name: field.name,
+          displayName: field.displayName,
+          type: field.type,
+          required: mc.required ?? false,
+          ...field.description && {
+            description: field.description
+          },
+          ...field.enum?.length && { enum: field.enum },
+          ...field.reference && {
+            reference: {
+              objectName: field.reference.objectName,
+              lookupValue: field.reference.lookupValue
+            }
+          }
+        };
+      }
+      if (Object.keys(bodyDefs).length > 0) {
+        result.body = bodyDefs;
+      }
+    }
+  }
+  if (methodConfig) {
+    const parameters = methodConfig.parameters;
+    if (Array.isArray(parameters)) {
+      const pathDefs = {};
+      const queryDefs = {};
+      for (const param of parameters) {
+        const compact = {
+          name: param.name,
+          displayName: param.displayName ?? param.name,
+          type: param.dataType ?? "string",
+          required: !!param.required
+        };
+        if (param.type === "path") {
+          pathDefs[param.name] = compact;
+        } else if (param.type === "query") {
+          queryDefs[param.name] = compact;
+        }
+      }
+      if (Object.keys(pathDefs).length > 0) {
+        result.pathParameters = pathDefs;
+      }
+      if (Object.keys(queryDefs).length > 0) {
+        result.queryParameters = queryDefs;
+      }
+    }
+  }
+  return result;
+}
+async function enrichConnectorRegistryEntry(config, connectionId) {
+  if (!config.objectName || !config.httpMethod) {
+    return null;
+  }
+  const metadata = await fetchMetadataSafe(config.connectorKey, config.objectName, connectionId);
+  if (!metadata) {
+    return null;
+  }
+  const rawFields = extractFields(metadata);
+  if (!rawFields) {
+    return null;
+  }
+  const fields = normalizeFields(rawFields);
+  const method = config.httpMethod;
+  const inputFields = [];
+  const outputFields = [];
+  for (const field of fields) {
+    const methodInfo = field.method?.[method];
+    if (!methodInfo)
+      continue;
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      required: methodInfo.required ?? false,
+      ...field.description && { description: field.description },
+      ...field.enum?.length && { enum: field.enum },
+      ...field.reference && {
+        reference: {
+          objectName: field.reference.objectName,
+          lookupValue: field.reference.lookupValue
+        }
+      }
+    };
+    if (methodInfo.request || methodInfo.requestCurated) {
+      inputFields.push(compact);
+    }
+    if (methodInfo.response || methodInfo.responseCurated) {
+      outputFields.push({ ...compact, required: false });
+    }
+  }
+  return {
+    inputDefinition: { fields: inputFields },
+    outputDefinition: { fields: outputFields }
+  };
+}
+async function enrichConnectorActivity(activityTypeId, connectionId, indexType = "typecache-activities") {
+  const { entry, config } = await lookupTypeCacheEntry(activityTypeId, indexType);
+  const resolvedOperation = await resolveActivityOperation(config.connectorKey, entry.displayName, config.operation);
+  let inputs = [];
+  let outputs = [];
+  let objectSwaggerPath;
+  let inputMetadata;
+  let metadata;
+  let objectMethodConfig;
+  if (config.objectName) {
+    const [md, swaggerPath, mc] = await Promise.all([
+      fetchMetadataSafe(config.connectorKey, config.objectName),
+      fetchObjectSwaggerPath(config.connectorKey, config.objectName),
+      fetchObjectMethodConfig(config.connectorKey, config.objectName, config.httpMethod)
+    ]);
+    metadata = md ?? undefined;
+    objectMethodConfig = mc ?? undefined;
+    if (metadata) {
+      const io = mapISFieldsToInputOutputs(metadata, config.httpMethod);
+      inputs = io.inputs;
+      outputs = io.outputs;
+      inputMetadata = buildInputMetadataFromParams(objectMethodConfig, resolvedOperation ?? config.operation);
+    }
+    objectSwaggerPath = swaggerPath;
+  }
+  const activityPropertyConfig = await buildActivityPropertyConfig({
+    entry,
+    config,
+    uiPathActivityTypeId: activityTypeId,
+    connectionId,
+    objectSwaggerPath,
+    objectMethodConfig
+  });
+  if (config.objectName) {
+    inputs = [
+      ...inputs,
+      ...buildParameterInputs(objectMethodConfig, activityPropertyConfig)
+    ];
+  }
+  const connections = await fetchConnectorConnections(config.connectorKey);
+  const connection = connections.find((c) => c.id === connectionId);
+  if (!connection) {
+    throw new Error(`Connection "${connectionId}" not found for connector "${config.connectorKey}"`);
+  }
+  const folderKey = connection.folder?.key ?? undefined;
+  const connectorName = connection.connector?.name;
+  const [connectionBinding, folderKeyBinding] = createConnectorBindings(config.connectorKey, connectionId, folderKey);
+  const bindings = [connectionBinding];
+  if (folderKeyBinding) {
+    bindings.push(folderKeyBinding);
+  }
+  const context = buildConnectorContext({
+    config,
+    entry,
+    connectionBindingId: connectionBinding.id,
+    folderKeyBindingId: folderKeyBinding?.id,
+    connectionId,
+    objectSwaggerPath,
+    connectorName,
+    activityPropertyConfig,
+    inputMetadata
+  });
+  const { inputsWithVars, outputsWithVars } = addVarIdsToInputsOutputs({
+    inputs,
+    outputs
+  });
+  return {
+    entry,
+    config,
+    connectionId,
+    folderKey,
+    resolvedOperation,
+    context,
+    bindings,
+    inputs: inputsWithVars,
+    outputs: outputsWithVars,
+    _metadata: metadata,
+    _methodConfig: objectMethodConfig
+  };
+}
+
+export { parseEntryConfiguration, resolveActivityOperation, fetchObjectSwaggerPath, fetchObjectMethodConfig, extractFields, normalizeFields, UNSAFE_KEYS, nestDottedKeys, mapISFieldsToInputOutputs, buildParameterInputs, buildConnectorContext, extractFieldDefinitions, enrichConnectorRegistryEntry, enrichConnectorActivity };
+
+//# debugId=F2D3B4FF2B4063C064756E2164756E21

package/dist/packager-tool-r84ng21s.js

@@ -0,0 +1,57 @@
+// src/types/registry.ts
+var RESOURCE_TYPES = [
+  "agent",
+  "process",
+  "api",
+  "processOrchestration",
+  "caseManagement",
+  "flow",
+  "typecache-activities",
+  "typecache-triggers",
+  "typecache-packages",
+  "typecache-external-automation-activities",
+  "typecache-external-automation-triggers",
+  "typecache-external-automation-packages",
+  "typecache-external-agent-activities",
+  "typecache-external-agent-triggers",
+  "typecache-external-agent-packages",
+  "action-apps",
+  "solution"
+];
+var TYPECACHE_ACTIVITY_INDEX_TYPES = [
+  "typecache-activities",
+  "typecache-external-automation-activities",
+  "typecache-external-agent-activities"
+];
+var TYPECACHE_TRIGGER_INDEX_TYPES = [
+  "typecache-triggers",
+  "typecache-external-automation-triggers",
+  "typecache-external-agent-triggers"
+];
+var TYPECACHE_PACKAGE_INDEX_TYPES = [
+  "typecache-packages",
+  "typecache-external-automation-packages",
+  "typecache-external-agent-packages"
+];
+var TYPECACHE_INDEX_TYPES = [
+  ...TYPECACHE_ACTIVITY_INDEX_TYPES,
+  ...TYPECACHE_TRIGGER_INDEX_TYPES
+];
+var GET_SEARCHABLE_TYPES = [
+  { type: "agent", idField: "entityKey" },
+  { type: "process", idField: "entityKey" },
+  { type: "api", idField: "entityKey" },
+  { type: "processOrchestration", idField: "entityKey" },
+  { type: "caseManagement", idField: "entityKey" },
+  { type: "flow", idField: "entityKey" },
+  { type: "action-apps", idField: "id" },
+  ...TYPECACHE_INDEX_TYPES.map((type) => ({
+    type,
+    idField: "uiPathActivityTypeId"
+  })),
+  { type: "solution", idField: "key" }
+];
+
+export { RESOURCE_TYPES, TYPECACHE_ACTIVITY_INDEX_TYPES, TYPECACHE_TRIGGER_INDEX_TYPES, TYPECACHE_PACKAGE_INDEX_TYPES, TYPECACHE_INDEX_TYPES, GET_SEARCHABLE_TYPES };
+
+//# debugId=A7AD4F9C62720BB264756E2164756E21