@uipath/maestro-builder-sdk 5.2.0

package/dist/bpmn/connector.js

@@ -0,0 +1,199 @@
+import { connectorOutputVars } from './bpmn-sdk.js';
+import { transportHttpMethod } from '../config.js';
+import { refuseLookupToken } from '../core/lookups.js';
+export function createConnectorTask(ctx, n) {
+    const { m } = ctx;
+    if (!ctx.library)
+        throw new Error(`connector task "${n.id}" needs the connector library — pass { library } to serialize or use uip maestro bpmn compile --library.`);
+    const rc = ctx.library.resolve(n.key, n.action, n.version, n.object);
+    const outVars = connectorOutputVars(n);
+    const op = (rc.entry.operation ?? {});
+    const params = Array.isArray(op.parameters) ? op.parameters : [];
+    // ── uipath:context — the connector wiring ──
+    // `activity` is the primary-key required field (the selected op identity).
+    const ctxInputs = [
+        ctxInput(m, 'activity', 'string', op.name ?? op.objectName ?? n.action),
+        // `operation` is required by the PRODUCT validator, which reports
+        // `EMPTY_REQUIRED_FIELD: The field 'operation' … is required but has no value` without it —
+        // so every connector task the SDK emitted was rejected by `uip maestro bpmn validate`,
+        // including the one in `example/`. The vendored maestro-sdk + canvas validator this
+        // package tests against does not check it, which is why the suite stayed green; the gap
+        // only shows against the shipped CLI.
+        //
+        // It carries the same CRUD op name as `activity` (both are `op.name`, e.g. `Create`)
+        // because that is the field the runtime reads for it: the dispatch layer's
+        // `authoredOperation` looks at `inputs.operation` first and only falls back to guessing
+        // the verb from the HTTP method. So this also makes a live run address the op it was
+        // authored for rather than an inferred one.
+        ctxInput(m, 'operation', 'string', op.name ?? op.objectName ?? n.action),
+        ctxInput(m, 'connectorKey', 'string', rc.connectorKey),
+    ];
+    const connRef = bindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
+    if (connRef) {
+        ctxInputs.push(ctxInput(m, 'connection', 'string', `=bindings.${connRef.id}`));
+        ctxInputs.push(ctxInput(m, 'resourceKey', 'string', connRef.resourceKey));
+    }
+    const folderRef = bindingRef(ctx, n.folder, 'Connection', 'folderKey', 'FolderKey');
+    if (folderRef)
+        ctxInputs.push(ctxInput(m, 'folderKey', 'string', `=bindings.${folderRef.id}`));
+    ctxInputs.push(ctxInput(m, 'objectName', 'string', op.objectName ?? n.action), ctxInput(m, 'method', 'string', transportHttpMethod(rc.httpMethod)), ctxInput(m, 'path', 'string', rc.endpoint), jsonInput(m, 'metadata', undefined, connectorMetadata(rc, op)));
+    // ── request inputs — split declared params into path/query, rest is body ──
+    const pathParameters = {};
+    const queryParameters = {};
+    // BPMN copies these values into the emitted body verbatim, so an unresolved
+    // lookup would ship as `{"__lookup": …}` where the connector wants an id.
+    // Only Flow reads connectors-local/resolutions.json today.
+    for (const [name, value] of Object.entries(n.inputs ?? {})) {
+        refuseLookupToken(value, 'bpmn', name);
+    }
+    const body = { ...n.inputs };
+    for (const p of params) {
+        const name = String(p.name ?? '');
+        if (!(name in body))
+            continue;
+        const camel = toCamel(name);
+        if (p.type === 'path') {
+            pathParameters[camel] = body[name];
+            delete body[name];
+        }
+        else if (p.type === 'query') {
+            queryParameters[camel] = body[name];
+            delete body[name];
+        }
+    }
+    // ── outputs — response schema + standard Error ──
+    const responseSchema = rc.entry.outputSchema
+        ? schemaFromFields(rc.entry.outputSchema.fields ?? [])
+        : { type: 'object', properties: {} };
+    const activity = m.create('uipath:Activity', {
+        version: 'v1',
+        // Only an activity/event tag can carry this — a mapping has no such
+        // attribute, which is why `skipCondition` is a connector-only option.
+        skipCondition: n.skipCondition,
+        type: m.create('uipath:Type', { value: 'Intsvc.ActivityExecution', version: 'v1' }),
+        context: m.create('uipath:Context', { input: ctxInputs }),
+        input: [
+            jsonInput(m, 'pathParameters', 'pathParameters', pathParameters),
+            jsonInput(m, 'queryParameters', 'queryParameters', queryParameters),
+            jsonInput(m, 'body', 'body', body),
+        ],
+        output: [
+            m.create('uipath:Output', {
+                name: 'response', type: 'jsonSchema', source: '=response', var: outVars.response,
+                body: JSON.stringify({ $schema: 'http://json-schema.org/draft-07/schema#', ...responseSchema }),
+            }),
+            m.create('uipath:Output', {
+                name: 'Error', type: 'jsonSchema', source: '=Error', var: outVars.error,
+                body: JSON.stringify({
+                    type: 'object',
+                    properties: {
+                        code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
+                        category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
+                    },
+                }),
+            }),
+        ],
+    });
+    return m.create('bpmn:SendTask', {
+        id: n.id,
+        name: n.name ?? rc.entry.display?.label ?? n.action,
+        extensionElements: m.create('bpmn:ExtensionElements', { values: [activity] }),
+    });
+}
+/** A `uipath:context` scalar input row. */
+function ctxInput(m, name, type, value) {
+    return m.create('uipath:Input', { name, type, value: String(value ?? '') });
+}
+/** A json `uipath:input` — CDATA body, optionally `target`-tagged (body/path/query). */
+function jsonInput(m, name, target, obj) {
+    const props = { name, type: 'json', body: JSON.stringify(obj ?? {}) };
+    if (target)
+        props.target = target;
+    return m.create('uipath:Input', props);
+}
+/**
+ * Resolve a symbolic connection/folder to a process-level binding.
+ *
+ * Exported for the Phase 3d nodes, which need the identical closure: a connector
+ * event and an external agent/workflow each reference a connection and a folder
+ * the same way a connector activity does, and duplicating this was how the two
+ * families drifted apart in `case/serialize.ts`.
+ */
+export function connectorBindingRef(ctx, name, resource, propertyAttribute, displayName) {
+    return bindingRef(ctx, name, resource, propertyAttribute, displayName);
+}
+/** Resolve a symbolic connection/folder to a process-level binding (collected once),
+ * returning its id + resourceKey for the `=bindings.<id>` reference. Mirrors
+ * `case/serialize.ts` `bindingRef`. */
+function bindingRef(ctx, name, resource, propertyAttribute, displayName) {
+    if (!name)
+        return undefined;
+    const entry = ctx.bindings?.entry(name);
+    const id = entry?.id ?? name;
+    const resourceKey = entry?.resourceKey ?? entry?.default ?? name;
+    if (!ctx.bindingSink.has(id)) {
+        ctx.bindingSink.set(id, {
+            id,
+            name: entry?.name ?? displayName,
+            type: 'string',
+            resource,
+            resourceKey,
+            default: entry?.default ?? resourceKey,
+            propertyAttribute,
+        });
+    }
+    return { id, resourceKey };
+}
+/** The functional connector `metadata` blob (essentialConfiguration + activityTypeId);
+ * designer cosmetics are omitted (schema-valid without them — design §C/§D). */
+function connectorMetadata(rc, op) {
+    const instanceParameters = {
+        connectorKey: rc.connectorKey,
+        objectName: op.objectName ?? rc.nodeType.split('.').pop(),
+        httpMethod: rc.httpMethod,
+        activityType: op.activityType ?? 'Curated',
+        version: rc.version,
+        supportsStreaming: op.supportsStreaming ?? false,
+        subType: op.subType ?? 'standard',
+    };
+    return {
+        activityPropertyConfiguration: {
+            configuration: `=jsonString:${JSON.stringify({
+                essentialConfiguration: {
+                    instanceParameters,
+                    objectName: instanceParameters.objectName,
+                    httpMethod: transportHttpMethod(rc.httpMethod),
+                    path: rc.endpoint,
+                    packageVersion: rc.version,
+                },
+            })}`,
+            uiPathActivityTypeId: rc.activityTypeId ?? '',
+            errorState: { issues: [] },
+        },
+    };
+}
+function schemaFromFields(fields) {
+    const properties = {};
+    for (const f of fields) {
+        const name = f?.name;
+        if (!name)
+            continue;
+        properties[name] = { title: f.displayName ?? name, type: jsonType(f.type) };
+    }
+    return { type: 'object', properties };
+}
+function jsonType(t) {
+    switch (String(t ?? '').toLowerCase()) {
+        case 'number':
+        case 'integer':
+        case 'float': return 'number';
+        case 'boolean':
+        case 'bool': return 'boolean';
+        case 'object': return 'object';
+        case 'array': return 'array';
+        default: return 'string';
+    }
+}
+function toCamel(s) {
+    return s.replace(/[_-](\w)/g, (_, c) => c.toUpperCase());
+}

