@uipath/maestro-builder-sdk 6.70.8 → 6.71.0

package/dist/nodes/connector/flow/event-wait.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A mid-flow wait for an Integration Service event — `waitForEvent(subscription)`,
+ * a node type per event: `uipath.connector.event.<connectorKey>.<event>`. The
+ * type owns every name under `uipath.connector.event.` that names an event,
+ * nested inside the connector operations' `uipath.connector.` prefix, whose
+ * narrowing leaves it alone. Per-tenant: the definition is the library's event
+ * entry, and so is its version (`versionedByDefinition`).
+ *
+ * The same node type opens a flow as its start trigger (`onEvent`). That place
+ * stays the pipeline's until the triggers port: serialize places the trigger, and
+ * decompile reads a root `uipath.connector.event.*` node as one. This type is the
+ * node as a step, with an incoming edge.
+ *
+ * The subscription's emission — `inputs.detail`, the library's resolution, the
+ * refusals compile makes with and without a library — is shared with the trigger,
+ * so it stays in `core/event-subscription.ts` and is called here through
+ * `ctx.events`; the subscription's check rules stay in `core/event-checks.ts` and
+ * run through `ctx.eventSubscription`, with their codes.
+ *
+ * Moved from serialize.ts / check.ts / decompile.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+import type { ActionSpec } from '../../../core/actions.js';
+import type { FlowVersionedNodeType } from '../../../flow-node-type.js';
+export type EventWaitSpec = Extract<ActionSpec, {
+    kind: 'waitEvent';
+}>;
+/** `<connector>.<event>` after the prefix, split on the last dot; undefined for a name with no event. */
+export declare function splitEvent(typeName: string): {
+    connector: string;
+    event: string;
+} | undefined;
+export declare const eventWaitNodeType: FlowVersionedNodeType<EventWaitSpec>;

package/dist/nodes/connector/flow/event-wait.js

