@uipath/maestro-builder-sdk 6.52.2 → 6.53.1

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

@@ -381,8 +381,13 @@ export interface BuiltCaseExitCondition {
     rules: CaseRule[][];
 }
 export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'function' | 'business-rule' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
-/** Published-resource task kinds that the Case schema permits as unresolved skeletons. */
-export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'function';
+/**
+ * Task kinds that the Case schema permits as unresolved skeletons: the
+ * published-resource kinds, and `action` (a human task whose Action App or form
+ * is not known yet). Each compiles to a task whose `data` is `{}`, which
+ * `uip maestro case validate` reports as a `TASK_NOT_CONFIGURED` warning.
+ */
+export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'function' | 'action';
 /**
  * A `wait-for-connector` subscription: suspend on an Integration Service event.
  * Omit `connectorKey`/`operation` for a bare **placeholder** (for a connector not
@@ -853,15 +858,18 @@ declare class TaskBuilder {
         folder?: string;
     }): this;
     /**
-     * Preserve an explicitly unresolved published-resource task as a typed
-     * skeleton whose serialized `data` is `{}`.
+     * Preserve an explicitly unresolved task as a typed skeleton whose serialized
+     * `data` is `{}`.
      *
      * @remarks
      * Use this only when the requested resource identity cannot be resolved.
      * Do not invent a name or folder. An unresolved task cannot declare input or
      * output bindings because there is no referenced contract to bind against.
+     * `unresolved('action')` is the human-task skeleton: no Action App, title,
+     * recipient or form fields, for an app that is not published yet. Use
+     * `.action({ ... })` instead once the form is known.
      *
-     * @param kind - The published-resource family to preserve.
+     * @param kind - The task kind to preserve: a published-resource family, or `'action'` for a human task.
      * @returns This builder, so calls chain.
      */
     unresolved(kind: UnresolvedReferenceTaskKind): this;

package/dist/case/case-sdk.js

