@uipath/maestro-builder-sdk 6.46.6 → 6.47.0

package/dist/case/serialize.js

@@ -8,7 +8,7 @@
  * `metadata.caseExitRules`. Symbolic references in rules (a stage label, a task
  * name) are resolved here to the generated ids.
  */
-import { IdGen } from './ids.js';
+import { IdGen, offlineBindingSeed } from './ids.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
 import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
@@ -22,7 +22,9 @@ import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './
 import { ownEntry } from '../core/own-entry.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
+import { businessEventProblems } from './business-event-shape.js';
 import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../core/event-filters.js';
+import { ruleShapeProblems } from './rule-options.js';
 /**
  * Condition `displayName` allocator.
  *
@@ -81,6 +83,8 @@ export function serialize(built, opts = {}) {
         library: opts.library,
         bindings: opts.bindings,
         bindingSink: new Map(),
+        ids,
+        offlineBindingIds: new Map(),
         varCompanions: new Map(),
         outputIds: new Set(),
         ownOutputVars: ownOutputVars(built),
@@ -88,6 +92,7 @@ export function serialize(built, opts = {}) {
         slaIdByName: new Map(),
         escalationId: new Map(),
         escalationIdByName: new Map(),
+        businessEvents: new Set((built.businessEvents ?? []).map((event) => event.name)),
         conditionName: conditionNamer(built),
     };
     // Preallocate SLA + escalation ids (before any rule is emitted) so a
@@ -219,6 +224,12 @@ export function serialize(built, opts = {}) {
     if (built.slaRules.length) {
         metadata.slaRules = built.slaRules.map((s, i, all) => emitSla(s, i, all.length, ids, resolver));
     }
+    if (built.businessEvents?.length) {
+        const [problem] = businessEventProblems(built.businessEvents);
+        if (problem)
+            throw new Error(problem.message);
+        metadata.businessEvents = built.businessEvents.map(emitBusinessEvent);
+    }
     // Variables: declared vars + the readable companions that task outputs bound
     // (collected during stage emission above). A declared var wins on a name clash.
     const variables = emitVariables(built.vars, ids, triggerNodeByRef);
@@ -1469,6 +1480,20 @@ function ioSlot(name, bodyObj, elementId) {
     const v = `v${name}`;
     return { name, type: 'json', target: name, body: bodyObj, var: v, id: v, elementId };
 }
+/**
+ * The binding id for a label no bindings.json declares. The row's
+ * `resourceKey`/`default` stays the label, and the id is minted from it (`b` +
+ * 8, as Studio Web mints one), once per label; `offlineBindingLabel` reverses
+ * it for decompile.
+ */
+function offlineBindingId(resolver, seed) {
+    let id = resolver.offlineBindingIds.get(seed);
+    if (id === undefined) {
+        id = resolver.ids.make('b', 8, seed);
+        resolver.offlineBindingIds.set(seed, id);
+    }
+    return id;
+}
 /** Resolve a symbolic connection/folder to a root binding entry (collected once),
  * returning its id + resourceKey for the `=bindings.<id>` reference. */
 function bindingRef(resolver, name, resource, propertyAttribute, displayName, site) {
@@ -1483,8 +1508,12 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
     if (refused)
         throw refused;
     const entry = resolver.bindings?.entry(name);
-    const id = entry?.id ?? name;
     const resourceKey = entry?.resourceKey ?? entry?.default ?? name;
+    // Only a label with no bindings.json entry gets a minted id: an entry's
+    // `resourceKey` is the real key, so its id (or its name) cannot clash with it.
+    const id = entry
+        ? String(entry.id ?? name)
+        : offlineBindingId(resolver, offlineBindingSeed(resource, propertyAttribute, name));
     if (!resolver.bindingSink.has(id)) {
         resolver.bindingSink.set(id, {
             id,
@@ -1501,7 +1530,8 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
 /**
  * A connector's folder is a property of its connection:
  * { resourceKey: <connection key>, default: <folder key>, propertyAttribute: 'folderKey' }.
- * One folder label on two connections gets one row each: `shared`, `shared_2`.
+ * One folder label on two connections gets one row each: `shared`, `shared_2`
+ * (offline, the minted id is seeded on the connection, so the rows differ anyway).
  * One connection with two different folders is refused: a connection lives in
  * one folder, and the syncs group rows by `resourceKey`, so one value would win.
  * Without a connection the folder binds as a plain binding.
@@ -1515,7 +1545,9 @@ function folderBindingRef(resolver, name, connection, site) {
     if (refused)
         throw refused;
     const entry = resolver.bindings?.entry(name);
-    const baseId = entry?.id ?? name;
+    const baseId = entry
+        ? String(entry.id ?? name)
+        : offlineBindingId(resolver, offlineBindingSeed('Connection', 'folderKey', name, connection.resourceKey));
     const folderKey = entry?.default ?? entry?.resourceKey ?? name;
     const matches = (row) => row?.resourceKey === connection.resourceKey && row?.default === folderKey
         && row?.propertyAttribute === 'folderKey';
@@ -1722,6 +1754,9 @@ function emitRules(rules, seed, ownerId, ids, resolver, site) {
     return rules.map((group, gi) => group.map((r, ri) => emitRule(r, `${seed}:${gi}:${ri}`, ownerId, ids, resolver, site)));
 }
 function emitRule(r, seed, ownerId, ids, resolver, site) {
+    const [shape] = ruleShapeProblems(r);
+    if (shape)
+        throw new Error(`${shape.message.replace(/^Rule /, 'rule ')} (in ${site})`);
     const ruleId = ids.ruleId(seed);
     const out = { rule: r.rule, id: ruleId };
     if (r.rule === 'selected-stage-completed' || r.rule === 'selected-stage-exited') {
@@ -1757,10 +1792,57 @@ function emitRule(r, seed, ownerId, ids, resolver, site) {
             out.escalationId = escId;
         }
     }
+    if (r.rule === 'api-event') {
+        // The event is matched by its exact name at run time; a rule without one
+        // listens for nothing, so both a missing and an undeclared name refuse.
+        if (!r.businessEvent)
+            throw new Error(`rule "api-event" in ${site} names no business event — write rule('api-event', { businessEvent: '<name>' }) with a name declared by .businessEvent('<name>').`);
+        if (!resolver.businessEvents.has(r.businessEvent))
+            throw new Error(`rule "api-event" in ${site} listens for business event "${r.businessEvent}", which the case does not declare — add .businessEvent(${JSON.stringify(r.businessEvent)}).`);
+        out.businessEventType = r.businessEvent;
+    }
     if (r.expression)
         out.conditionExpression = r.expression;
     return out;
 }
+const JSON_SCHEMA_DRAFT_7 = 'http://json-schema.org/draft-07/schema#';
+/**
+ * True only for a payload that says nothing at all: `{}`, `{ type: 'object' }`
+ * or `{ type: 'object', properties: {} }`. Any other key (`required`,
+ * `$schema`, a non-object `type`, ...) is content the author wrote, so the
+ * schema is written and survives a decompile/recompile round trip.
+ */
+function isEmptyObjectSchema(payload) {
+    return Object.entries(payload).every(([key, value]) => {
+        if (key === 'type')
+            return value === 'object';
+        if (key === 'properties')
+            return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+        return false;
+    });
+}
+/**
+ * One `metadata.businessEvents[]` entry, in the shape the Case Designer saves
+ * (`{ name, description?, schema? }`). `schema` is the payload's JSON Schema
+ * serialized to a string with `$schema` defaulted to draft 7. The payload is an
+ * object or array schema (`businessEventProblems` refuses any other type before
+ * this runs), and every one except the empty object schema
+ * (`isEmptyObjectSchema`) is written. That keeps more than the Designer and `uip maestro case sdd
+ * convert`, which write a schema only for `type: 'array'` or a non-empty
+ * `properties`: `{ type: 'object', required: ['a'] }` is written here and left
+ * out there, so a decompiled payload recompiles unchanged.
+ */
+function emitBusinessEvent(event) {
+    const out = { name: event.name };
+    if (event.description !== undefined)
+        out.description = event.description;
+    const payload = event.payload;
+    if (payload !== undefined) {
+        if (!isEmptyObjectSchema(payload))
+            out.schema = JSON.stringify({ ...payload, $schema: payload.$schema ?? JSON_SCHEMA_DRAFT_7 });
+    }
+    return out;
+}
 function emitEntry(c, seed, ownerId, label, ids, resolver) {
     const out = {
         id: ids.conditionId(seed),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.46.6",
+  "version": "6.47.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "64e024e591ad47ef3ebcdebe54d8a07ead2aa871"
+  "gitref": "e0223e1b46cdf1eb1f4ab072c970824f52b87eeb"
 }