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

package/dist/trigger-enrichment-service-zdx4x92j.js

@@ -0,0 +1,340 @@
+import {
+  parseEntryConfiguration
+} from "./packager-tool-hrr0efqc.js";
+import"./packager-tool-134mvmcm.js";
+import"./packager-tool-rqvr63x5.js";
+import"./packager-tool-885mmrvr.js";
+import {
+  fetchConnectorConnections,
+  lookupTypeCacheEntry
+} from "./packager-tool-njzcfve1.js";
+import {
+  ConnectionOperationsApi,
+  ElementsApi,
+  assertActivityMetadataResolved,
+  createApiClient,
+  createConfiguredActivityClient
+} from "./packager-tool-mp59jtpm.js";
+import {
+  addVarIdsToInputsOutputs,
+  buildErrorOutput
+} from "./packager-tool-ajvse9r3.js";
+import"./packager-tool-s12392rd.js";
+import"./packager-tool-jhdf8gt1.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-37zvccmt.js";
+import {
+  createConnectorBindings
+} from "./packager-tool-0mj06yen.js";
+import"./packager-tool-j9rfdrdm.js";
+import"./packager-tool-r84ng21s.js";
+import"./packager-tool-9scn4b15.js";
+import"./packager-tool-3ze5vt52.js";
+import"./packager-tool-vepqrsse.js";
+import"./packager-tool-dqs5qy9s.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/trigger-enrichment-service.ts
+function buildTriggerBodyInput(params) {
+  const eventParams = params?.eventParams;
+  const filterExpression = params?.filterExpression;
+  const hasParams = eventParams !== undefined && Object.keys(eventParams).length > 0;
+  const body = {};
+  if (hasParams) {
+    body.filters = {
+      expression: filterExpression ?? ""
+    };
+    body.queryParams = { ...eventParams };
+    body.parameters = { ...eventParams };
+  }
+  return {
+    name: "body",
+    type: "json",
+    target: "body",
+    body
+  };
+}
+function buildTriggerOutputs(params) {
+  const outputs = [];
+  outputs.push({
+    name: "response",
+    displayName: params.displayName,
+    type: "jsonSchema",
+    source: "=response",
+    ...params.responseSchema ? { _jsonSchema: params.responseSchema } : {}
+  });
+  outputs.push(buildErrorOutput());
+  return outputs;
+}
+async function buildTriggerPropertyConfig(params) {
+  const { entry, config, uiPathActivityTypeId, connectionId, eventParams } = params;
+  const instanceParameters = {
+    ...parseEntryConfiguration(entry),
+    activityType: "CuratedWaitFor"
+  };
+  const triggerClient = await createConfiguredActivityClient({
+    instanceParameters,
+    connectionId,
+    savedFilterTrees: null,
+    fieldValues: eventParams ?? {}
+  });
+  const { essentialConfiguration } = triggerClient.getEssentialConfiguration();
+  assertActivityMetadataResolved(essentialConfiguration, connectionId);
+  return {
+    activityPropertyConfiguration: {
+      objectName: config.objectName ?? null,
+      eventType: config.eventOperation ?? null,
+      eventMode: config.eventMode ?? null,
+      configuration: `=jsonString:${JSON.stringify({ essentialConfiguration })}`,
+      uiPathActivityTypeId,
+      errorState: { issues: [] }
+    },
+    filterExpression: triggerClient.getCompiledFilter("filter")
+  };
+}
+function buildTriggerContext(params) {
+  const {
+    config,
+    entry,
+    connectionBindingId,
+    folderKeyBindingId,
+    connectionId,
+    connectorName,
+    inputMetadata,
+    primaryKeyName,
+    activityPropertyConfiguration
+  } = 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"
+    });
+  }
+  context.push({ name: "method", type: "string" });
+  context.push({ name: "path", type: "string" });
+  if (config.objectName) {
+    context.push({
+      name: "objectName",
+      value: config.objectName,
+      type: "string"
+    });
+  }
+  if (config.eventOperation) {
+    context.push({
+      name: "operation",
+      value: config.eventOperation,
+      type: "string"
+    });
+  }
+  const metadataBody = {
+    activityPropertyConfiguration: activityPropertyConfiguration ?? {},
+    activityMetadata: { activity: entry },
+    inputMetadata: inputMetadata ?? {},
+    telemetryData: {
+      connectorKey: config.connectorKey,
+      connectorName: connectorName ?? entry.displayName,
+      objectName: config.objectName ?? "",
+      objectDisplayName: config.objectName?.replaceAll("_", " ") ?? "",
+      primaryKeyName: primaryKeyName ?? ""
+    }
+  };
+  context.push({
+    name: "metadata",
+    type: "json",
+    body: metadataBody
+  });
+  return context;
+}
+async function fetchTriggerFieldInfo(connectorKey, objectName, eventOperation) {
+  const result = { allFields: {}, fieldDefinitions: {} };
+  if (!objectName || !eventOperation)
+    return result;
+  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+  if (apiError)
+    return result;
+  const [fetchError, objects] = await catchError(api.getObjects({ elementKey: connectorKey }));
+  if (fetchError || !Array.isArray(objects))
+    return result;
+  const match = objects.find((obj) => obj.name === objectName);
+  if (!match)
+    return result;
+  const metadata = match.metadata;
+  const eventTypes = metadata?.events?.polling?.eventTypes;
+  if (!Array.isArray(eventTypes))
+    return result;
+  const eventType = eventTypes.find((et) => et.operation === eventOperation);
+  if (!eventType?.parameters)
+    return result;
+  const allParams = [];
+  const bodyDefs = {};
+  for (const param of eventType.parameters) {
+    allParams.push(param.name);
+    bodyDefs[param.name] = {
+      name: param.name,
+      displayName: param.displayName ?? param.name,
+      type: param.type ?? "string",
+      required: !!param.required,
+      ...param.description && {
+        description: param.description
+      }
+    };
+  }
+  if (allParams.length > 0) {
+    result.allFields.body = allParams;
+  }
+  if (Object.keys(bodyDefs).length > 0) {
+    result.fieldDefinitions.body = bodyDefs;
+  }
+  return result;
+}
+async function fetchEventOutputFields(connectionId, operation, objectName) {
+  const [apiError, api] = await catchError(createApiClient(ConnectionOperationsApi));
+  if (apiError) {
+    logger.debug(`Failed to create ConnectionOperationsApi client: ${apiError.message}`);
+    return [];
+  }
+  const [fetchError, fields] = await catchError(api.apiV1ConnectionsConnectionIdOperationsOperationNameObjectsObjectNameEventFieldsGet({ connectionId, operationName: operation, objectName }));
+  if (fetchError || !Array.isArray(fields)) {
+    logger.debug(`Failed to fetch event fields for ${objectName}/${operation}: ${fetchError?.message ?? "unexpected response"}`);
+    return [];
+  }
+  return fields;
+}
+function buildEventOutputSchema(fields) {
+  if (fields.length === 0)
+    return;
+  const properties = {};
+  const definitions = {};
+  for (const field of fields) {
+    const name = field.name;
+    if (!name)
+      continue;
+    const type = field.type ?? "string";
+    const title = field.displayName ?? name;
+    const arrayMatch = name.match(/^([^[]+)\[\*\]\.(.+)$/);
+    if (arrayMatch) {
+      const [, arrayName, innerName] = arrayMatch;
+      const arrayKey = `${arrayName}[*]`;
+      if (!definitions[arrayKey]) {
+        definitions[arrayKey] = { type: "object", properties: {} };
+        properties[arrayKey] = {
+          title: arrayName,
+          type: "array",
+          items: { $ref: `#/definitions/${arrayKey}` }
+        };
+      }
+      definitions[arrayKey].properties[innerName] = { title, type };
+    } else {
+      properties[name] = { title, type };
+    }
+  }
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    ...Object.keys(definitions).length > 0 ? { definitions } : {}
+  };
+}
+async function enrichConnectorTrigger(triggerTypeId, connectionId, eventParams, indexType = "typecache-triggers") {
+  const { entry, config } = await lookupTypeCacheEntry(triggerTypeId, indexType);
+  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 hasEventParams = eventParams !== undefined && Object.keys(eventParams).length > 0;
+  const { activityPropertyConfiguration, filterExpression } = await buildTriggerPropertyConfig({
+    entry,
+    config,
+    uiPathActivityTypeId: triggerTypeId,
+    connectionId,
+    eventParams: hasEventParams ? eventParams : undefined
+  });
+  const inputs = [
+    buildTriggerBodyInput(hasEventParams ? {
+      eventParams,
+      filterExpression
+    } : undefined)
+  ];
+  let eventFields = [];
+  let responseSchema;
+  if (config.objectName && config.eventOperation) {
+    eventFields = await fetchEventOutputFields(connectionId, config.eventOperation, config.objectName);
+    responseSchema = buildEventOutputSchema(eventFields);
+  }
+  const outputs = buildTriggerOutputs({
+    responseSchema,
+    displayName: entry.displayName
+  });
+  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 = buildTriggerContext({
+    config,
+    entry,
+    connectionBindingId: connectionBinding.id,
+    folderKeyBindingId: folderKeyBinding?.id,
+    connectionId,
+    connectorName,
+    activityPropertyConfiguration
+  });
+  const { inputsWithVars, outputsWithVars } = addVarIdsToInputsOutputs({
+    inputs,
+    outputs
+  });
+  return {
+    entry,
+    config,
+    connectionId,
+    folderKey,
+    resolvedOperation: config.eventOperation,
+    context,
+    bindings,
+    inputs: inputsWithVars,
+    outputs: outputsWithVars
+  };
+}
+export {
+  buildEventOutputSchema,
+  buildTriggerBodyInput,
+  buildTriggerContext,
+  buildTriggerOutputs,
+  enrichConnectorTrigger,
+  fetchEventOutputFields,
+  fetchTriggerFieldInfo
+};
+
+//# debugId=0E16C74D39425D2D64756E2164756E21