@uipath/maestro-builder-sdk 6.31.0 → 6.31.2

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

@@ -8,6 +8,7 @@
  */
 import { Expr } from '../../../core/expr.js';
 import { jsonClone } from '../../../core/json-clone.js';
+import { isRecord } from '../../../core/node-envelope.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
 import { checkHttpRead, checkHttpStep, plainHttpOnErrorMessage } from './check.js';
 const PLAIN = 'core.action.http';
@@ -264,7 +265,7 @@ function liftHttp(node, ctx, managed) {
             return raw;
         return text.startsWith('=js:') ? ctx.expr(text) : text;
     };
-    const map = (m) => m && typeof m === 'object' && Object.keys(m).length
+    const map = (m) => isRecord(m) && Object.keys(m).length
         ? Object.fromEntries(Object.entries(m).map(([k, v]) => [k, value(v)]))
         : undefined;
     const text = (v) => (typeof v === 'string' ? v : undefined);

package/dist/nodes/queue/flow/check.d.ts

@@ -7,6 +7,19 @@ import type { FlowCheckContext } from '../../../flow-node-type.js';
 import type { QueueItemInputs } from './spec.js';
 /** Every code the family reports, with the severity it reports it at. */
 export declare const QUEUE_DIAGNOSTICS: DiagnosticCatalog;
+/**
+ * Whether a definition stores `inputs.itemData` as a JSON STRING — the 1.0 era.
+ * 1.1 and later declare an `object`. Read off the definition being emitted or
+ * lifted, not off a version number, so a carried definition of any era answers
+ * for itself.
+ */
+export declare function itemDataIsString(def: unknown): boolean;
+/**
+ * Why `item.<field>` cannot be an expression on a definition that stores the item
+ * as one JSON string. Shared by `check` (QUEUE_ITEM_EXPR_UNSUPPORTED) and the
+ * serializer's refusal, so the two say the same thing.
+ */
+export declare function queueItemExprMessage(step: string, typeName: string, version: string, field: string): string;
 /**
  * Check a `queueItem(...)` call.
  *
@@ -31,5 +44,7 @@ export declare const QUEUE_DIAGNOSTICS: DiagnosticCatalog;
  *  - `returns` on a step that does not wait (there is nothing per-tenant to
  *    declare), and a `wait: true` step whose result nothing can read.
  *  - a non-ISO `dueDate` / `deferDate`.
+ *  - an expression in `item` when the definition stores the item as one JSON
+ *    string (1.0): the serializer refuses it, so `check` reports it first.
  */
-export declare function checkQueueItem(inputs: QueueItemInputs | undefined, ctx: FlowCheckContext): void;
+export declare function checkQueueItem(inputs: QueueItemInputs | undefined, ctx: FlowCheckContext, typeName: string): void;

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