@@ -0,0 +1,162 @@
+import { missingBindingLabels } from '../../../core/binding-messages.js';
+import { prepareCommand } from '../../../core/cli-spelling.js';
+import { commentText } from '../../../core/comment-text.js';
+import { eventFilterFromTreeLeaf } from '../../../core/event-filters.js';
+import { eventDetail, eventTarget, libraryRequiredForEvent, refuseUnverifiedByoa, resolveEvent } from '../../../core/event-subscription.js';
+import { Expr } from '../../../core/expr.js';
+import { tsLiteral, tsObject, tsOptions } from '../../../core/ts-literal.js';
+const EVENT_PREFIX = 'uipath.connector.event.';
+/** `<connector>.<event>` after the prefix, split on the last dot; undefined for a name with no event. */
+export function splitEvent(typeName) {
+    if (!typeName.startsWith(EVENT_PREFIX))
+        return undefined;
+    const rest = typeName.slice(EVENT_PREFIX.length);
+    const dot = rest.lastIndexOf('.');
+    if (dot <= 0)
+        return undefined;
+    return { connector: rest.slice(0, dot), event: rest.slice(dot + 1) };
+}
+function serializeEventWait(spec, ctx) {
+    const sub = spec.subscription;
+    const site = `waitForEvent "${ctx.step}"`;
+    if (!ctx.library)
+        throw libraryRequiredForEvent(ctx.events, sub, ctx.nodeId, site, site);
+    const rc = resolveEvent(ctx.library, 'event', sub, site);
+    refuseUnverifiedByoa(ctx.events, site, sub);
+    const detail = eventDetail(rc, sub, ctx.nodeId, ctx.events, site);
+    // The platform reaches the connection through the flow's `bindings[]`, as for
+    // a connector operation (board G-19). `eventDetail` refused a node without
+    // both labels, so both resolve here.
+    const target = eventTarget(sub);
+    const connectionId = ctx.resolveBinding(sub.connection, 'connection', site, target);
+    const folderKey = ctx.resolveBinding(sub.folder, 'folder', site, target);
+    ctx.bindConnection({
+        model: rc.v1def?.model,
+        connectorKey: rc.connectorKey, connectionId: connectionId,
+        ...(folderKey !== undefined ? { folderKey } : {}),
+    });
+    // The node is the event the author named (`rc.nodeType`); a definition naming
+    // another is written under that name, so the node and its definitions[] entry agree.
+    const v1def = rc.v1def;
+    const def = v1def.nodeType === rc.nodeType ? v1def : { ...v1def, nodeType: rc.nodeType };
+    return {
+        definition: { source: 'snapshot', nodeType: def.nodeType, version: def.version, manifest: def },
+        inputs: { detail },
+        // A wait continues on `output`, as every connector node does.
+        port: 'output',
+    };
+}
+/** A `where` value as decompile reads it: an expression back to an `Expr`, wire text as text, any other JSON as is. */
+function liftValue(v, ctx) {
+    const raw = Array.isArray(v) ? undefined : ctx.sourceText(v);
+    if (raw === undefined)
+        return v;
+    return raw.startsWith('=js:') ? new Expr(raw.slice(4)) : raw;
+}
+/**
+ * The subscription back from the node: the `where` scope from
+ * `detail.eventParameters`, which carries it verbatim, and the filters from the
+ * filter tree inside `detail.configuration`. Both are also encoded into the
+ * generated `filterExpression`, but reading the structured copies avoids parsing
+ * a string compile generated.
+ */
+function liftEventWait(node, ctx) {
+    const n = node;
+    const split = splitEvent(n.type);
+    if (!split)
+        return undefined;
+    const detail = (n.inputs?.detail ?? undefined);
+    const where = Object.entries((detail?.eventParameters ?? {}))
+        .filter(([, v]) => v !== undefined && v !== null && String(v) !== '')
+        .map(([k, v]) => [k, liftValue(v, ctx)]);
+    // The filter tree lives inside the `=jsonString:` configuration blob, and so
+    // does the one fact that says whether `detail.objectName` was the AUTHOR's
+    // choice: a GENERIC event (`activityType: GenericTrigger`) carries the object
+    // the author named, a curated one carries its built-in object.
+    let filters = [];
+    let generic = false;
+    const config = detail?.configuration;
+    if (typeof config === 'string' && config.startsWith('=jsonString:')) {
+        try {
+            const parsed = JSON.parse(config.slice('=jsonString:'.length));
+            generic = parsed?.essentialConfiguration?.instanceParameters?.activityType === 'GenericTrigger';
+            const rows = (parsed?.essentialConfiguration?.filter?.filters ?? []);
+            filters = rows
+                .map((f) => eventFilterFromTreeLeaf(f))
+                .filter((f) => f !== undefined);
+        }
+        catch {
+            // A hand-edited blob is not ours to guess at — the scope and identity
+            // still recover, and the filters simply do not come back.
+            filters = [];
+        }
+    }
+    const object = generic && typeof detail?.objectName === 'string' && detail.objectName !== ''
+        ? detail.objectName
+        : undefined;
+    const connection = typeof detail?.connectionId === 'string' ? detail.connectionId : undefined;
+    const folder = typeof detail?.connectionFolderKey === 'string' ? detail.connectionFolderKey : undefined;
+    // A connection the file never picked (`connectionId: null`): the source cannot
+    // invent labels for it, and compile and check refuse a node without both
+    // (BINDING_MISSING, flow-builder-sdk#890), so the source says so at the node
+    // and the run warns once.
+    const missing = missingBindingLabels({ connection, folder });
+    if (missing.length > 0) {
+        ctx.warn(`node ${tsLiteral(n.id)} (${n.type}) has no ${missing.join(' or ')} in the .flow (an unbound draft). `
+            + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out, and compile and check refuse it (BINDING_MISSING) `
+            + `until it names both labels: run \`${prepareCommand(split.connector, split.event)}\`, then pass `
+            + `\`connection\` and \`folder\`.`);
+    }
+    return { kind: 'waitEvent', ...split, where, object, filters, connection, folder, missing };
+}
+/**
+ * `waitForEvent({ … })`, the stringly form: the subscription as one object. The
+ * unbound marker sits inside the call, after the object, where the lift has
+ * always put it.
+ */
+function printEventWait(l, ctx) {
+    const value = (v) => (v instanceof Expr ? ctx.value(v) : ctx.json(v));
+    const filters = l.filters.map((f) => tsOptions([
+        ['field', tsLiteral(f.field)],
+        [f.operator, typeof f.value === 'string' ? tsLiteral(f.value) : JSON.stringify(f.value)],
+    ]));
+    const subscription = tsOptions([
+        ['connector', tsLiteral(l.connector)],
+        ['event', tsLiteral(l.event)],
+        ['where', l.where.length ? tsObject(l.where.map(([k, v]) => [k, value(v)])) : undefined],
+        ['object', l.object !== undefined ? tsLiteral(l.object) : undefined],
+        ['filters', filters.length ? `[${filters.join(', ')}]` : undefined],
+        ['connection', l.connection !== undefined ? tsLiteral(l.connection) : undefined],
+        ['folder', l.folder !== undefined ? tsLiteral(l.folder) : undefined],
+    ]);
+    const marker = l.missing.length > 0
+        ? ` /* TODO: bind ${commentText(l.missing.join(' and '))}; check refuses this node until it has both labels (BINDING_MISSING) */`
+        : '';
+    return { factory: 'waitForEvent', positional: [subscription + marker] };
+}
+const eventWait10 = {
+    kind: 'waitEvent', typeName: `${EVENT_PREFIX}*`, version: '1.0.0', factory: 'waitForEvent',
+    definition: 'per-tenant',
+    // An event wait resumes or it does not: it has no error port to route.
+    errorPort: false,
+    serialize: (spec, ctx) => serializeEventWait(spec, ctx),
+    deserialize: (node, ctx) => liftEventWait(node, ctx),
+    print: (spec, ctx) => printEventWait(spec, ctx),
+    check: (spec, ctx) => ctx.eventSubscription(spec.subscription, `waitForEvent "${ctx.step}"`),
+    namedNode: (spec) => {
+        const sub = spec.subscription;
+        return {
+            typeName: `${EVENT_PREFIX}${sub?.connector}.${sub?.event}`,
+            ...(typeof sub?.version === 'string' ? { version: sub.version } : {}),
+        };
+    },
+    expressions: () => [],
+    output: () => ({ kind: 'opaque' }),
+};
+export const eventWaitNodeType = {
+    kind: 'waitEvent', typeName: `${EVENT_PREFIX}*`, typeNamePrefix: EVENT_PREFIX, factory: 'waitForEvent',
+    typeNameMatches: (typeName) => splitEvent(typeName) !== undefined,
+    versionedByDefinition: true,
+    defaultVersion: eventWait10.version,
+    versions: { [eventWait10.version]: eventWait10 },
+};

package/dist/nodes/connector/flow/family.d.ts

@@ -1,3 +1,3 @@
-/** The connector node family, as flow-node-registry.ts lists it: an Integration Service connector operation. */
+/** The connector node family, as flow-node-registry.ts lists it: an Integration Service connector operation, and a mid-flow event wait. */
 import type { FlowNodeFamily } from '../../../flow-node-type.js';
 export declare const connectorFlowFamily: FlowNodeFamily;

package/dist/nodes/connector/flow/family.js

@@ -1,8 +1,9 @@
+import { eventWaitNodeType } from './event-wait.js';
 import { connectorNodeType } from './node-type.js';
 export const connectorFlowFamily = {
     id: 'connector',
     title: 'Integration Service connector',
-    types: [connectorNodeType],
-    // Its rules' codes are the pipeline's, shared with an event subscription (ctx.connector).
+    types: [connectorNodeType, eventWaitNodeType],
+    // Its rules' codes are the pipeline's, shared with the triggers (ctx.connector, ctx.eventSubscription).
     diagnostics: {},
 };