@uipath/maestro-builder-sdk 6.6.1 → 6.8.0

package/dist/decompile.js

@@ -182,6 +182,8 @@ const T = {
     loop: 'core.logic.loop',
     doWhile: 'core.logic.dowhile',
     dataFabricRead: 'core.datafabric.read',
+    dataFabricCreate: 'core.datafabric.create',
+    dataFabricDelete: 'core.datafabric.delete',
     documentClassify: 'uipath.document.classify',
     dynamicExtract: 'uipath.ixp.extract-document-builder',
     dataFabricUpdate: 'core.datafabric.update',
@@ -497,31 +499,93 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             ])})`;
         }
         case T.dataFabricRead:
-        case T.dataFabricUpdate: {
+        case T.dataFabricCreate:
+        case T.dataFabricUpdate:
+        case T.dataFabricDelete: {
             const cfg = (inputs.entityConfig ?? {});
             const entity = str(String(cfg.entityName ?? ''));
             const folder = typeof cfg._folderKey === 'string' ? str(cfg._folderKey) : undefined;
+            const resourceKey = typeof cfg._resourceKey === 'string' ? str(cfg._resourceKey) : undefined;
             const val = (v) => {
+                // 1.3 let `recordId` and a create's field value be a `{ type:
+                // 'jsExpression', expression }` object as well as a `=js:` string. A
+                // product-authored node can carry either; both recover as an expression.
+                const obj = v;
+                if (obj && typeof obj === 'object' && obj.type === 'jsExpression') {
+                    return emitBareExpr(String(obj.expression ?? ''), imp, inputNames);
+                }
                 const raw = typeof v === 'string' ? v : String(v ?? '');
                 return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : str(raw);
             };
