@uipath/maestro-builder-sdk 6.32.5 → 6.32.7

package/dist/case/case-sdk.d.ts

@@ -204,6 +204,8 @@ export interface BuiltTrigger {
     eventOutputs?: TaskOutputBinding[];
     /** Event only: a library-resolved Integration Service subscription. */
     eventSubscription?: EventSubscription;
+    /** Event placeholder only: the source object the event watches (see {@link EventTriggerOpts.object}). */
+    eventObject?: string;
 }
 export interface ManualTriggerOpts {
     name?: string;
@@ -241,10 +243,25 @@ export interface EventTriggerOpts {
     description?: string;
     /**
      * Stringly resolved subscription. Prefer the descriptor overload when a
-     * prepared connector module is available. Omit this for the legacy
-     * `serviceType`-only placeholder.
+     * prepared connector module is available. Omit this for a **placeholder**
+     * trigger, whose bag carries `serviceType` (plus `context[objectName]` when
+     * `object` is set).
      */
     subscription?: EventSubscription;
+    /**
+     * The source OBJECT the event watches — a Data Fabric entity, a Salesforce or
+     * ServiceNow object, a database table — for a **placeholder** trigger whose
+     * connector and connection are not resolved yet. It is emitted as the
+     * trigger's `context[objectName]` row, the same row `uip maestro case sdd
+     * convert` writes for an SDD's `| T02 | Intsvc.EventTrigger | <object> | … |`
+     * Case Triggers row, so the requested source survives in the plan as data,
+     * not only in a label. For example
+     * `eventTrigger({ name: 'Invoice created', object: 'aged_invoice_cases' })`.
+     *
+     * A resolved subscription names its object in `subscription.object` instead;
+     * passing both is refused.
+     */
+    object?: string;
     /**
      * Optional event-payload extractions. Each key is a case-variable name read
      * downstream as `=vars.<name>`; each value is the payload field expression
@@ -253,7 +270,8 @@ export interface EventTriggerOpts {
      *
      * @remarks
      * With **no** outputs the event trigger is a **placeholder** (`data.inputs`
-     * carries only `serviceType`) — the offline shape for an event on a connector
+     * carries `serviceType`, plus `context[objectName]` when `object` is set) —
+     * the offline shape for an event on a connector
      * not yet registered; attach the real connection after registering it.
      */
     outputs?: Record<string, string | {

package/dist/case/case-sdk.js

@@ -112,11 +112,21 @@ export function eventTrigger(descriptorOrOpts = {}, descriptorOpts = {}) {
         const type = (typeof v === 'string' ? 'string' : (v.type ?? 'string'));
         eventOutputs.push({ var: name, source, type });
     }
+    const object = descriptor ? undefined : opts.object;
+    if (object !== undefined) {
+        if (opts.subscription)
+            throw new Error('eventTrigger: pass the watched object as `subscription.object` on a resolved subscription, not as `object`.');
+        // Refuse padding rather than trim it: the value must match the SDD's
+        // source object exactly, and a silent trim would hide the typo.
+        if (typeof object !== 'string' || !object.trim() || object !== object.trim())
+            throw new Error('eventTrigger: `object` must be a non-empty string with no surrounding whitespace.');
+    }
     return {
         kind: 'event',
         name: opts.name,
         description: opts.description,
         eventOutputs: eventOutputs.length ? eventOutputs : undefined,
+        eventObject: object,
         eventSubscription: descriptor
             ? subscriptionFrom(descriptor, descriptorOpts)
             : opts.subscription,

package/dist/case/compile-cli.js

@@ -269,8 +269,8 @@ function syncEntryPoints(caseplan, outPath) {
  * succeeds with zero warnings when the sidecar is stale or empty.
  *
  * Non-connector resources come from root binding pairs and referenced tasks.
- * Connector connection and folder bindings have different resource keys, so
- * their relationship comes from the context[] that references both binding ids.
+ * A connector's connection and folder relationship comes from the context[]
+ * that references both binding ids.
  * No-op when compiling outside a scaffolded project.
  */
 function syncBindingsV2(caseplan, outPath) {

package/dist/case/decompile.js

@@ -814,7 +814,9 @@ function triggerSource(node, index, plan, refs) {
     }
     if (bag.serviceType === 'Intsvc.EventTrigger') {
         const bridges = bridgeRows(plan, node.id ?? '', bag);
-        const resolved = bag.context !== undefined || bag.inputs !== undefined || bag.bindings !== undefined;
+        const object = placeholderEventObject(bag);
+        const resolved = object === undefined
+            && (bag.context !== undefined || bag.inputs !== undefined || bag.bindings !== undefined);
         const outputs = (bag.outputs ?? []).filter((row) => !bridges.has(row) && !isResolvedConnectorOutput(row, node.id ?? '', resolved));
         const subscription = resolved
             ? resolvedSubscriptionSource(bag, `event trigger "${label ?? node.id ?? index}"`, 'trigger', refs)
@@ -832,11 +834,28 @@ function triggerSource(node, index, plan, refs) {
             ['name', name],
             ['description', description ? tsLiteral(description) : undefined],
             ['subscription', subscription],
+            ['object', object !== undefined ? tsLiteral(object) : undefined],
             ['outputs', outputShape],
         ])})`;
     }
     throw new Error(`trigger "${label ?? node.id ?? index}" has unsupported serviceType "${bag.serviceType}".`);
 }
+/**
+ * The source object of an unresolved event trigger, when its bag is the
+ * placeholder plus one `context[objectName]` row — the shape `eventTrigger({
+ * object })` compiles to and `uip maestro case sdd convert` writes. Anything
+ * richer (connector key, inputs, bindings) is a resolved subscription.
+ */
+function placeholderEventObject(bag) {
+    const context = bag.context;
+    if (!Array.isArray(context) || context.length !== 1)
+        return undefined;
+    const row = context[0];
+    if (row?.name !== 'objectName' || typeof row.value !== 'string' || !row.value.trim())
+        return undefined;
+    const empty = (value) => value === undefined || (Array.isArray(value) && value.length === 0);
+    return empty(bag.inputs) && empty(bag.bindings) ? row.value : undefined;
+}
 function caseAppSource(config) {
     if (typeof config.caseSummary !== 'string')
         throw new Error('caseAppConfig.caseSummary must be a string.');

package/dist/case/serialize.js

@@ -184,7 +184,7 @@ export function serialize(built, opts = {}) {
                 context.push(io('connection', 'string', { value: `=bindings.${connection.id}` }));
                 context.push(io('resourceKey', 'string', { value: connection.resourceKey }));
             }
-            const folder = bindingRef(resolver, connector.folder, 'Connection', 'folderKey', 'FolderKey', { ...site, attribute: 'folder' });
+            const folder = folderBindingRef(resolver, connector.folder, connection, { ...site, attribute: 'folder' });
             if (folder)
                 context.push(io('folderKey', 'string', { value: `=bindings.${folder.id}` }));
         }
@@ -700,7 +700,12 @@ function emitTriggers(triggers, ids, resolver) {
             // machinery as connector tasks and wait-for-connector bags.
             const bag = t.eventSubscription
                 ? resolvedSubscriptionBag('trigger', t.eventSubscription, resolver, triggerId, `Event trigger "${label}"`)
-                : { serviceType: CASE_FORMAT_PROFILE.eventServiceType };
+                : {
+                    serviceType: CASE_FORMAT_PROFILE.eventServiceType,
+                    // A placeholder that names its source object carries it the way
+                    // `case sdd convert` does: one `context[objectName]` row.
+                    ...(t.eventObject ? { context: [io('objectName', 'string', { value: t.eventObject })] } : {}),
+                };
             if (t.eventOutputs?.length) {
                 const outputs = t.eventOutputs.map((o) => {
                     const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
@@ -899,7 +904,7 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
         context.push(io('connection', 'string', { value: `=bindings.${connection.id}` }));
         context.push(io('resourceKey', 'string', { value: connection.resourceKey }));
     }
-    const folder = bindingRef(resolver, spec.folder, 'Connection', 'folderKey', 'FolderKey', { attribute: 'folder', where, target });
+    const folder = folderBindingRef(resolver, spec.folder, connection, { attribute: 'folder', where, target });
     if (folder)
         context.push(io('folderKey', 'string', { value: `=bindings.${folder.id}` }));
     context.push(io('method', 'string', {}), io('path', 'string', {}), io('objectName', 'string', { value: op.objectName ?? spec.event }), io('operation', 'string', { value: op.eventOperation ?? spec.event }), io('metadata', 'json', { body: subscriptionMetadata(rc, op, spec.filters ?? [], elementId) }));
@@ -1095,7 +1100,7 @@ function connectorTaskData(spec, resolver, elementId, where) {
         context.push(io('connection', 'string', { value: `=bindings.${connRef.id}` }));
         context.push(io('resourceKey', 'string', { value: connRef.resourceKey }));
     }
-    const folderRef = bindingRef(resolver, spec.folder, 'Connection', 'folderKey', 'FolderKey', { attribute: 'folder', where, target });
+    const folderRef = folderBindingRef(resolver, spec.folder, connRef, { attribute: 'folder', where, target });
     if (folderRef)
         context.push(io('folderKey', 'string', { value: `=bindings.${folderRef.id}` }));
     context.push(io('objectName', 'string', { value: op.objectName ?? spec.action }), io('method', 'string', { value: transportHttpMethod(rc.httpMethod) }), io('path', 'string', { value: rc.endpoint }), io('metadata', 'json', { body: connectorMetadata(rc, op) }));
@@ -1143,7 +1148,7 @@ function externalTaskData(kind, spec, resolver, where) {
         throw new Error(`${kind} task mode must be "sync" or "async".`);
     const target = { key: spec.connector.key, action: spec.connector.action };
     const connection = bindingRef(resolver, spec.connector.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`, { attribute: 'connection', where, target });
-    const folder = bindingRef(resolver, spec.connector.folder, 'Connection', 'folderKey', 'FolderKey', { attribute: 'folder', where, target });
+    const folder = folderBindingRef(resolver, spec.connector.folder, connection, { attribute: 'folder', where, target });
     if (!connection || !folder)
         throw new Error(`${kind} task requires non-empty connection and folder binding names.`);
     const serviceType = kind === 'external-agent'
@@ -1231,6 +1236,50 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
     }
     return { id, resourceKey };
 }
+/**
+ * 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 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.
+ */
+function folderBindingRef(resolver, name, connection, site) {
+    if (!connection)
+        return bindingRef(resolver, name, 'Connection', 'folderKey', 'FolderKey', site);
+    if (!name)
+        return undefined;
+    const refused = bindingLabelRefusal(resolver.bindings, name, site.attribute, site.where, site.target);
+    if (refused)
+        throw refused;
+    const entry = resolver.bindings?.entry(name);
+    const baseId = entry?.id ?? name;
+    const folderKey = entry?.default ?? entry?.resourceKey ?? name;
+    const matches = (row) => row?.resourceKey === connection.resourceKey && row?.default === folderKey
+        && row?.propertyAttribute === 'folderKey';
+    for (const row of resolver.bindingSink.values()) {
+        if (row.resourceKey === connection.resourceKey && row.propertyAttribute === 'folderKey'
+            && row.default !== folderKey)
+            throw new Error(`${site.where}: connection "${connection.resourceKey}" is bound to two folders: `
+                + `"${String(row.name)}" (${String(row.default)}) and "${name}" (${folderKey}). `
+                + `A connection lives in one folder; use the same folder binding for every task on it.`);
+    }
+    let id = baseId;
+    for (let n = 2; resolver.bindingSink.has(id) && !matches(resolver.bindingSink.get(id)); n++)
+        id = `${baseId}_${n}`;
+    if (!resolver.bindingSink.has(id)) {
+        resolver.bindingSink.set(id, {
+            id,
+            name: entry?.name ?? 'FolderKey',
+            type: 'string',
+            resource: 'Connection',
+            resourceKey: connection.resourceKey,
+            default: folderKey,
+            propertyAttribute: 'folderKey',
+        });
+    }
+    return { id };
+}
 /** The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
  * activityTypeId. Designer cosmetics (packageId/activityColor/…) are omitted —
  * the caseplan schema-validates without them (see design §C). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.32.5",
+  "version": "6.32.7",
   "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": "14ac2b3fba98100313a97094685f1e9b5bc3601a"
+  "gitref": "25920074d219f5839f57dd1e8ef96af291415168"
 }