@uipath/maestro-builder-sdk 6.70.9 → 6.71.1

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: {},
 };

package/dist/nodes/process/flow/check.js

@@ -33,6 +33,9 @@ export const PROCESS_DIAGNOSTICS = {
     AGENTIC_RESERVED_INPUT: { severity: 'error', summary: 'an agentic process step with the reserved fireAndForget input' },
     APIWF_EMPTY_RETURNS: { severity: 'warning', summary: 'an API workflow step with returns: {}' },
     APIWF_KEY_NOT_KEY: { severity: 'error', summary: 'an API workflow step whose key is not a GUID' },
+    APIWF_LOCAL_HAS_FOLDER: { severity: 'error', summary: 'an API workflow step in-solution, with a folderPath' },
+    APIWF_LOCAL_NO_PROJECT_ID: { severity: 'error', summary: 'an API workflow step in-solution, with no projectId' },
+    APIWF_LOCAL_PROJECT_ID_NOT_GUID: { severity: 'error', summary: 'an API workflow step in-solution, with a projectId that is not a GUID' },
     APIWF_NAME_IS_PATH: { severity: 'error', summary: 'an API workflow step whose name looks like a folder path' },
     APIWF_NO_FOLDER: { severity: 'error', summary: 'an API workflow step with no folderPath' },
     APIWF_NO_KEY: { severity: 'error', summary: 'an API workflow step with no key' },
@@ -157,10 +160,21 @@ export function checkApiWorkflow(inputs, ctx) {
         at('APIWF_NO_NAME', `API workflow step "${step}" has no \`name\`. The runtime starts the job by name + folder, not by the `
             + `key in the node type, so without it the workflow cannot be resolved and the run fails before dispatch.`, `name: 'NameToAgeFixed'`);
     }
-    if (blank(inputs?.folderPath)) {
+    const inSolution = inputs?.location === 'in-solution';
+    if (!inSolution && blank(inputs?.folderPath)) {
         at('APIWF_NO_FOLDER', `API workflow step "${step}" has no \`folderPath\`. The runtime starts the job by name + folder, so the `
-            + `Orchestrator folder holding the workflow is required.`, `folderPath: 'Shared'`);
+            + `Orchestrator folder holding the workflow is required. For an API workflow in the SAME solution, set `
+            + `\`location: 'in-solution'\` and its \`projectId\` instead.`, `folderPath: 'Shared'`);
+    }
+    if (inSolution && blank(inputs?.projectId)) {
+        at('APIWF_LOCAL_NO_PROJECT_ID', `In-solution API workflow step "${step}" has no \`projectId\`. Read \`resource.projectKey\` from `
+            + `\`resources/solution_folder/process/api/<project>.json\`.`, `projectId: '<resource.projectKey>'`);
+    }
+    else if (inSolution && !GUID_RE.test(String(inputs.projectId).trim())) {
+        at('APIWF_LOCAL_PROJECT_ID_NOT_GUID', `In-solution API workflow step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
+            + `the sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
     }
+    // A folderPath beside in-solution is the serializer's APIWF_LOCAL_HAS_FOLDER (refusals.ts).
     const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
     if (name.includes('/')) {
         at('APIWF_NAME_IS_PATH', `API workflow step "${step}"'s \`name\` is ${JSON.stringify(inputs.name)}, which is a folder path. `

package/dist/nodes/process/flow/node-type.js

@@ -176,7 +176,8 @@ const API_WORKFLOW_PREFIX = 'uipath.core.api-workflow.';
  * one the platform's own definition writes.
  */
 function apiWorkflowDef(spec) {
-    const resourceKey = `${spec.folderPath}.${spec.name}`;
+    const loc = processResourceLocation(spec);
+    const { resourceKey } = loc;
     const properties = {};
     for (const [k, v] of Object.entries(spec.inputs)) {
         properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
@@ -186,8 +187,8 @@ function apiWorkflowDef(spec) {
         version: '1.0.0',
         category: 'api-workflow',
         runtimeConstraints: { exclude: ['api-function'] },
-        description: `(${spec.folderPath})`,
-        tags: [],
+        description: loc.description,
+        tags: loc.tags,
         sortOrder: resourceNodeSortOrder('api-workflow'),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: 'api' },
@@ -195,11 +196,12 @@ function apiWorkflowDef(spec) {
             { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
             { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
         ],
+        ...loc.definitionExtras,
         model: {
             type: 'bpmn:ServiceTask',
             serviceType: 'Orchestrator.ExecuteApiWorkflowAsync',
             version: 'v2',
-            section: 'Published',
+            ...(loc.inSolution ? {} : { section: 'Published' }),
             bindings: {
                 resource: 'process',
                 resourceSubType: 'Api',
@@ -207,9 +209,10 @@ function apiWorkflowDef(spec) {
                 orchestratorType: 'api',
                 values: [
                     { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: spec.folderPath },
+                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
                 ],
             },
+            ...loc.modelExtras,
             context: [
                 { name: 'name', type: 'string', value: '<bindings.name>' },
                 { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
@@ -611,7 +614,10 @@ export function processDefinition(spec) {
                 inputs: s.inputs ?? {}, returns: s.returns,
             });
         case 'apiWorkflow':
-            return apiWorkflowDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
+            return apiWorkflowDef({
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
+                inputs: s.inputs ?? {}, returns: s.returns,
+            });
         case 'agenticProcess':
             return agenticProcessDef({
                 key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
@@ -723,11 +729,14 @@ function liftProcess(node, ctx, prefix, kind, form) {
     const name = binding('name');
     const folderPath = binding('folderPath');
     // A sibling project of the same solution (#951): the model names its project
-    // instead of a folder. `isInSolution` is flow-core's marker. Read back as
-    // `location: 'in-solution'` so the recompile takes the in-solution path
-    // instead of a published one with an empty folder.
+    // instead of a folder. `isInSolution` is flow-core's marker; files that carry
+    // `projectName` but neither it nor `projectId` still carry the `in-solution`
+    // tag and an empty folder. Read back as `location: 'in-solution'` so the
+    // recompile takes the in-solution path instead of a published one with an
+    // empty folder (#1396). A tag beside a real folder is not enough.
     const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
-    const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
+    const inSolution = def?.model?.isInSolution === true || projectId !== undefined
+        || (Array.isArray(def?.tags) && def.tags.includes('in-solution') && !folderPath);
     const inputs = { ...(n.inputs ?? {}) };
     // The design-time fire-and-forget switch is an OPTION on agenticProcess(),
     // not a process argument — serialize adds it to `inputs` after rendering the

package/dist/nodes/process/flow/refusals.js

@@ -25,7 +25,7 @@ const KINDS = {
         noKeySuggestion: `key: '486edc26-0658-4ac1-92c9-1ef953927151'`,
     },
     apiWorkflow: {
-        noKeyCode: 'APIWF_NO_KEY', label: 'API workflow', oldField: 'workflow',
+        noKeyCode: 'APIWF_NO_KEY', localCode: 'APIWF_LOCAL_HAS_FOLDER', label: 'API workflow', oldField: 'workflow', localLabel: 'API workflow step',
         noKey: (step) => `API workflow step "${step}" has no \`key\`. That is the published workflow's key (a GUID), and `
             + `it becomes part of the node's type — without it there is no workflow to invoke. Find it with `
             + `\`uip or processes list --all-folders\` (an API workflow's ProcessKey reads "<name>.api.<name>").`,

package/dist/nodes/process/flow/spec.d.ts

@@ -74,12 +74,38 @@ export interface ApiWorkflowInputs {
      * `uip or processes list --all-folders --process-type Api` (an API workflow's
      * `ProcessKey` reads `<name>.api.<name>`; the GUID you want is the row's `Key`)
      * or `uip maestro flow registry search`.
+     *
+     * For an in-solution sibling it is `resource.key` from
+     * `resources/solution_folder/process/api/<project>.json`, the suffix of the
+     * node type `uip maestro flow registry list --local` shows.
      */
     key: string;
     /** The workflow's name in Orchestrator — e.g. `'NameToAgeFixed'`. */
     name: string;
-    /** The Orchestrator folder holding it — e.g. `'Shared'`. */
-    folderPath: string;
+    /**
+     * Where the workflow lives. `'published'` (the default) is a workflow
+     * deployed to `folderPath`. `'in-solution'` is a sibling API workflow project
+     * of the same solution: it needs `projectId` and no `folderPath`, and `key` is
+     * that sibling's `resource.key`.
+     */
+    location?: ProcessLocation;
+    /**
+     * The Orchestrator folder holding it — e.g. `'Shared'`. Required for a
+     * published workflow; omit it for an in-solution sibling.
+     *
+     * @enforcedBy APIWF_NO_FOLDER A published API workflow needs its folder.
+     * @enforcedBy APIWF_LOCAL_HAS_FOLDER An in-solution API workflow has no folder.
+     */
+    folderPath?: string;
+    /**
+     * The sibling API workflow project's `resource.projectKey`, read from
+     * `resources/solution_folder/process/api/<project>.json`. Required only when
+     * `location` is `'in-solution'`.
+     *
+     * @enforcedBy APIWF_LOCAL_NO_PROJECT_ID An in-solution API workflow needs its project id.
+     * @enforcedBy APIWF_LOCAL_PROJECT_ID_NOT_GUID The project id is the sibling's GUID, not its name.
+     */
+    projectId?: string;
     /**
      * The WORKFLOW's own input arguments, by its own argument names (e.g.
      * `{ name: 'tomasz' }`). Not a fixed schema — every workflow declares its own.