@@ -11,6 +11,7 @@ export const QUEUE_DIAGNOSTICS = {
     QUEUE_NO_ITEM: { severity: 'warning', summary: 'the item carries no data' },
     QUEUE_ITEM_NOT_OBJECT: { severity: 'error', summary: 'the item is not an object' },
     QUEUE_ITEM_FIELD_NOT_PRIMITIVE: { severity: 'error', summary: 'an item field is not a primitive' },
+    QUEUE_ITEM_EXPR_UNSUPPORTED: { severity: 'error', summary: 'an expression in an item stored as one JSON string' },
     QUEUE_BAD_PRIORITY: { severity: 'error', summary: 'a priority the node type does not offer' },
     QUEUE_BAD_DATE: { severity: 'error', summary: 'a date Orchestrator cannot read' },
     QUEUE_RETURNS_WITHOUT_WAIT: { severity: 'warning', summary: 'returns without wait: true' },
@@ -18,6 +19,27 @@ export const QUEUE_DIAGNOSTICS = {
     QUEUE_READ_WITHOUT_RETURNS: { severity: 'error', summary: 'a field read off a wait result with no returns' },
     QUEUE_READ_UNKNOWN_FIELD: { severity: 'error', summary: 'a read of a field the step does not publish' },
 };
+/**
+ * Whether a definition stores `inputs.itemData` as a JSON STRING — the 1.0 era.
+ * 1.1 and later declare an `object`. Read off the definition being emitted or
+ * lifted, not off a version number, so a carried definition of any era answers
+ * for itself.
+ */
+export function itemDataIsString(def) {
+    const props = def
+        ?.inputDefinition?.properties;
+    return props?.itemData?.type === 'string';
+}
+/**
+ * Why `item.<field>` cannot be an expression on a definition that stores the item
+ * as one JSON string. Shared by `check` (QUEUE_ITEM_EXPR_UNSUPPORTED) and the
+ * serializer's refusal, so the two say the same thing.
+ */
+export function queueItemExprMessage(step, typeName, version, field) {
+    return `Queue step "${step}": ${typeName}@${version} stores the item as one JSON string, so \`item.${field}\` `
+        + `cannot be an expression there. Omit the { version } to emit the SDK's default version, which `
+        + `stores the item as an object of values and expressions.`;
+}
 /**
  * Check a `queueItem(...)` call.
  *
@@ -42,8 +64,10 @@ export const QUEUE_DIAGNOSTICS = {
  *  - `returns` on a step that does not wait (there is nothing per-tenant to
  *    declare), and a `wait: true` step whose result nothing can read.
  *  - a non-ISO `dueDate` / `deferDate`.
+ *  - an expression in `item` when the definition stores the item as one JSON
+ *    string (1.0): the serializer refuses it, so `check` reports it first.
  */
-export function checkQueueItem(inputs, ctx) {
+export function checkQueueItem(inputs, ctx, typeName) {
     const step = ctx.step;
     // Severity is the catalog's (QUEUE_DIAGNOSTICS): `at` and `warn` name the intent.
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
@@ -83,7 +107,12 @@ export function checkQueueItem(inputs, ctx) {
             + `item's \`SpecificContent\`.`, `item: { InvoiceId: 'INV-1', Amount: 120 }`);
     }
     else {
+        const itemIsString = itemDataIsString(ctx.definition());
         for (const [k, v] of Object.entries(item)) {
+            if (v instanceof Expr && itemIsString) {
+                at('QUEUE_ITEM_EXPR_UNSUPPORTED', queueItemExprMessage(step, typeName, ctx.version, k));
+                continue;
+            }
             // An Expr is a reference the runtime resolves — its VALUE may be anything,
             // and nothing local can know, so it is not flagged here.
             if (v instanceof Expr)

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

@@ -1,6 +1,7 @@
 import { Expr } from '../../../core/expr.js';
 import { jsonClone } from '../../../core/json-clone.js';
-import { checkQueueItem } from './check.js';
+import { isRecord } from '../../../core/node-envelope.js';
+import { checkQueueItem, itemDataIsString, queueItemExprMessage } from './check.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './record.js';
 const CREATE = 'core.action.queue.create';
 const CREATE_AND_WAIT = 'core.action.queue.create-and-wait';
@@ -159,6 +160,87 @@ function liftReturns(node) {
         .map(([k, v]) => [k, v.type]);
     return entries.length ? Object.fromEntries(entries) : undefined;
 }
+/**
+ * The surface's `item` as a 1.0 node stores it: one JSON string, `''` for no
+ * data (the 1.0 definition's own default). A JSON string holds DATA, so an
+ * expression in a field has no spelling there; it is refused rather than
+ * written as text the runtime would never evaluate.
+ */
+function itemDataString(item, step, typeName, version) {
+    const rows = Object.entries(item);
+    if (rows.length === 0)
+        return '';
+    for (const [k, v] of rows) {
+        if (v instanceof Expr)
+            throw new Error(queueItemExprMessage(step, typeName, version, k));
+    }
+    return JSON.stringify(item);
+}
+/** Whether `v` is, or holds at any depth, an integer JSON.parse could not represent exactly. */
+function hasUnsafeInteger(v) {
+    if (typeof v === 'number')
+        return Number.isInteger(v) && !Number.isSafeInteger(v);
+    if (Array.isArray(v))
+        return v.some(hasUnsafeInteger);
+    return isRecord(v) && Object.values(v).some(hasUnsafeInteger);
+}
+/**
+ * `inputs.itemData` back as the surface's `item`, in either wire shape:
+ *
+ *  - 1.1 and later: an object of field → value, each value as the author wrote it
+ *    (`=js:` text back to an Expr);
+ *  - 1.0: ONE JSON STRING (`"{\"invoiceId\":\"INV-1001\"}"`), which is parsed back
+ *    to the object it encodes; `''` is the 1.0 default, no data.
+ *
+ * `undefined`, with a warning, for a value `item` cannot hold without changing
+ * what the node does — a whole-item expression, a string that is not a JSON
+ * object, an integer beyond 2^53 (parsing rounds it), or a JSON field whose
+ * text starts with `=` (literal data at 1.0; it would become an expression once
+ * written as an object). The lift then
+ * declines the node and decompile keeps it as a `rawNode`, verbatim.
+ *
+ * Reading the shape off the value, never assuming it, is the point: treating
+ * the 1.0 string as an object spread it into one field per character
+ * (flow-builder-sdk#1164).
+ */
+function liftItem(raw, ctx, value) {
+    const decline = (why) => {
+        ctx.warn(`node ${JSON.stringify(ctx.nodeId)}: its queue item data (inputs.itemData) is ${why}, which \`queueItem({ item })\` `
+            + `cannot hold without changing it, so the source keeps the node as a rawNode, verbatim.`);
+        return undefined;
+    };
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw === 'string') {
+        if (raw === '')
+            return {};
+        if (raw.startsWith('='))
+            return decline('an expression for the whole item');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return decline('a string that is not JSON');
+        }
+        if (!isRecord(parsed))
+            return decline('a JSON string that does not encode an object');
+        const expressionLike = Object.keys(parsed).find((k) => typeof parsed[k] === 'string' && parsed[k].startsWith('='));
+        if (expressionLike !== undefined)
+            return decline(`a JSON string whose field "${expressionLike}" starts with "="`);
+        // JSON.parse rounds an integer beyond 2^53 (`12345678901234567890` reads back
+        // as `12345678901234567000`), and the compile would write the rounded value.
+        const rounded = Object.keys(parsed).find((k) => hasUnsafeInteger(parsed[k]));
+        if (rounded !== undefined)
+            return decline(`a JSON string whose field "${rounded}" holds an integer too large to read back exactly`);
+        return parsed;
+    }
+    if (ctx.sourceText(raw) !== undefined)
+        return decline('an expression for the whole item');
+    if (!isRecord(raw))
+        return decline(Array.isArray(raw) ? 'an array' : `a ${typeof raw}`);
+    return Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, value(v)]));
+}
 function queueAt(typeName, wait) {
     return {
         kind: 'queueItem', typeName, version: '1.2', factory: 'queueItem', definition: 'per-tenant', errorPort: true,
@@ -169,7 +251,8 @@ function queueAt(typeName, wait) {
             const { ids, entries } = queueItemBindings(s, ctx.bindings);
             for (const b of entries)
                 ctx.bind(b);
-            const manifest = queueItemDef(s, typeName, ctx.step, ids, ctx.definition(typeName, ctx.version));
+            const base = ctx.definition(typeName, ctx.version);
+            const manifest = queueItemDef(s, typeName, ctx.step, ids, base);
             return {
                 definition: { source: 'snapshot', nodeType: typeName, version: ctx.version, manifest },
                 // The result is read as `$vars.<step>.output`, like every other family: the
@@ -180,8 +263,11 @@ function queueAt(typeName, wait) {
                 inputs: {
                     queue: { name: s.queue, folderPath: s.folderPath, key: s.key },
                     // `itemData`, not `item`: the surface's name is friendlier, the node's is
-                    // the platform's. Rendered one level deep, as the item is FLAT.
-                    itemData: Object.fromEntries(Object.entries(s.item ?? {}).map(([k, v]) => [k, ctx.render(v)])),
+                    // the platform's. Rendered one level deep, as the item is FLAT — or, for a
+                    // definition of the 1.0 era, encoded as the one JSON string it declares.
+                    itemData: itemDataIsString(base)
+                        ? itemDataString(s.item ?? {}, ctx.step, typeName, ctx.version)
+                        : Object.fromEntries(Object.entries(s.item ?? {}).map(([k, v]) => [k, ctx.render(v)])),
                     priority: s.priority ?? 'Normal',
                     reference: s.reference === undefined ? '' : ctx.render(s.reference),
                     deferDate: s.deferDate === undefined ? '' : ctx.render(s.deferDate),
@@ -209,12 +295,14 @@ function queueAt(typeName, wait) {
             // A wait's `returns` is the schema serialize wrote for THIS step (the
             // template ships none), as the node's own `outputs` carries it.
             const returns = wait ? liftReturns(node) : undefined;
+            const item = liftItem(inputs.itemData, ctx, value);
+            if (item === undefined)
+                return undefined;
             return {
                 kind: 'queueItem',
                 inputs: {
                     queue: q.name, folderPath: q.folderPath, key: q.key,
-                    item: Object.fromEntries(Object.entries((inputs.itemData ?? {}))
-                        .map(([k, v]) => [k, value(v)])),
+                    item,
                     ...(typeof priority === 'string' ? { priority: priority } : {}),
                     ...(optional(inputs.reference) !== undefined ? { reference: optional(inputs.reference) } : {}),
                     ...(optional(inputs.deferDate) !== undefined ? { deferDate: optional(inputs.deferDate) } : {}),
@@ -249,7 +337,7 @@ function queueAt(typeName, wait) {
                 ],
             };
         },
-        check: ({ inputs }, ctx) => checkQueueItem(inputs, ctx),
+        check: ({ inputs }, ctx) => checkQueueItem(inputs, ctx, typeName),
         // check collected no expressions for a queue step before the port; unchanged by it.
         expressions: () => [],
         output: ({ inputs }) => queueOutput(inputs, wait),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.31.0",
+  "version": "6.31.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -62,6 +62,7 @@
   ],
   "files": [
     "dist",
+    "!dist/api.model.json",
     "lib/library-json.samples",
     "README.md"
   ],
@@ -92,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "21719d7a1fd422a6886d9021c02cf2f124c4f627"
+  "gitref": "37b4b349e7ce452d74154e65bdae4dff9a1aeb93"
 }