@uipath/maestro-builder-sdk 6.4.0 → 6.5.1

package/dist/registry/library-build/enrich.js

@@ -0,0 +1,158 @@
+/**
+ * `is resources describe` enrichment: the second pass over every canonical
+ * entry.
+ *
+ * `flow registry get` (without `--connection-id`) returns a sparse view: many
+ * connectors come back with empty definitions and no `connectorMethodInfo`.
+ * `is resources describe <connector> <object> --operation <op>` returns the
+ * same data plus path placeholders, the path/query parameter split and full
+ * request/response field schemas — without a connection for every
+ * schema-static connector.
+ *
+ * Split in two here: {@link applyDescribe} is the pure merge of one describe
+ * payload into one entry, {@link enrichEntry} is the fetch plan around it
+ * (registry verb first, then the alternate the object itself advertises).
+ */
+import { mapConcurrent } from "../concurrency.js";
+import { messageOf } from "../errors.js";
+import { normalizeFieldKeys, pick } from "./canonical.js";
+import { isDescribeObject, isDescribeOperation } from "./context.js";
+import { get, item, pyEquals, pyIter, pyOr, truthy } from "./py.js";
+/**
+ * Registry `httpMethod` (e.g. `GETBYID`) → a guess at the `is resources`
+ * operation name, for an entry whose canonical `operation.name` is empty.
+ */
+export const HTTP_METHOD_TO_OPERATION = new Map([
+    ["GET", "List"],
+    ["GETBYID", "Retrieve"],
+    ["POST", "Create"],
+    ["PATCH", "Update"],
+    ["PUT", "Replace"],
+    ["DELETE", "Delete"],
+]);
+/**
+ * `discover_operation_name`: the `is resources` operation whose HTTP method
+ * matches the entry's, from the object's `AvailableOperations`; `null` when
+ * the object cannot be described or nothing matches.
+ */
+export async function discoverOperationName(ctx, entry) {
+    const operation = item(entry, "operation");
+    const connectorKey = item(item(entry, "connector"), "key");
+    const objectName = item(operation, "objectName");
+    const httpMethod = item(operation, "httpMethod");
+    if (!truthy(connectorKey) || !truthy(objectName))
+        return null;
+    const objData = await isDescribeObject(ctx, connectorKey, objectName);
+    if (!truthy(objData))
+        return null;
+    for (const op of pyIter(pyOr(pick(objData, "AvailableOperations", "availableOperations"), []))) {
+        if (pyEquals(pick(op, "Method", "method"), httpMethod))
+            return pick(op, "Name", "name");
+    }
+    return null;
+}
+/**
+ * The pure half of `enrich_entry`: merge one describe `Data` payload into the
+ * entry, in place. `operation.name` is filled only when the registry left it
+ * empty; `pathTemplate`, `parameters` and the two schemas come from the
+ * payload; `objectDisplayName` and `display.operationLabel` fill gaps only.
+ */
+export function applyDescribe(entry, data) {
+    const e = entry;
+    const operation = item(e, "operation");
+    const display = item(e, "display");
+    const opData = pyOr(pick(data, "Operation", "operation"), {});
+    // If the name was discovered via fallback, persist it now.
+    const opResolvedName = pick(opData, "Name", "name");
+    if (!truthy(item(operation, "name")) && truthy(opResolvedName))
+        operation.name = opResolvedName;
+    // Path with placeholders (supersedes the simple `path`).
+    const opPath = pick(opData, "Path", "path");
+    if (truthy(opPath))
+        operation.pathTemplate = opPath;
+    if (!truthy(get(operation, "objectDisplayName"))) {
+        const displayName = pick(data, "DisplayName", "displayName");
+        if (truthy(displayName))
+            operation.objectDisplayName = displayName;
+    }
+    const opCurated = pick(opData, "Curated", "curated");
+    if (truthy(opCurated) && !truthy(get(display, "operationLabel")))
+        display.operationLabel = opCurated;
+    // Parameters (path / query) — raw shape, camelCase keys.
+    const params = pyOr(pick(data, "Parameters", "parameters"), []);
+    if (truthy(params))
+        operation.parameters = normalizeFieldKeys(params);
+    // Do not infer schema discovery from empty field lists: delete and file
+    // operations legitimately expose neither. Connector metadata owns that flag.
+    const requestFields = pyOr(pick(data, "RequestFields", "requestFields"), []);
+    const responseFields = pyOr(pick(data, "ResponseFields", "responseFields"), []);
+    if (truthy(requestFields))
+        e.inputSchema = { fields: normalizeFieldKeys(requestFields) };
+    if (truthy(responseFields))
+        e.outputSchema = { fields: normalizeFieldKeys(responseFields) };
+    return entry;
+}
+/**
+ * `enrich_entry`: augment a canonical entry with `is resources describe` data.
+ * On any failure the entry is returned as it was, so the pipeline degrades
+ * gracefully.
+ *
+ * The registry's verb and the IS CLI's can DISAGREE for the same operation
+ * (Data Service `QueryEntityRecordsCurated`: registry `List`, CLI `Create`).
+ * When the registry's name does not resolve, the OBJECT is asked which
+ * operations it has and the one whose HTTP method matches is retried.
+ * `operation.name` deliberately keeps the REGISTRY's verb even then — it maps
+ * to a CRUD verb the offline fixtures are synthesised from; the discovered
+ * name is only for reaching the schema.
+ */
+export async function enrichEntry(ctx, entry) {
+    const operation = item(entry, "operation");
+    const connectorKey = item(item(entry, "connector"), "key");
+    const objectName = item(operation, "objectName");
+    let opName = item(operation, "name");
+    // Fallback: no operation name from the registry — discover via httpMethod.
+    if (!truthy(opName)) {
+        opName = pyOr(await discoverOperationName(ctx, entry), HTTP_METHOD_TO_OPERATION.get(item(operation, "httpMethod")) ?? null);
+    }
+    if (!truthy(opName))
+        return entry; // nothing to do
+    let data = await isDescribeOperation(ctx, connectorKey, objectName, opName);
+    if (!truthy(data)) {
+        const alt = await discoverOperationName(ctx, entry);
+        if (truthy(alt) && alt !== opName)
+            data = await isDescribeOperation(ctx, connectorKey, objectName, alt);
+    }
+    if (!truthy(data))
+        return entry; // connector might be a stub or recently removed
+    return applyDescribe(entry, data);
+}
+/** `enrich_all`: `enrichEntry` over every entry, results in input order. */
+export async function enrichAll(ctx, entries) {
+    let done = 0;
+    const enriched = await mapConcurrent(entries, ctx.concurrency, async (e, i) => {
+        let out;
+        try {
+            out = await enrichEntry(ctx, e);
+        }
+        catch (exc) {
+            // Non-fatal — keep the un-enriched entry.
+            out = entries[i];
+            ctx.reporter.warn(`  WARN: enrichment failed for ${item(entries[i], "nodeType")}: ${messageOf(exc)}`);
+        }
+        done += 1;
+        if (done % 100 === 0 || done === entries.length)
+            ctx.reporter.info(`  Enriched ${done}/${entries.length}`);
+        return out;
+    });
+    let pathTemplateAdded = 0;
+    let schemaAdded = 0;
+    for (const e of enriched) {
+        if (truthy(get(get(e, "operation", {}), "pathTemplate")))
+            pathTemplateAdded += 1;
+        if (truthy(get(get(e, "inputSchema", {}), "fields")) || truthy(get(get(e, "outputSchema", {}), "fields")))
+            schemaAdded += 1;
+    }
+    ctx.reporter.info(`  pathTemplate added on ${pathTemplateAdded}/${entries.length}`);
+    ctx.reporter.info(`  schema added/augmented on ${schemaAdded}/${entries.length}`);
+    return enriched;
+}