package/dist/bpmn/decompile-cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { type CliExitCode } from '../cli-run.js';
+/**
+ * `run(argv)` is the tool contract the family-first `flow-sdk` CLI loads. It must
+ * NOT read `process.argv`: under the unified CLI that still holds
+ * `bpmn decompile …`, so a positional scan would pick up the family word.
+ */
+export declare function run(argv: string[]): Promise<CliExitCode>;

package/dist/bpmn/decompile-cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * decompile-cli — `<Name>.bpmn` → `<Name>.bpmn.ts`
+ *
+ * Usage:
+ *   node --experimental-strip-types decompile-cli.js <Name.bpmn> [-o Name.bpmn.ts] [--import <specifier>]
+ *
+ * The reverse of compile-cli: reads a `.bpmn` and emits builder source whose
+ * default export re-serializes to the same XML. `--import` sets the module
+ * specifier of the emitted `import { bpmn }` line (default
+ * the package's `./bpmn` subpath export) so the emitted file
+ * resolves for a package consumer; the library default in `decompile.ts` stays
+ * repo-relative for in-tree callers, mirroring the Flow and Case arms.
+ *
+ * Diagram layout is not read or emitted — the SDK emits semantic-only XML and
+ * `tidy` regenerates `bpmndi`. Run `tidy` on the recompiled artifact when a canvas
+ * needs one.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { runWhenInvokedDirectly } from '../cli-run.js';
+import { decompile } from './decompile.js';
+import { BPMN_IMPORT } from '../package-name.js';
+function opt(argv, name) {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+/**
+ * `run(argv)` is the tool contract the family-first `flow-sdk` CLI loads. It must
+ * NOT read `process.argv`: under the unified CLI that still holds
+ * `bpmn decompile …`, so a positional scan would pick up the family word.
+ */
+export async function run(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.error('usage: decompile <Name.bpmn> [-o Name.bpmn.ts] [--import <specifier>]');
+        return 2;
+    }
+    const flags = new Set(['-o', '--import']);
+    const input = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]));
+    if (!input) {
+        console.error('decompile: missing <Name.bpmn>');
+        return 2;
+    }
+    const xml = readFileSync(input, 'utf8');
+    const source = await decompile(xml, {
+        importSpecifier: opt(argv, '--import') ?? BPMN_IMPORT,
+    });
+    const base = basename(input).replace(/\.bpmn$/, '');
+    const out = opt(argv, '-o') ?? `${base}.bpmn.ts`;
+    writeFileSync(out, source);
+    console.log(`decompile: wrote ${out}`);
+    return 0;
+}
+runWhenInvokedDirectly(import.meta.url, 'decompile', run);

package/dist/bpmn/decompile.d.ts

@@ -0,0 +1,6 @@
+/** Options for {@link decompile}. */
+export interface BpmnDecompileOptions {
+    /** Module specifier for the emitted `import { bpmn }` line. */
+    importSpecifier?: string;
+}
+export declare function decompile(xml: string, options?: BpmnDecompileOptions): Promise<string>;