@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-3mvr6njb.js

@@ -1,305 +0,0 @@
-import {
-  getFileSystem
-} from "./packager-tool-xdxr3ync.js";
-
-// ../flow-tool/src/services/inline-activity-service.ts
-import { randomUUID } from "node:crypto";
-var INLINE_ACTIVITY_TYPE_PREFIX = "uipath.connector.custom.";
-var INLINE_ACTIVITY_SOURCE = "inline";
-var INLINE_ACTIVITY_VERSION = "4.0.0";
-
-class InlineActivityError extends Error {
-  code = "InlineActivityInvalid";
-  instructions;
-  constructor(message, instructions) {
-    super(message);
-    this.name = "InlineActivityError";
-    this.instructions = instructions;
-  }
-}
-var asBag = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
-var text = (v) => typeof v === "string" ? v : "";
-function parseInlineActivityNodeType(nodeType) {
-  if (!nodeType.startsWith(INLINE_ACTIVITY_TYPE_PREFIX)) {
-    throw new InlineActivityError(`Node type "${nodeType}" is not a non-catalog activity type.`, `A non-catalog activity node type is "${INLINE_ACTIVITY_TYPE_PREFIX}<connector-key>.<activity-slug>", e.g. "${INLINE_ACTIVITY_TYPE_PREFIX}uipath-salesforce-slack.add-users-to-user-group".`);
-  }
-  const rest = nodeType.slice(INLINE_ACTIVITY_TYPE_PREFIX.length);
-  const dot = rest.indexOf(".");
-  const connectorKey = dot === -1 ? rest : rest.slice(0, dot);
-  const slug = dot === -1 ? "" : rest.slice(dot + 1);
-  if (!connectorKey || !slug) {
-    throw new InlineActivityError(`Node type "${nodeType}" is missing the connector key or the activity slug.`, `Use "${INLINE_ACTIVITY_TYPE_PREFIX}<connector-key>.<activity-slug>" — both parts are required.`);
-  }
-  return { connectorKey, slug };
-}
-async function readInlineActivityMetadata(metadataFile) {
-  const fs = getFileSystem();
-  const raw = await fs.readFile(metadataFile, "utf-8");
-  if (raw === null || raw === undefined) {
-    throw new InlineActivityError(`Activity metadata file not found: ${metadataFile}`, "Pass the <Name>.json that `uip is activities metadata generate` wrote.");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(String(raw));
-  } catch (err) {
-    throw new InlineActivityError(`Activity metadata is not valid JSON (${metadataFile}): ${err instanceof Error ? err.message : String(err)}`, "Regenerate it with `uip is activities metadata generate <min-file>` — never hand-edit generated metadata.");
-  }
-  return assertInlineActivityMetadata(parsed, metadataFile);
-}
-function assertInlineActivityMetadata(value, where) {
-  const m = asBag(value);
-  const problems = [];
-  for (const key of ["name", "elementKey", "path"]) {
-    if (!text(m[key])) {
-      problems.push(`missing top-level "${key}"`);
-    }
-  }
-  const slots = asBag(asBag(m.metadata).method);
-  const verbs = Object.keys(slots);
-  if (verbs.length !== 1) {
-    problems.push(`metadata.method must have exactly one verb slot (got ${verbs.length})`);
-  } else {
-    const slot = asBag(slots[verbs[0]]);
-    for (const key of ["operation", "method", "path", "scriptRef"]) {
-      if (!text(slot[key])) {
-        problems.push(`method ${verbs[0]}: missing "${key}"`);
-      }
-    }
-  }
-  if (problems.length > 0) {
-    throw new InlineActivityError(`Activity metadata is not a v4 activity (${where}):
-  - ${problems.join(`
-  - `)}`, "Regenerate it with `uip is activities metadata generate <min-file>`; this command reads the file that writes.");
-  }
-  return m;
-}
-function verbSlotOf(metadata) {
-  const verb = Object.keys(metadata.metadata.method)[0];
-  return { verb, slot: metadata.metadata.method[verb] };
-}
-function collectScriptRefs(metadata) {
-  const { slot } = verbSlotOf(metadata);
-  const lookups = [];
-  const add = (ref) => {
-    const r = text(ref);
-    if (r && r !== slot.scriptRef && !lookups.includes(r)) {
-      lookups.push(r);
-    }
-  };
-  for (const p of slot.parameters ?? []) {
-    add(asBag(p.reference).scriptRef);
-  }
-  for (const f of Object.values(metadata.fields ?? {})) {
-    add(asBag(asBag(f).reference).scriptRef);
-  }
-  return { main: slot.scriptRef, lookups };
-}
-async function readInlineScripts(scriptsDir, refs) {
-  const fs = getFileSystem();
-  const scripts = {};
-  const missing = [];
-  for (const ref of refs) {
-    const file = fs.path.join(scriptsDir, `${ref}.js`);
-    const source = await fs.readFile(file, "utf-8");
-    if (source === null || source === undefined) {
-      missing.push(file);
-      continue;
-    }
-    scripts[ref] = String(source);
-  }
-  if (missing.length > 0) {
-    throw new InlineActivityError(`Action script(s) not found:
-  - ${missing.join(`
-  - `)}`, "Every scriptRef in the metadata — the main action and each lookup reference — needs a <scriptRef>.js in --scripts. Generate the missing script, or fix the scriptRef in the min-file and regenerate.");
-  }
-  return scripts;
-}
-function buildInlineActivityDefinition(args) {
-  const { nodeType, connectorKey, metadata, activityTypeId } = args;
-  const { slot } = verbSlotOf(metadata);
-  const label = metadata.displayName ?? metadata.name;
-  const description = metadata.description ?? "";
-  const configuration = {
-    connectorKey,
-    objectName: metadata.name,
-    httpMethod: slot.method,
-    activityType: "Curated",
-    activitySource: INLINE_ACTIVITY_SOURCE,
-    version: INLINE_ACTIVITY_VERSION,
-    operation: slot.operation,
-    supportsStreaming: false,
-    subType: "standard"
-  };
-  const manifest = {
-    nodeType,
-    version: INLINE_ACTIVITY_VERSION,
-    category: `connector.${connectorKey}`,
-    tags: ["connector", "activity", INLINE_ACTIVITY_SOURCE],
-    sortOrder: 1,
-    supportsErrorHandling: true,
-    description,
-    display: {
-      label,
-      description,
-      sourceDisplayName: connectorKey
-    },
-    handleConfiguration: [
-      {
-        position: "left",
-        handles: [
-          {
-            id: "input",
-            type: "target",
-            handleType: "input",
-            label: ""
-          }
-        ]
-      },
-      {
-        position: "right",
-        handles: [
-          {
-            id: "output",
-            type: "source",
-            handleType: "output",
-            label: ""
-          }
-        ]
-      }
-    ],
-    model: {
-      type: "bpmn:SendTask",
-      serviceType: "Intsvc.ActivityExecution",
-      bindings: {
-        resource: "Connection",
-        resourceKey: "",
-        values: [
-          {
-            name: `${connectorKey} connection`,
-            propertyAttribute: "ConnectionId"
-          },
-          { name: "FolderKey", propertyAttribute: "FolderKey" }
-        ]
-      },
-      context: [
-        { name: "connectorKey", type: "string", value: connectorKey },
-        { name: "operation", type: "string", value: slot.operation },
-        { name: "objectName", type: "string", value: metadata.name },
-        { name: "method", type: "string", value: slot.method },
-        {
-          name: "connection",
-          type: "string",
-          value: `<bindings.${connectorKey} connection>`
-        },
-        {
-          name: "folderKey",
-          type: "string",
-          value: "<bindings.FolderKey>"
-        },
-        {
-          name: "activityConfigurationVersion",
-          type: "string",
-          value: "v1"
-        },
-        {
-          name: "metadata",
-          type: "json",
-          body: {
-            telemetryData: {
-              connectorKey,
-              connectorName: label
-            },
-            inputMetadata: {},
-            errorState: { hasError: true }
-          }
-        }
-      ]
-    },
-    form: {
-      id: "connector-properties",
-      title: "Connector configuration",
-      sections: [
-        {
-          id: "connector",
-          title: "Connector",
-          collapsible: true,
-          defaultExpanded: true,
-          fields: [
-            {
-              label: "",
-              name: "inputs.detail",
-              type: "custom",
-              component: "dap-config",
-              componentProps: {
-                connectorDetail: {
-                  uiPathActivityTypeId: activityTypeId,
-                  displayName: label,
-                  description,
-                  configuration: JSON.stringify(configuration)
-                }
-              }
-            }
-          ]
-        }
-      ]
-    },
-    inputDefinition: {},
-    inputDefaults: {},
-    outputDefinition: {
-      output: {
-        type: "object",
-        description: "The return value of the connector.",
-        source: "=result.response",
-        var: "output"
-      }
-    },
-    debug: { runtime: "bpmnEngine" }
-  };
-  return manifest;
-}
-async function prepareInlineActivity(nodeType, input) {
-  const { connectorKey } = parseInlineActivityNodeType(nodeType);
-  const metadata = await readInlineActivityMetadata(input.metadataFile);
-  if (metadata.elementKey !== connectorKey) {
-    throw new InlineActivityError(`Node type names connector "${connectorKey}" but the metadata was generated for "${metadata.elementKey}".`, `Use "${INLINE_ACTIVITY_TYPE_PREFIX}${metadata.elementKey}.<activity-slug>", or regenerate the metadata for "${connectorKey}".`);
-  }
-  const { main, lookups } = collectScriptRefs(metadata);
-  const scripts = await readInlineScripts(input.scriptsDir, [
-    main,
-    ...lookups
-  ]);
-  const manifest = buildInlineActivityDefinition({
-    nodeType,
-    connectorKey,
-    metadata,
-    activityTypeId: randomUUID()
-  });
-  return {
-    manifest,
-    connectorKey,
-    configuration: { metadata, scriptRef: main, scripts }
-  };
-}
-function getInlineActivityConfiguration(node) {
-  const raw = node.inputs?.inlineActivityConfiguration;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return;
-  }
-  return raw;
-}
-function definitionConfigurationOf(definition) {
-  const form = asBag(definition.form);
-  for (const section of form.sections ?? []) {
-    for (const field of asBag(section).fields ?? []) {
-      const detail = asBag(asBag(asBag(field).componentProps).connectorDetail);
-      if (typeof detail.configuration === "string") {
-        return detail.configuration;
-      }
-    }
-  }
-  return;
-}
-
-export { INLINE_ACTIVITY_TYPE_PREFIX, INLINE_ACTIVITY_SOURCE, InlineActivityError, collectScriptRefs, prepareInlineActivity, getInlineActivityConfiguration, definitionConfigurationOf };
-
-//# debugId=61C571D377AE582F64756E2164756E21

package/dist/packager-tool-521x949f.js

@@ -1,32 +0,0 @@
-import {
-  catchError
-} from "./packager-tool-z1qbc0qf.js";
-
-// ../case-tool/src/services/business-rule-outputs.ts
-var DECISION_KEYED_SCHEMA_KEY = "x-uipath-decision-keyed";
-function flattenDecisionKeyedSchema(output) {
-  const schema = typeof output === "string" ? catchError(() => JSON.parse(output))[1] : output;
-  if (!schema || typeof schema !== "object" || schema[DECISION_KEYED_SCHEMA_KEY] !== true) {
-    return output;
-  }
-  const { properties, definitions, $defs } = schema;
-  if (!properties || Object.keys(properties).length === 0) {
-    return output;
-  }
-  const columns = Object.create(null);
-  for (const decision of Object.values(properties)) {
-    for (const [name, column] of Object.entries(decision.properties ?? {})) {
-      columns[name] ??= column;
-    }
-  }
-  return {
-    type: "object",
-    properties: columns,
-    ...definitions ? { definitions } : {},
-    ...$defs ? { $defs } : {}
-  };
-}
-
-export { flattenDecisionKeyedSchema };
-
-//# debugId=1F9AB632F002C52464756E2164756E21