package/dist/registry/library-build/events.d.ts

@@ -0,0 +1,108 @@
+import { Refusal } from "../errors.js";
+import type { LibraryEntry } from "../model/library.js";
+import type { UipClient } from "../uip/client.js";
+import { type BuildContext } from "./context.js";
+import { type Dict } from "./py.js";
+/** A trigger metadata call failed, with the reason and the way forward. */
+export declare class EventDiscoveryError extends Refusal {
+    /**
+     * True when the call was never made — the client refused it (`--offline`).
+     * Such a failure is not an answer from the tenant and must not be cached
+     * as one; see {@link triggersObjectsCached}.
+     */
+    readonly refused: boolean;
+    constructor(message: string, 
+    /**
+     * True when the call was never made — the client refused it (`--offline`).
+     * Such a failure is not an answer from the tenant and must not be cached
+     * as one; see {@link triggersObjectsCached}.
+     */
+    refused?: boolean);
+}
+/**
+ * `triggers_objects`: the event objects for `(connector, operation)`, PascalCase
+ * rows. `connectionId` is optional; a connector whose objects do not come from
+ * the connection answers identically either way.
+ */
+export declare function triggersObjects(client: UipClient, key: string, operation: string, connectionId?: string, timeoutMs?: number): Promise<unknown[]>;
+/** `triggers_describe`: `EventParameters` / `FilterFields` / `OutputFields` for one object. */
+export declare function triggersDescribe(client: UipClient, key: string, operation: string, objectName: string, connectionId?: string, timeoutMs?: number): Promise<Dict>;
+/** `_camelize`: lower-case the first letter of every key, recursively. */
+export declare function camelize(value: unknown): unknown;
+/** `_is_hidden`: a hidden parameter that is safe to DROP — hidden and optional. */
+export declare function isHidden(low: Dict): boolean;
+/** `_keep_hidden_marker`: flag a kept parameter the designer hides (necessarily a required one). */
+export declare function keepHiddenMarker(low: Dict, field: Dict): Dict;
+/**
+ * `_with_cascade`: mark each parameter that another one has to resolve before
+ * it, then order by the designer's `sortOrder` (unset last), stably.
+ */
+export declare function withCascade(fields: Dict[]): Dict[];
+/** `camel_fields`: describe/objects fields normalized to the registry's camelCase shape. */
+export declare function camelFields(fields: unknown): Dict[];
+/** `normalize_bucket_fields`: `triggers objects → Parameters[]` rows, camelCase, bucket made explicit. */
+export declare function normalizeBucketFields(parameters: unknown): Dict[];
+/**
+ * `union_event_parameters`: describe's EventParameters ∪ the object row's
+ * Parameters, deduped by name; `required` is an OR; the object row's bucket
+ * survives the merge.
+ */
+export declare function unionEventParameters(declared: unknown, objectParameters: unknown): Dict[];
+/** `merge_describe_into_node`: fold a `triggers describe` answer into a registry trigger definition (a copy). */
+export declare function mergeDescribeIntoNode(node: Dict, describe: Dict, objectParameters?: unknown): Dict;
+export interface EventFacts {
+    eventMode: string;
+    byoaConnection: boolean;
+    isWebhookUrlVisible: boolean;
+    textBlocks: string[];
+}
+/** `event_facts`: the three facts that change how a subscription is prepared or tested; the object row wins. */
+export declare function eventFacts(node: Dict, objectRow: unknown): EventFacts;
+/**
+ * `triggers_objects_cached`: cached `uip is triggers objects <key> <OPERATION>`,
+ * called WITHOUT a connection on purpose. A failure is reported and cached as
+ * an empty catalog — a REAL failure, that is. The Python had no offline mode,
+ * so every failure it cached was the tenant's answer. Under `--offline` the
+ * client refuses the call instead; caching that as `{objects: []}` would make
+ * the next ONLINE build over the same `--keep-temp` caches see an empty event
+ * catalogue and expand nothing, silently. So a refusal is reported and used,
+ * but never written down. (The four describe/list helpers in `context.ts` now
+ * apply the same rule explicitly. They used to rest on an accident — a
+ * refusal's empty stdout is not JSON, so they returned before their cache
+ * write — which held only for as long as the offline client wrote nothing to
+ * stdout. That is precisely the accident this flag replaced, so they check the
+ * flag instead.)
+ */
+export declare function triggersObjectsCached(ctx: BuildContext, key: string, operation: string): Promise<unknown[]>;
+/**
+ * `triggers_describe_cached`: cached `uip is triggers describe <key> <OPERATION> <object>`.
+ * A refused call is not cached, for the reason given on {@link triggersObjectsCached}.
+ */
+export declare function triggersDescribeCached(ctx: BuildContext, key: string, operation: string, objectName: string): Promise<Dict>;
+/**
+ * `_apply_event_schema`: put an event's OWN schema on the entry, replacing the
+ * node manifest's. `inputSchema` becomes the union rule's answer; `eventSchema`
+ * is appended to the entry and later stamped onto the sidecar.
+ */
+export declare function applyEventSchema(entry: LibraryEntry, describe: unknown, obj: unknown): LibraryEntry;
+/** `_describe_curated_events`: give each CURATED event its own schema, in place. */
+export declare function describeCuratedEvents(ctx: BuildContext, entries: LibraryEntry[]): Promise<void>;
+/**
+ * `_make_expanded_event_entry`: one per-object variant of a generic connector
+ * EVENT. The variant keeps `activityType: GenericTrigger` and the template's
+ * nodeType deliberately; the object rides on `operation.objectName`.
+ */
+export declare function makeExpandedEventEntry(template: LibraryEntry, obj: unknown, describe: unknown): LibraryEntry;
+/**
+ * `_expand_generic_events`: expand each generic EVENT template into one entry
+ * per event object. Variants come back in template × object order (the Python
+ * appended them as the describes completed); `build` sorts them before
+ * planning.
+ */
+export declare function expandGenericEvents(ctx: BuildContext, templates: LibraryEntry[]): Promise<LibraryEntry[]>;
+/**
+ * `resolve_connector_events`: give every connector EVENT its real schema;
+ * expand the expandable ones. Returns `[entries, expanded]` — `entries` is the
+ * input with curated events described in place.
+ */
+export declare function resolveConnectorEvents(ctx: BuildContext, entries: LibraryEntry[]): Promise<[LibraryEntry[], LibraryEntry[]]>;