@@ -197,15 +197,18 @@ class TaskBuilder {
         return this.reference('process', name, opts);
     }
     /**
-     * Preserve an explicitly unresolved published-resource task as a typed
-     * skeleton whose serialized `data` is `{}`.
+     * Preserve an explicitly unresolved task as a typed skeleton whose serialized
+     * `data` is `{}`.
      *
      * @remarks
      * Use this only when the requested resource identity cannot be resolved.
      * Do not invent a name or folder. An unresolved task cannot declare input or
      * output bindings because there is no referenced contract to bind against.
+     * `unresolved('action')` is the human-task skeleton: no Action App, title,
+     * recipient or form fields, for an app that is not published yet. Use
+     * `.action({ ... })` instead once the form is known.
      *
-     * @param kind - The published-resource family to preserve.
+     * @param kind - The task kind to preserve: a published-resource family, or `'action'` for a human task.
      * @returns This builder, so calls chain.
      */
     unresolved(kind) {

package/dist/case/decompile.js

@@ -708,6 +708,11 @@ function emitTaskKind(task, refs, library) {
     if (isAuthorableBusinessRule(task))
         return businessRuleCall(task, refs);
     if (kind === 'action') {
+        // The skeleton human task (v1's placeholder, validate's TASK_NOT_CONFIGURED):
+        // nothing configured, so `.action({})` would recompile with a default
+        // `priority` the source never had.
+        if (Object.keys(data).length === 0)
+            return `.unresolved(${tsLiteral('action')})`;
         let recipient;
         if (data.recipient) {
             const type = Number(data.recipient.Type);

package/dist/case/serialize.js

@@ -27,6 +27,7 @@ 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 { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 /**
  * Condition `displayName` allocator.
@@ -962,6 +963,11 @@ function taskData(task, resolver, taskId, stageId, ids) {
         case 'business-rule':
             return businessRuleTaskData(task, resolver, `${stageId}-${taskId}`, ids);
         case 'action': {
+            // `.unresolved('action')`: the skeleton human task, `data: {}` like an
+            // unresolved resource task (validate warns TASK_NOT_CONFIGURED). `.action()`
+            // always sets `task.action`, so only the skeleton reaches here without one.
+            if (!task.action && !task.ref)
+                return {};
             const a = task.action ?? {};
             const data = {};
             if (a.title)
@@ -1749,7 +1755,7 @@ const ERROR_OUTPUT_SCHEMA = {
 };
 function connectorOutputs(rc, elementId, resolver) {
     const responseSchema = rc.entry.outputSchema
-        ? schemaFromFields(rc.entry.outputSchema.fields ?? [])
+        ? responseJsonSchema(rc.entry.outputSchema.fields ?? [])
         : { type: 'object', properties: {} };
     const responseVar = connectorOutputVar(resolver, 'response');
     const errorVar = connectorOutputVar(resolver, 'Error');
@@ -1766,29 +1772,6 @@ function connectorOutputs(rc, elementId, resolver) {
         },
     ];
 }
-/** A minimal JSON-schema `{type:object, properties}` from library output fields. */
-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';
-    }
-}
 /** snake_case → camelCase (the caseplan camelCases declared param names). */
 function toCamel(s) {
     return s.replace(/_([a-z0-9])/gi, (_m, c) => String(c).toUpperCase());

package/dist/core/connector-response-schema.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The JSON Schema of a connector activity's `response`, built from the
+ * library's flat output fields.
+ *
+ * The connector library lists an operation's output as flat leaf fields with
+ * dotted paths (`message.bot_profile.icons.image_36`, `blocks[*].text.type`);
+ * it carries no nested schema. Studio Web writes the response as a NESTED JSON
+ * Schema, with one `definitions` entry per object on a path and `$ref`s to them
+ * (`fieldsContainer.outputJsonSchema`, written into `output.body` by
+ * `getIntsvcOutputJsonSchema`), and `uip maestro case spec` returns the same
+ * shape. Writing each leaf as a top-level key instead gave Slack
+ * `send-message-to-channel` 102 dotted keys where the contract has 13 top-level
+ * properties (builder-sdk#1423).
+ *
+ * This is a port of the CLI's `buildResponseJsonSchema`
+ * (`UiPath/cli` `packages/maestro-sdk/src/connector-spec/connector-task-spec.ts`),
+ * which mirrors the Studio Web front end:
+ *
+ * - a one-segment field (`ts`) is a top-level property;
+ * - a one-segment array (`reply_users[*]`) is a top-level array of primitives;
+ * - a dotted path walks through definitions: `message.bot_profile.icons.x`
+ *   makes property `message` → `$ref` `message`, whose property `bot_profile`
+ *   → `$ref` `messageBot_profile`, whose property `icons` → `$ref`
+ *   `messageBot_profileIcons`, which holds the leaf `x`;
+ * - an array segment (`attendees[*].…`) is an array whose `items` `$ref` the
+ *   definition.
+ *
+ * A definition name is the first segment, then each deeper segment with its
+ * first letter upper-cased, concatenated (`[*]` and `_` kept). Leaf types are
+ * the library's own (`integer` stays `integer`), as the CLI and Studio Web
+ * write them.
+ */
+/** One library output field: a dotted path, its type and its display name. */
+export interface ResponseField {
+    name?: unknown;
+    type?: unknown;
+    displayName?: unknown;
+}
+/** The nested response schema: `type`, `properties` and `definitions` (no `$schema`; the caller adds it). */
+export interface ResponseJsonSchema {
+    type: 'object';
+    properties: Record<string, unknown>;
+    definitions: Record<string, {
+        type: 'object';
+        properties: Record<string, unknown>;
+    }>;
+}
+/**
+ * Build the nested response schema from the library's flat output fields.
+ *
+ * @param fields - The operation's `outputSchema.fields`, in library order.
+ * @returns `{ type: 'object', properties, definitions }`.
+ */
+export declare function responseJsonSchema(fields: readonly ResponseField[]): ResponseJsonSchema;

package/dist/core/connector-response-schema.js

@@ -0,0 +1,107 @@
+/**
+ * The JSON Schema of a connector activity's `response`, built from the
+ * library's flat output fields.
+ *
+ * The connector library lists an operation's output as flat leaf fields with
+ * dotted paths (`message.bot_profile.icons.image_36`, `blocks[*].text.type`);
+ * it carries no nested schema. Studio Web writes the response as a NESTED JSON
+ * Schema, with one `definitions` entry per object on a path and `$ref`s to them
+ * (`fieldsContainer.outputJsonSchema`, written into `output.body` by
+ * `getIntsvcOutputJsonSchema`), and `uip maestro case spec` returns the same
+ * shape. Writing each leaf as a top-level key instead gave Slack
+ * `send-message-to-channel` 102 dotted keys where the contract has 13 top-level
+ * properties (builder-sdk#1423).
+ *
+ * This is a port of the CLI's `buildResponseJsonSchema`
+ * (`UiPath/cli` `packages/maestro-sdk/src/connector-spec/connector-task-spec.ts`),
+ * which mirrors the Studio Web front end:
+ *
+ * - a one-segment field (`ts`) is a top-level property;
+ * - a one-segment array (`reply_users[*]`) is a top-level array of primitives;
+ * - a dotted path walks through definitions: `message.bot_profile.icons.x`
+ *   makes property `message` → `$ref` `message`, whose property `bot_profile`
+ *   → `$ref` `messageBot_profile`, whose property `icons` → `$ref`
+ *   `messageBot_profileIcons`, which holds the leaf `x`;
+ * - an array segment (`attendees[*].…`) is an array whose `items` `$ref` the
+ *   definition.
+ *
+ * A definition name is the first segment, then each deeper segment with its
+ * first letter upper-cased, concatenated (`[*]` and `_` kept). Leaf types are
+ * the library's own (`integer` stays `integer`), as the CLI and Studio Web
+ * write them.
+ */
+/**
+ * Build the nested response schema from the library's flat output fields.
+ *
+ * @param fields - The operation's `outputSchema.fields`, in library order.
+ * @returns `{ type: 'object', properties, definitions }`.
+ */
+export function responseJsonSchema(fields) {
+    const properties = {};
+    const definitions = {};
+    for (const field of fields) {
+        if (typeof field?.name !== 'string' || !field.name)
+            continue;
+        insertField(field.name, field, properties, definitions);
+    }
+    return { type: 'object', properties, definitions };
+}
+function insertField(path, field, properties, definitions) {
+    const segments = path.split('.');
+    let current = properties;
+    let defName = '';
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        defName = i === 0 ? segment : defName + capitalize(segment);
+        // Own-key test: a definition named like an Object.prototype member
+        // (`constructor`) must not read the prototype's.
+        if (!Object.prototype.hasOwnProperty.call(definitions, defName)) {
+            definitions[defName] = { type: 'object', properties: {} };
+            current[segment] = refTo(segment, defName);
+        }
+        current = definitions[defName].properties;
+    }
+    const leaf = segments[segments.length - 1];
+    current[leaf] = leafSchema(leaf, field);
+}
+function leafSchema(segment, field) {
+    const title = typeof field.displayName === 'string' ? field.displayName : humanize(segment);
+    const type = schemaType(field.type);
+    // An array of primitives: `reply_users[*]` at the leaf.
+    if (segment.endsWith('[*]'))
+        return { title, type: 'array', items: { type } };
+    return { title, type };
+}
+/**
+ * A library field type as a JSON Schema type. The library's types are JSON
+ * Schema's own (`string`, `integer`, `object`, …) except `octet-stream`, which
+ * 77 file-download fields carry (ServiceNow `download-attachment`
+ * `fileDownload`). That is not a schema type, so it is written `string`, as the
+ * old flat builder wrote it. The CLI never meets it: it gives a file response
+ * its own file schema before this builder runs.
+ */
+function schemaType(type) {
+    return type === 'octet-stream' ? 'string' : type;
+}
+function refTo(segment, defName) {
+    // An array of objects: `attendees[*].…` is an array whose items `$ref` the definition.
+    if (segment.endsWith('[*]'))
+        return { title: humanize(segment), type: 'array', items: { $ref: `#/definitions/${defName}` } };
+    return { title: humanize(segment), $ref: `#/definitions/${defName}` };
+}
+/** Upper-case the first letter, for definition-name compounding (`[*]` kept). */
+function capitalize(segment) {
+    return segment ? segment.charAt(0).toUpperCase() + segment.slice(1) : segment;
+}
+/**
+ * The front end's title for an intermediate segment: `[*]` dropped, camelCase
+ * split into words, sentence case (`emailAddress` → `Email address`,
+ * `bot_profile` → `Bot_profile`).
+ */
+function humanize(segment) {
+    const clean = segment.replace(/\[\*\]/g, '');
+    if (!clean)
+        return '';
+    const spaced = clean.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.52.2",
+  "version": "6.53.1",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -96,5 +96,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "410164517bc2552666c867e9107b2cbb57acd083"
+  "gitref": "19cae12b584be7d3ae29f393942b36c474217a81"
 }