+            const fieldObject = (rows) => {
+                const list = Array.isArray(rows) ? rows : [];
+                return `{ ${list.map((r) => `${key(String(r.field ?? ''))}: ${val(r.value)}`).join(', ')} }`;
+            };
+            const record = cfg.recordSource === 'fromRead'
+                ? `{ fromRead: ${str(String(cfg.readEntityNodeId ?? ''))} }`
+                : `{ byId: ${val(cfg.recordId)} }`;
             if (node.type === T.dataFabricRead) {
-                const rows = Array.isArray(cfg._filters) ? cfg._filters : [];
-                const filterRow = (r) => opts([
+                // The array is what the platform serializer reads and what compile
+                // writes; the grouped object is the newer authoring shape, tolerated
+                // here so a canvas-authored file still decompiles. Both flatten to the
+                // builder's row list, where `or: true` marks each new OR alternative.
+                const filterRow = (r, or = false) => opts([
                     ['field', str(String(r.field ?? ''))],
-                    ['operator', r.operator !== '=' ? str(String(r.operator ?? '')) : undefined],
+                    ['operator', r.operator !== undefined && r.operator !== '=' ? str(String(r.operator)) : undefined],
                     ['value', val(r.value)],
-                    ['or', r['join'] === 'OR' ? 'true' : undefined],
+                    ['or', or ? 'true' : undefined],
                 ]);
-                const filters = rows.length ? `[${rows.map(filterRow).join(', ')}]` : undefined;
-                return `${imp.use('dataFabricRead')}(${opts([['entity', entity], ['filters', filters], ['folderKey', folder]])})`;
+                const q = cfg._filters;
+                let rows = [];
+                if (Array.isArray(q)) {
+                    rows = q.map((r, i) => filterRow(r, i > 0 && r['join'] === 'OR'));
+                }
+                else if (q && typeof q === 'object') {
+                    // Grouped: each root row and each group is one alternative, so every
+                    // one but the first opens with `or: true`.
+                    const alts = [
+                        ...(Array.isArray(q.rows) ? q.rows.map((r) => [r]) : []),
+                        ...(Array.isArray(q.groups) ? q.groups : [])
+                            .map((g) => (Array.isArray(g.rows) ? g.rows : [])),
+                    ].filter((a) => a.length);
+                    rows = alts.flatMap((alt, ai) => alt.map((r, ri) => filterRow(r, ai > 0 && ri === 0)));
+                }
+                const filters = rows.length ? `[${rows.join(', ')}]` : undefined;
+                // `resultMode` only exists from 1.4, and recovering it re-selects 1.4 on
+                // the way back out — so a 1.0 node stays a 1.0 node through the round trip.
+                const mode = cfg.resultMode === 'single' || cfg.resultMode === 'multiple'
+                    ? str(cfg.resultMode) : undefined;
+                const sort = cfg._sort && typeof cfg._sort === 'object'
+                    ? opts([
+                        ['field', str(String(cfg._sort.field ?? ''))],
+                        ['direction', cfg._sort.direction === 'desc' ? str('desc') : undefined],
+                    ])
+                    : undefined;
+                const fields = Array.isArray(cfg._selectedFieldNames) && cfg._selectedFieldNames.length
+                    ? `[${cfg._selectedFieldNames.map((f) => str(String(f))).join(', ')}]`
+                    : undefined;
+                return `${imp.use('dataFabricRead')}(${opts([
+                    ['entity', entity], ['filters', filters], ['resultMode', mode],
+                    ['limit', typeof cfg._recordLimit === 'number' ? String(cfg._recordLimit) : undefined],
+                    ['skip', typeof cfg._skip === 'number' ? String(cfg._skip) : undefined],
+                    ['sort', sort], ['fields', fields],
+                    ['folderKey', folder], ['resourceKey', resourceKey],
+                ])})`;
             }
-            const record = cfg.recordSource === 'fromRead'
-                ? `{ fromRead: ${str(String(cfg.readEntityNodeId ?? ''))} }`
-                : `{ byId: ${val(cfg.recordId)} }`;
-            const updates = Array.isArray(cfg.fieldUpdates) ? cfg.fieldUpdates : [];
-            const set = `{ ${updates.map((u) => `${key(String(u.field ?? ''))}: ${val(u.value)}`).join(', ')} }`;
-            return `${imp.use('dataFabricUpdate')}(${opts([['entity', entity], ['record', record], ['set', set], ['folderKey', folder]])})`;
+            if (node.type === T.dataFabricCreate) {
+                return `${imp.use('dataFabricCreate')}(${opts([
+                    ['entity', entity], ['values', fieldObject(cfg.fieldValues)], ['folderKey', folder], ['resourceKey', resourceKey],
+                ])})`;
+            }
+            if (node.type === T.dataFabricDelete) {
+                return `${imp.use('dataFabricDelete')}(${opts([
+                    ['entity', entity], ['record', record], ['folderKey', folder], ['resourceKey', resourceKey],
+                ])})`;
+            }
+            return `${imp.use('dataFabricUpdate')}(${opts([
+                ['entity', entity], ['record', record], ['set', fieldObject(cfg.fieldUpdates)],
+                ['folderKey', folder], ['resourceKey', resourceKey],
+            ])})`;
         }
         case T.createOutgoingCall:
         case T.endCall: {

package/dist/index.d.ts

@@ -25,7 +25,7 @@ export { serialize as serializeCase } from './case/serialize.js';
 export { decompile as decompileCase, decompileWithDiagnostics as decompileCaseWithDiagnostics } from './case/decompile.js';
 export { bpmn } from './bpmn/bpmn-sdk.js';
 export type { BuiltBpmn, BpmnNode, BpmnFlow, BpmnVarDecl, EventDef, GatewayKind, EventKind, LoopSpec, RetrySpec, ActivityOpts, HttpOpts, } from './bpmn/bpmn-sdk.js';
-export { registryTypeNames, registryType } from './bpmn/typed-node.js';
+export { registryTypeNames, registryType, isSnapshotType } from './bpmn/typed-node.js';
 export type { RegistryTypeSpec, RegistryContextField, RegistryOutput } from './bpmn/typed-node.js';
 export { serialize as serializeBpmn } from './bpmn/serialize.js';
 export { check as checkBpmn } from './bpmn/check.js';

package/dist/index.js

@@ -28,8 +28,10 @@ export { decompile as decompileCase, decompileWithDiagnostics as decompileCaseWi
 // BPMN authoring API. `bpmn()` exposes only BPMN methods.
 export { bpmn } from './bpmn/bpmn-sdk.js';
 // The registry snapshot the typed nodes emit from — exposed so the coverage
-// ledger and its audit read the same source the emitter does.
-export { registryTypeNames, registryType } from './bpmn/typed-node.js';
+// ledger and its audit read the same source the emitter does. `isSnapshotType`
+// separates the two answers `registryType` now gives: a type the snapshot carries
+// emits offline, one it does not is resolved from the registry through `uip`.
+export { registryTypeNames, registryType, isSnapshotType } from './bpmn/typed-node.js';
 export { serialize as serializeBpmn } from './bpmn/serialize.js';
 export { check as checkBpmn } from './bpmn/check.js';
 export { check as checkCase } from './case/check.js';

package/dist/serialize.js

@@ -83,7 +83,9 @@ const NODE_TYPE = {
     loop: 'core.logic.loop',
     doWhile: 'core.logic.dowhile',
     dataFabricRead: 'core.datafabric.read',
+    dataFabricCreate: 'core.datafabric.create',
     dataFabricUpdate: 'core.datafabric.update',
+    dataFabricDelete: 'core.datafabric.delete',
     documentClassify: 'uipath.document.classify',
     dynamicExtract: 'uipath.ixp.extract-document-builder',
     subflow: 'core.subflow',
@@ -2375,6 +2377,93 @@ function scheduledVersion(inputs, explicit) {
     }
     return cron ? '1.2' : undefined;
 }
+/**
+ * Lower filter rows the way the platform's own serializer reads them.
+ *
+ * `_filters` is an ARRAY, and the join is a `join: 'OR'` key on the row that
+ * STARTS a new alternative — `entity-vdo.ts`'s `buildQesFromEntityConfig`
+ * splits the array into runs on that key, ANDs within a run, and ORs the runs
+ * together. So the query model is disjunctive: `alt1 OR alt2 OR …`, each `alt`
+ * an AND of its rows, which is why `[A, B(or), C]` is `A OR (B AND C)` and not
+ * `(A OR B) AND C`.
+ *
+ * The grouped `{ logicalOperator, rows, groups }` object the authoring guide
+ * shows is a NEWER shape: the vendored converter the local engine runs throws
+ * `(filters ?? []).filter is not a function` on it, so emitting it would trade
+ * a working offline rung for a shape only the current platform can read. The
+ * array is the form both accept.
+ */
+function dataFabricFilterRows(filters, render) {
+    return filters.map((f, i) => ({
+        field: f.field,
+        operator: f.operator ?? '=',
+        value: render(f.value),
+        // Never on the first row: a leading `join` starts an empty run, which the
+        // platform's own loop guards against, and which means nothing anyway.
+        ...(i > 0 && f.or ? { join: 'OR' } : {}),
+    }));
+}
+/**
+ * The two `bindings[]` rows a FOLDER-SCOPED entity needs to survive export to
+ * another org, and the `_resourceKey` that ties them to the node.
+ *
+ * Nothing else in this file emits `resource: 'Entity'`: the kind is matched by
+ * `(resourceKey, propertyAttribute)` rather than by name, carries no
+ * `resourceSubType`, spells the folder attribute `folderKey` (never
+ * `folderPath` — a folderPath row receives the Orchestrator FQN, which the
+ * Data Fabric query rejects even in the source org), and puts a DISPLAY label
+ * in `name`. The capital `E` is load-bearing: packaging ignores a lowercase
+ * row, so deploy emits no override at all.
+ *
+ * A tenant-scoped entity needs none of this — it serializes as a dotted
+ * literal — which is why the pair is emitted only when the author supplied
+ * both `folderKey` and `resourceKey`. `check` refuses the half-authored case,
+ * because `_folderKey` with no binding falls back to a source-org literal that
+ * looks portable and breaks on deploy.
+ */
+function entityBindings(entity, folderKey, resourceKey) {
+    const base = `b${entity.replace(/[^A-Za-z0-9]/g, '')}Entity`;
+    return [
+        {
+            id: `${base}Name`,
+            name: entity,
+            type: 'string',
+            resource: 'Entity',
+            resourceKey,
+            default: entity,
+            propertyAttribute: 'name',
+        },
+        {
+            id: `${base}Folder`,
+            name: `${entity}Folder`,
+            type: 'string',
+            resource: 'Entity',
+            resourceKey,
+            default: folderKey,
+            propertyAttribute: 'folderKey',
+        },
+    ];
+}
+/**
+ * Which `core.datafabric.read` definition a step needs.
+ *
+ * The family's read node grew from "Read entity" into "Query entity records" at
+ * 1.4, and `entityConfig.resultMode` is the input that expresses the difference.
+ * The SDK keeps 1.0 pinned as the default, the same way every other family here
+ * keeps its older default — a flow that reads one record must not change
+ * version because the platform moved. So `resultMode` SELECTS 1.4, exactly as a
+ * Quartz `every` selects the scheduled trigger's 1.2 (see `scheduledVersion`).
+ */
+function dataFabricReadVersion(inputs, explicit) {
+    if (explicit !== undefined) {
+        if (inputs?.resultMode !== undefined && explicit === '1.0') {
+            throw new Error("dataFabricRead(): { resultMode } needs the node's 1.4 definition, but { version: '1.0' } was "
+                + 'requested. Drop the version, request 1.4, or drop resultMode.');
+        }
+        return explicit;
+    }
+    return inputs?.resultMode !== undefined ? '1.4' : undefined;
+}
 /**
  * The form-trigger schema: one field per flow input, the same derivation the
  * designer's form editor applies to a flow's arguments (`argument-fields.ts` /
@@ -3691,6 +3780,15 @@ function stepNamesOf(steps, out = []) {
     return out;
 }
 export function serialize(built, opts = {}) {
+    /**
+     * The `definitions[]` a flow carries, keyed by `type@version` — NOT by type.
+     * One flow can legitimately hold two versions of the same family (a plain
+     * `.loop()` at 1.0.0 beside a parallel one at 2.4; a `dataFabricRead()` at 1.0
+     * beside a `resultMode` query at 1.4), and a type-keyed map emitted only the
+     * last of them: every other node of that family then pinned a `typeVersion`
+     * with no matching definition, which `uip maestro flow validate` refuses:
+     * "Node type `core.datafabric.read:1.4` has no matching definition".
+     */
     const emittedDefs = new Map();
     /**
      * RESOURCE bindings collected while emitting, keyed by binding id — `resource:
@@ -3774,7 +3872,7 @@ export function serialize(built, opts = {}) {
             def = exact;
         }
         if (def)
-            emittedDefs.set(type, def);
+            emittedDefs.set(`${type}@${def.version}`, def);
         const node = {
             id,
             type,
@@ -5102,39 +5200,74 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             return [{ node: id, port: successPort(type) }];
         }
-        if (spec.kind === 'dataFabricRead' || spec.kind === 'dataFabricUpdate') {
-            const type = spec.kind === 'dataFabricRead' ? NODE_TYPE.dataFabricRead : NODE_TYPE.dataFabricUpdate;
+        if (spec.kind === 'dataFabricRead' || spec.kind === 'dataFabricCreate'
+            || spec.kind === 'dataFabricUpdate' || spec.kind === 'dataFabricDelete') {
+            const type = NODE_TYPE[spec.kind];
             const id = stepUid(scope, step.name);
-            const node = makeNode(type, id, step.name, { parentId, requestedVersion: step.options?.version });
+            const node = makeNode(type, id, step.name, {
+                parentId,
+                requestedVersion: spec.kind === 'dataFabricRead'
+                    ? dataFabricReadVersion(spec.inputs, step.options?.version)
+                    : step.options?.version,
+            });
             const cfg = { entityName: spec.inputs.entity };
-            if (spec.kind === 'dataFabricRead') {
-                if (spec.inputs.filters?.length) {
-                    cfg._filters = spec.inputs.filters.map((f, i) => ({
-                        field: f.field,
-                        operator: f.operator ?? '=',
-                        value: String(renderValue(f.value, scope.rename)),
-                        ...(i > 0 && f.or ? { join: 'OR' } : {}),
-                    }));
-                }
-            }
-            else {
-                const rec = spec.inputs.record;
-                if (typeof rec.fromRead === 'string') {
+            // `recordSource` is how update and delete both name their target; the
+            // read step's emitted node id is rename-aware, for subflow copies.
+            const targetRecord = (record) => {
+                if (typeof record.fromRead === 'string') {
                     cfg.recordSource = 'fromRead';
-                    // The read step's emitted node id (rename-aware for subflow copies).
-                    cfg.readEntityNodeId = scope.stepNodeId.get(rec.fromRead) ?? rec.fromRead;
+                    cfg.readEntityNodeId = scope.stepNodeId.get(record.fromRead) ?? record.fromRead;
                 }
                 else {
                     cfg.recordSource = 'byId';
-                    cfg.recordId = String(renderValue(rec.byId, scope.rename));
+                    cfg.recordId = String(renderValue(record.byId, scope.rename));
                 }
-                cfg.fieldUpdates = Object.entries(spec.inputs.set ?? {}).map(([field, value]) => ({
-                    field,
-                    value: String(renderValue(value, scope.rename)),
-                }));
+            };
+            const fieldRows = (values) => Object.entries(values ?? {}).map(([field, value]) => ({
+                field,
+                value: String(renderValue(value, scope.rename)),
+            }));
+            if (spec.kind === 'dataFabricRead') {
+                // Only 1.4 declares it, and only 1.4 is emitted when it is set (see
+                // dataFabricReadVersion) — so writing it can never land on a 1.0 node,
+                // where it would be an input the definition does not know.
+                if (spec.inputs.resultMode !== undefined)
+                    cfg.resultMode = spec.inputs.resultMode;
+                if (spec.inputs.limit !== undefined)
+                    cfg._recordLimit = spec.inputs.limit;
+                if (spec.inputs.skip !== undefined)
+                    cfg._skip = spec.inputs.skip;
+                if (spec.inputs.sort !== undefined) {
+                    cfg._sort = { field: spec.inputs.sort.field, direction: spec.inputs.sort.direction ?? 'asc' };
+                }
+                if (spec.inputs.fields?.length)
+                    cfg._selectedFieldNames = [...spec.inputs.fields];
+                if (spec.inputs.filters?.length) {
+                    cfg._filters = dataFabricFilterRows(spec.inputs.filters, (value) => String(renderValue(value, scope.rename)));
+                }
+            }
+            else if (spec.kind === 'dataFabricCreate') {
+                cfg.fieldValues = fieldRows(spec.inputs.values);
+            }
+            else if (spec.kind === 'dataFabricUpdate') {
+                targetRecord(spec.inputs.record);
+                cfg.fieldUpdates = fieldRows(spec.inputs.set);
+            }
+            else {
+                targetRecord(spec.inputs.record);
             }
             if (spec.inputs.folderKey !== undefined)
                 cfg._folderKey = spec.inputs.folderKey;
+            // A folder-scoped entity is portable only with its `Entity` bindings; the
+            // half-authored form is refused by check(), so reaching here with both
+            // means emit both. Same id for the same (entity, resourceKey), so two
+            // steps on one entity share one pair rather than duplicating it.
+            if (spec.inputs.folderKey !== undefined && spec.inputs.resourceKey !== undefined) {
+                cfg._resourceKey = spec.inputs.resourceKey;
+                for (const entry of entityBindings(spec.inputs.entity, spec.inputs.folderKey, spec.inputs.resourceKey)) {
+                    resourceBindings.set(entry.id, entry);
+                }
+            }
             node.inputs = { entityConfig: cfg };
             scope.nodes.push(node);
             for (const t of tails)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.6.1",
+  "version": "6.8.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -87,5 +87,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "cd125317bcecb3a004dfe47cf11ef6b9878fe331"
+  "gitref": "de2812e18734552a112d97deec05fc9ae2244caa"
 }