@uipath/maestro-builder-sdk 6.58.0 → 6.59.0

package/dist/merge.js

@@ -95,119 +95,8 @@ import { placeAddedNodes } from './node-placement.js';
 import { mergeAgentSidecars } from './merge-sidecars.js';
 import { embeddedAgentFindings, isEmbeddedAgent, mergeEmbeddedAgentNode } from './merge-embedded-agent.js';
 import { mergeObject, mergeVariables, stableJson } from './merge-variables.js';
+import { byId, isKept, nodeUnchanged, subflowsTakenFromEdited } from './edit-scope.js';
 export { MergeRefusedError } from './merge-roundtrip.js';
-function byId(nodes) {
-    return new Map((nodes ?? []).map((n) => [n.id, n]));
-}
-/**
- * Whether two nodes are the SAME as far as the author is concerned — same type,
- * same inputs and same output mappings. Layout (`ui`), `display`, `typeVersion`,
- * and the derived parts of `outputs` (type, schema, description) are ignored,
- * because those are exactly the parts decompile does not carry through. An
- * output's `source` is authored, not derived: it is what an End returns, so an
- * edit to `.return({ ... })` changes nothing else on the node. Used only to
- * decide "did the user edit this node?" against the baseline.
- */
-function nodeUnchanged(a, b) {
-    if (!a || !b)
-        return false;
-    if (a.type !== b.type)
-        return false;
-    return JSON.stringify(a.inputs ?? {}) === JSON.stringify(b.inputs ?? {})
-        && JSON.stringify(outputSources(a)) === JSON.stringify(outputSources(b));
-}
-/** Each output's `source` by output name; outputs without one are left out. */
-function outputSources(n) {
-    const sources = {};
-    for (const [name, output] of Object.entries(n.outputs ?? {})) {
-        if (output && typeof output === 'object' && 'source' in output)
-            sources[name] = output.source;
-    }
-    return sources;
-}
-/**
- * The ids of the root nodes {@link mergeFlow} takes from `edited` rather than
- * restoring from `original`: every node that is new, or that differs from its
- * `baseline` counterpart. With no baseline, that is every node.
- *
- * For instance, with a baseline equal to `edited` and every node present in
- * `original`, the answer is `[]` — a no-edit merge keeps them all.
- */
-export function nodesTakenFromEdited(original, edited, baseline) {
-    const origNodes = byId(original.nodes);
-    const baseNodes = byId(baseline?.nodes);
-    return (edited.nodes ?? []).filter((e) => !isKept(e, origNodes, baseNodes, baseline)).map((e) => e.id);
-}
-/**
- * The keys of the subflows {@link mergeFlow} takes from `edited` rather than
- * restoring from `original`: every subflow that is new, that the original does
- * not have, or that differs from its `baseline` counterpart in any way the
- * author can edit — a node's inputs, output sources or label, an edge, the
- * scope's `variables` or `layout` (`subflowUnchanged`, #1322). With no
- * baseline, that is every subflow. A kept subflow is the original's whole: its
- * nodes, edges, variables and layout.
- */
-export function subflowsTakenFromEdited(original, edited, baseline) {
-    return Object.keys(edited.subflows ?? {}).filter((key) => {
-        const orig = original.subflows?.[key];
-        const base = baseline?.subflows?.[key];
-        return !baseline || orig === undefined || base === undefined
-            || !subflowUnchanged(edited.subflows[key], base);
-    });
-}
-/** A node's canvas label, when it has one. */
-const labelOf = (n) => n?.display?.label;
-/**
- * Whether an edited subflow equals its baseline: the same node ids, each node
- * unchanged (`nodeUnchanged`) and under the same label, the same edges by
- * their endpoints and handles (ids are compile's own), and the same
- * `variables` and `layout` byte for byte. The scope's variables carry what the
- * nodes do not — a step's `{ updates }` row, a child `.input()` type, a `.var()`
- * default — and a kept subflow is the original's whole, so any of them changing
- * has to make the subflow a taken one.
- */
-function subflowUnchanged(e, b) {
-    const eNodes = byId(e.nodes);
-    const bNodes = byId(b.nodes);
-    if (eNodes.size !== bNodes.size)
-        return false;
-    for (const [id, n] of eNodes) {
-        const base = bNodes.get(id);
-        if (!nodeUnchanged(n, base) || labelOf(n) !== labelOf(base))
-            return false;
-    }
-    if (JSON.stringify(e.variables ?? null) !== JSON.stringify(b.variables ?? null))
-        return false;
-    // `layout.edges` is keyed by edge id, and ids come from one file-wide
-    // counter: a step added before the call shifts every id in the subflow
-    // without touching it. So routes are compared by the endpoints the id names
-    // (as the edges themselves are), and `layout.nodes` as it is.
-    if (JSON.stringify(layoutByEndpoints(e)) !== JSON.stringify(layoutByEndpoints(b)))
-        return false;
-    const eEdges = (e.edges ?? []).map(edgeKey).sort();
-    const bEdges = (b.edges ?? []).map(edgeKey).sort();
-    return eEdges.length === bEdges.length && eEdges.every((k, i) => k === bEdges[i]);
-}
-/** `<source>@<port>-><target>@<port>`: an edge's identity apart from its id. */
-const edgeKey = (x) => `${x.sourceNodeId}@${x.sourcePort}->${x.targetNodeId}@${x.targetPort}`;
-/** A scope's layout with its `edges` re-keyed by endpoints, so an id shift does not read as a change. */
-function layoutByEndpoints(sf) {
-    const layout = sf.layout;
-    if (!layout || typeof layout !== 'object')
-        return layout ?? null;
-    const byId = new Map((sf.edges ?? []).map((x) => [x.id, edgeKey(x)]));
-    const { edges, ...rest } = layout;
-    const routes = Object.entries(edges ?? {}).map(([id, route]) => [byId.get(id) ?? id, route]).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-    return { ...rest, edges: Object.fromEntries(routes) };
-}
-/**
- * Whether merge restores `e`'s ORIGINAL node instead of taking `e`: there is a
- * baseline, the original has the node, and `e` equals its baseline counterpart.
- * {@link mergeFlow}'s node loop and {@link nodesTakenFromEdited} both ask this.
- */
-function isKept(e, origNodes, baseNodes, baseline) {
-    return !!baseline && origNodes.has(e.id) && nodeUnchanged(e, baseNodes.get(e.id));
-}
 /**
  * Give an edited node the original's position, by id.
  *

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

@@ -42,6 +42,9 @@ export const PROCESS_DIAGNOSTICS = {
     APIWF_READ_WITHOUT_RETURNS: { severity: 'error', summary: 'an API workflow step field read with no returns' },
     FUNCTION_EMPTY_RETURNS: { severity: 'warning', summary: 'a function step with returns: {}' },
     FUNCTION_KEY_NOT_KEY: { severity: 'error', summary: 'a function step whose key is not a GUID' },
+    FUNCTION_LOCAL_HAS_FOLDER: { severity: 'error', summary: 'a function step in-solution, with a folderPath' },
+    FUNCTION_LOCAL_NO_PROJECT_ID: { severity: 'error', summary: 'a function step in-solution, with no projectId' },
+    FUNCTION_LOCAL_PROJECT_ID_NOT_GUID: { severity: 'error', summary: 'a function step in-solution, with a projectId that is not a GUID' },
     FUNCTION_NAME_IS_PATH: { severity: 'error', summary: 'a function step whose name looks like a folder path' },
     FUNCTION_NO_FOLDER: { severity: 'error', summary: 'a function step with no folderPath' },
     FUNCTION_NO_KEY: { severity: 'error', summary: 'a function step with no key' },
@@ -220,10 +223,26 @@ export function checkPublishedFunction(inputs, ctx) {
         at('FUNCTION_NO_NAME', `Function step "${step}" has no \`name\`. The runtime resolves the function by name + folder, not by the `
             + `key in the node type, so without it the dispatch fails before it starts.`, `name: 'acme-echo'`);
     }
-    if (blank(inputs?.folderPath)) {
+    const inSolution = inputs?.location === 'in-solution';
+    if (!inSolution && blank(inputs?.folderPath)) {
         at('FUNCTION_NO_FOLDER', `Function step "${step}" has no \`folderPath\`. The runtime resolves the function by name + folder — and a `
             + `function is often deployed into a folder of its OWN name, so read the folder from the tenant rather `
-            + `than assuming 'Shared'.`, `folderPath: 'Shared/acme-echo'`);
+            + `than assuming 'Shared'. For a coded function in the SAME solution, set \`location: 'in-solution'\` `
+            + `and its \`projectId\` instead.`, `folderPath: 'Shared/acme-echo'`);
+    }
+    if (inSolution && blank(inputs?.projectId)) {
+        at('FUNCTION_LOCAL_NO_PROJECT_ID', `In-solution function step "${step}" has no \`projectId\`. Read \`resource.projectKey\` from `
+            + `\`resources/solution_folder/process/function/<project>.json\`.`, `projectId: '<resource.projectKey>'`);
+    }
+    else if (inSolution && !GUID_RE.test(String(inputs.projectId).trim())) {
+        at('FUNCTION_LOCAL_PROJECT_ID_NOT_GUID', `In-solution function step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
+            + `the sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
+    }
+    if (inSolution && !blank(inputs?.folderPath)) {
+        at('FUNCTION_LOCAL_HAS_FOLDER', `In-solution function step "${step}" also sets \`folderPath\` ${JSON.stringify(inputs.folderPath)}. An `
+            + `in-solution sibling has no folder until the solution is deployed — the platform's own manifest `
+            + `writes \`""\` — so the value would be dropped. Remove it, or drop \`location: 'in-solution'\` to `
+            + `call the published copy.`);
     }
     const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
     if (name.includes('/')) {

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

@@ -257,7 +257,12 @@ const FUNCTION_PREFIX = 'uipath.core.function.';
  * alongside `output` (gated on `errorHandlingEnabled`, as everywhere else).
  */
 function publishedFunctionDef(spec) {
-    const resourceKey = `${spec.folderPath}.${spec.name}`;
+    // The location slot the other process resources share: an in-solution
+    // sibling (VS Code 1.204.25's `uipath.core.function.<key>` against the
+    // solution's own coded function) is the bare key, folder `''`, no
+    // `section`, and `projectId`/`projectName`/`isInSolution` on the model.
+    const loc = processResourceLocation(spec);
+    const { resourceKey } = loc;
     const properties = {};
     for (const [k, v] of Object.entries(spec.inputs)) {
         properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
@@ -266,8 +271,8 @@ function publishedFunctionDef(spec) {
         nodeType: `${FUNCTION_PREFIX}${spec.key}`,
         version: '1.0.0',
         category: 'function',
-        description: `(${spec.folderPath})`,
-        tags: [],
+        description: loc.description,
+        tags: loc.tags,
         sortOrder: resourceNodeSortOrder('function'),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: 'function' },
@@ -285,11 +290,12 @@ function publishedFunctionDef(spec) {
                 ],
             },
         ],
