@uipath/maestro-builder-sdk 5.2.0

package/dist/case/preserve.js

@@ -0,0 +1,105 @@
+const preserved = new WeakMap();
+/** Attach decompiler-owned, non-authoring wire data to a built case. */
+export function preserveCaseJson(built, payload) {
+    preserved.set(built, payload);
+    return built;
+}
+/** @internal Read the preservation payload attached by `preserveCaseJson`. */
+export function caseJsonPreservation(built) {
+    return preserved.get(built);
+}
+const TOP_LEVEL_KEYS = new Set([
+    'id', 'name', 'description', 'version', 'bindings', 'variables', 'metadata', 'nodes', 'edges', 'layout',
+]);
+const METADATA_KEYS = new Set([
+    'caseIdentifier', 'caseIdentifierType', 'caseAppEnabled', 'publishVersion', 'caseExitRules', 'slaRules',
+    'caseAppConfig', 'adhocCaseEndData',
+    'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector',
+]);
+const VARIABLE_KEYS = new Set([
+    'id', 'name', 'type', 'default', 'body', '_jsonSchema', 'elementId', 'var',
+]);
+const TASK_KEYS = new Set([
+    'id', 'displayName', 'type', 'data', 'shouldRunOnlyOnce', 'isRequired', 'skipCondition', 'description',
+    'entryConditions', 'conditions', 'nonSequentialRunConditions',
+]);
+const TRIGGER_DATA_KEYS = new Set(['label', 'description', 'uipath', 'display', 'inputs', 'typeVersion']);
+const PRESERVED_TASK_KEYS = new Set(['elementId']);
+const PRESERVED_TRIGGER_DATA_KEYS = new Set(['parentElement', 'isInvalidDropTarget', 'isPendingParent']);
+const PRESERVED_VARIABLE_KEYS = new Set(['subType', 'canonicalId', 'camelizedId', 'variableType', 'internal']);
+const PRESERVED_CASE_APP_CONFIG_KEYS = new Set(['stageOrder', 'hiddenStageIds']);
+const PRESERVED_CASE_APP_SECTION_KEYS = new Set(['error', 'titleError']);
+/** @internal Validate that preservation cannot impersonate typed authoring. */
+export function caseJsonPreservationErrors(payload) {
+    if (!payload)
+        return [];
+    const errors = [];
+    for (const name of Object.keys(payload.topLevel ?? {}))
+        if (TOP_LEVEL_KEYS.has(name))
+            errors.push(`top-level key "${name}" is owned by the typed Case serializer`);
+    for (const name of Object.keys(payload.metadata ?? {}))
+        if (METADATA_KEYS.has(name))
+            errors.push(`metadata key "${name}" is owned by the typed Case serializer`);
+    for (const name of Object.keys(payload.caseAppConfigFields?.fields ?? {}))
+        if (!PRESERVED_CASE_APP_CONFIG_KEYS.has(name))
+            errors.push(`caseAppConfig field "${name}" is not an allowed preserved platform field`);
+    for (const section of payload.caseAppConfigFields?.sections ?? []) {
+        if (typeof section.id !== 'string' || !section.id)
+            errors.push('preserved Case App section id must be a non-empty string');
+        for (const name of Object.keys(section.fields))
+            if (!PRESERVED_CASE_APP_SECTION_KEYS.has(name))
+                errors.push(`Case App section "${section.id}" field "${name}" is not an allowed preserved platform field`);
+    }
+    for (const preservedNode of payload.nodes ?? []) {
+        const type = String(preservedNode.node.type ?? '');
+        if (type !== 'case-management:StickyNote')
+            errors.push(`node type "${type || '(missing)'}" is not an allowed preserved annotation`);
+        if (!Number.isInteger(preservedNode.index) || preservedNode.index < 0)
+            errors.push(`preserved node index "${preservedNode.index}" is not a non-negative integer`);
+    }
+    for (const [lane, rows] of Object.entries(payload.variableFields ?? {})) {
+        if (!['inputs', 'outputs', 'inputOutputs'].includes(lane)) {
+            errors.push(`variable lane "${lane}" is not recognized`);
+            continue;
+        }
+        for (const [name, fields] of Object.entries(rows ?? {}))
+            for (const field of Object.keys(fields))
+                if (!PRESERVED_VARIABLE_KEYS.has(field)
+                    && !(lane === 'inputOutputs' && (field === 'default' || field === 'custom'))
+                    && !(lane === 'outputs' && field === 'var'))
+                    errors.push(`variable "${name}" field "${field}" is not an allowed preserved designer field`);
+                else if (VARIABLE_KEYS.has(field)
+                    && !(lane === 'inputOutputs' && field === 'default')
+                    && !(lane === 'outputs' && field === 'var'))
+                    errors.push(`variable "${name}" field "${field}" is owned by the typed Case serializer`);
+    }
+    for (const [lane, rows] of Object.entries(payload.legacyVariableDefaults ?? {})) {
+        if (!['inputs', 'outputs', 'inputOutputs'].includes(lane)) {
+            errors.push(`legacy variable-default lane "${lane}" is not recognized`);
+            continue;
+        }
+        for (const [name, value] of Object.entries(rows ?? {})) {
+            if (typeof value === 'string' || value === undefined || JSON.stringify(value) === undefined)
+                errors.push(`legacy variable default "${name}" must be a JSON-encodable non-string value`);
+        }
+    }
+    for (const entry of payload.omitTaskElementIds ?? [])
+        if (!Number.isInteger(entry.lane) || entry.lane < 0)
+            errors.push(`omitted-elementId task lane "${entry.lane}" is not a non-negative integer`);
+    for (const entry of payload.taskFields ?? []) {
+        if (!Number.isInteger(entry.lane) || entry.lane < 0)
+            errors.push(`preserved task lane "${entry.lane}" is not a non-negative integer`);
+        for (const field of Object.keys(entry.fields))
+            if (!PRESERVED_TASK_KEYS.has(field))
+                errors.push(`task "${entry.task}" field "${field}" is not allowed in the preservation channel`);
+            else if (TASK_KEYS.has(field))
+                errors.push(`task "${entry.task}" field "${field}" is owned by the typed Case serializer`);
+    }
+    for (const [index, fields] of (payload.triggerDataFields ?? []).entries())
+        for (const field of Object.keys(fields))
+            if (!PRESERVED_TRIGGER_DATA_KEYS.has(field))
+                errors.push(`trigger ${index + 1} data field "${field}" is not allowed in the preservation channel`);
+            else if (TRIGGER_DATA_KEYS.has(field))
+                errors.push(`trigger ${index + 1} data field "${field}" is owned by the typed Case serializer`);
+    return errors;
+}

package/dist/case/serialize.d.ts

@@ -0,0 +1,10 @@
+import { Library } from '../core/library.js';
+import { Bindings } from '../core/bindings.js';
+import type { BuiltCase } from './case-sdk.js';
+/** Optional wiring for connector tasks — the library that resolves a connector
+ * op, and the bindings that map its symbolic connection/folder to resources. */
+export interface CaseSerializeOpts {
+    library?: Library;
+    bindings?: Bindings;
+}
+export declare function serialize(built: BuiltCase, opts?: CaseSerializeOpts): Record<string, unknown>;