@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/{packager-tool-wvqz81mx.js → packager-tool-gtzs471w.js}

@@ -277,7 +277,8 @@ class ToolsFactoryRepository {
   getProjectToolFactory(projectType) {
     const factory = this.projectFactoryMap.get(projectType);
     if (!factory) {
-      throw new Error(`No tool factory found for project type '${projectType}'`);
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
     }
     return factory;
   }
@@ -1117,4 +1118,4 @@ I18nManager.registerTranslations("zu", zu);
 I18nManager.setLocale("en");
 export { ensureProjectId, NugetPackager, toolsFactoryRepository };
 
-//# debugId=B8BE39020582C5AB64756E2164756E21
+//# debugId=EA96C0A2D58145DE64756E2164756E21

package/dist/packager-tool-hrr0efqc.js

@@ -0,0 +1,546 @@
+import {
+  fetchConnectorMetadata
+} from "./packager-tool-rqvr63x5.js";
+import {
+  fetchConnectorConnections,
+  lookupTypeCacheEntry
+} from "./packager-tool-njzcfve1.js";
+import {
+  ElementsApi,
+  assertActivityMetadataResolved,
+  buildInputMetadata,
+  createApiClient,
+  createConfiguredActivityClient,
+  extractMultipartParameters
+} from "./packager-tool-mp59jtpm.js";
+import {
+  addVarIdsToInputsOutputs,
+  buildErrorOutput
+} from "./packager-tool-ajvse9r3.js";
+import {
+  createConnectorBindings
+} from "./packager-tool-0mj06yen.js";
+import {
+  catchError
+} from "./packager-tool-5ax2ywcg.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