+        ...loc.definitionExtras,
         model: {
             type: 'bpmn:ServiceTask',
             serviceType: 'Orchestrator.ExecuteFunctionAsync',
             version: 'v2',
-            section: 'Published',
+            ...(loc.inSolution ? {} : { section: 'Published' }),
             listingVersion: '1.0.0',
             bindings: {
                 resource: 'process',
@@ -298,9 +304,10 @@ function publishedFunctionDef(spec) {
                 orchestratorType: 'function',
                 values: [
                     { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: spec.folderPath },
+                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
                 ],
             },
+            ...loc.modelExtras,
             context: [
                 { name: 'name', type: 'string', value: '<bindings.name>' },
                 { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
@@ -598,7 +605,10 @@ export function processDefinition(spec) {
     const s = (spec.inputs ?? {});
     switch (spec.kind) {
         case 'publishedFunction':
-            return publishedFunctionDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
+            return publishedFunctionDef({
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
+                inputs: s.inputs ?? {}, returns: s.returns,
+            });
         case 'apiWorkflow':
             return apiWorkflowDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
         case 'agenticProcess':

package/dist/nodes/process/flow/spec.d.ts

@@ -111,17 +111,42 @@ export interface PublishedFunctionInputs {
      * `uipath.core.function.<key>`. Find it with
      * `uip maestro flow registry search "uipath.core.function"` (after
      * `registry pull --force`) or the Orchestrator process listing.
+     *
+     * For an in-solution sibling it is `resource.key` from
+     * `resources/solution_folder/process/function/<project>.json` — the suffix of
+     * the node type `uip maestro flow registry list --local` shows.
      */
     key: string;
     /** The function's name in Orchestrator, e.g. `'acme-echo'`. */
     name: string;
+    /**
+     * Where the function lives. `'published'` (the default) is a function
+     * deployed to `folderPath`. `'in-solution'` is a sibling coded-function
+     * project of the same solution: it needs `projectId` and no `folderPath`, and
+     * `key` is that sibling's `resource.key` from
+     * `resources/solution_folder/process/function/<project>.json`.
+     */
+    location?: ProcessLocation;
     /**
      * The Orchestrator folder holding it. A function is usually deployed into a
      * folder of its OWN name (e.g. `'Shared/acme-echo'`), and the binding's
      * `resourceKey` is `<folderPath>.<name>` — copy the folder from the tenant
-     * rather than assuming `'Shared'`.
+     * rather than assuming `'Shared'`. Required for a published function; omit
+     * it for an in-solution sibling.
+     *
+     * @enforcedBy FUNCTION_NO_FOLDER A published function needs its folder.
+     * @enforcedBy FUNCTION_LOCAL_HAS_FOLDER An in-solution function has no folder.
      */
-    folderPath: string;
+    folderPath?: string;
+    /**
+     * The sibling function project's `resource.projectKey`, read from
+     * `resources/solution_folder/process/function/<project>.json`. Required only
+     * when `location` is `'in-solution'`.
+     *
+     * @enforcedBy FUNCTION_LOCAL_NO_PROJECT_ID An in-solution function needs its project id.
+     * @enforcedBy FUNCTION_LOCAL_PROJECT_ID_NOT_GUID The project id is the sibling's GUID, not its name.
+     */
+    projectId?: string;
     /** The function's own input arguments, by its own names. */
     inputs?: Record<string, unknown>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.58.0",
+  "version": "6.59.0",
   "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": "d70ce10e11def3cbb2d1d42ba52c76686dcfae2f"
+  "gitref": "ddebc637dab91373bb326fd4da5590f6e7d3b9c2"
 }