otomato-sdk 2.0.36 → 2.0.37

package/dist/src/models/Workflow.js

@@ -12,7 +12,7 @@ import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
 import { Action } from './Action.js';
 import { Note } from './Note.js';
-import { getEndNodePositions, positionWorkflowNodesAvoidOverlap } from '../utils/WorkflowNodePositioner.js';
+import { getEndNodePositions, positionWorkflowNodes } from '../utils/WorkflowNodePositioner.js';
 import { ACTIONS } from '../constants/Blocks.js';
 export class Workflow {
     constructor(name = '', nodes = [], edges = []) {
@@ -25,18 +25,18 @@ export class Workflow {
         this.nodes = nodes;
         this.edges = edges;
         this.state = 'inactive';
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     setName(name) {
         this.name = name;
     }
     addNode(node) {
         this.nodes.push(node);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addNodes(nodes) {
         this.nodes.push(...nodes);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     deleteNode(nodeToDelete) {
         // Remove the node from the nodes array
@@ -59,7 +59,7 @@ export class Workflow {
         this.edges = this.edges.filter(edge => edge.source !== nodeToDelete && edge.target !== nodeToDelete);
         this.edges.push(...newEdges);
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     /**
      * Inserts a new node into the workflow, potentially splitting an existing edge.
@@ -98,7 +98,7 @@ export class Workflow {
             });
             this.addEdge(newEdge);
             // Recalculate positions
-            positionWorkflowNodesAvoidOverlap(this);
+            positionWorkflowNodes(this);
             return;
         }
         // CASE B: nodeAfter is provided => we expect an edge nodeBefore->nodeAfter to exist
@@ -131,9 +131,9 @@ export class Workflow {
         });
         this.addEdges([newEdge1, newEdge2]);
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
-    insertCondition(nodeToInsert, nodeBefore, nodeAfter, addElseCase) {
+    insertCondition(nodeToInsert, nodeBefore, nodeAfter, addElseCase, addEmptyNodes = true) {
         if (nodeAfter) {
             this.insertNode(nodeToInsert, nodeBefore, nodeAfter, null, null, 'true', 'true');
         }
@@ -141,13 +141,15 @@ export class Workflow {
         // 1) "true" path: nodeBefore -> nodeToInsert -> nodeAfter
         if (!nodeAfter) {
             this.insertNode(nodeToInsert, nodeBefore, undefined);
-            const emptyNode1 = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
-            this.insertNode(emptyNode1, nodeToInsert, undefined, 'true', 'true');
+            if (addEmptyNodes) {
+                const emptyNode1 = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
+                this.insertNode(emptyNode1, nodeToInsert, undefined, 'true', 'true');
+            }
         }
         // 2) "false" path: nodeBefore -> nodeToInsert, 
         //    but here we pass no nodeAfter (so nodeAfter=null),
         //    and label/value are "false".
-        if (addElseCase) {
+        if (addElseCase && addEmptyNodes) {
             const emptyNode2 = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
             this.insertNode(emptyNode2, nodeToInsert, undefined, 'false', 'false');
         }
@@ -222,11 +224,11 @@ export class Workflow {
             }
         });
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addEdge(edge) {
         this.edges.push(edge);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     updateEdge(edgeId, newEdge) {
         const edgeToUpdate = this.edges.find(e => e.id === edgeId);
@@ -237,11 +239,11 @@ export class Workflow {
         else {
             throw new Error(`Edge with id ${edgeId} not found`);
         }
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addEdges(edges) {
         this.edges.push(...edges);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     getState() {
         return this.state;
@@ -370,7 +372,7 @@ export class Workflow {
                 this.nodes = yield Promise.all(response.nodes.map((nodeData) => __awaiter(this, void 0, void 0, function* () { return yield Node.fromJSON(nodeData); })));
                 this.edges = response.edges.map((edgeData) => Edge.fromJSON(edgeData, this.nodes));
                 this.notes = response.notes.map((noteData) => Note.fromJSON(noteData));
-                positionWorkflowNodesAvoidOverlap(this);
+                positionWorkflowNodes(this);
                 return this;
             }
             catch (error) {

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,146 +1,68 @@
-export const xSpacing = 500;
-export const ySpacing = 120;
-export const ROOT_X = 400;
+// Note: Using 'dagre' for layered DAG layout
+import dagre from 'dagre';
+// or: import * as dagre from 'dagre';
+export const xSpacing = 700; // used by dagre as node separation
+export const ySpacing = 75;
+export const ROOT_X = 400; // we’ll keep references, but Dagre decides actual positions
 export const ROOT_Y = 120;
-export function positionWorkflowNodesAvoidOverlap(workflow) {
-    // 1) Lay out nodes using existing logic
-    positionWorkflowNodes(workflow);
-    // 2) Group nodes by 'level' based on vertical position
-    const levels = new Map();
-    workflow.nodes.forEach((node) => {
-        if (node.position) {
-            const level = Math.round(node.position.y / ySpacing);
-            if (!levels.has(level)) {
-                levels.set(level, []);
-            }
-            levels.get(level).push(node);
-        }
-    });
-    // 3) Resolve horizontal overlaps among *all* nodes in each level
-    levels.forEach((levelNodes) => {
-        // Sort the nodes in this level by X
-        levelNodes.sort((a, b) => { var _a, _b; return ((_a = a.position.x) !== null && _a !== void 0 ? _a : 0) - ((_b = b.position.x) !== null && _b !== void 0 ? _b : 0); });
-        // Walk left-to-right, shifting nodes that would collide with the previous one
-        for (let i = 1; i < levelNodes.length; i++) {
-            const prev = levelNodes[i - 1];
-            const current = levelNodes[i];
-            // Compute how close they are
-            const dx = current.position.x - prev.position.x;
-            // If they are too close, shift the current node (and its children) to the right
-            if (dx < xSpacing) {
-                const shift = xSpacing - dx;
-                moveNodeAndChildren(current, shift, workflow.edges);
-            }
-        }
-    });
-    // 4) Re-center parents above their children in a bottom-up pass
-    centerParentXPositions(workflow);
-}
 /**
- * Lays out the workflow nodes in a rough top-down manner,
- * then positions each node relative to its parent.
+ * Dagre-based layout for the “top-down” pass. We’re effectively ignoring the old
+ * manual code. Instead, we:
+ *  1) Build a dagre graph
+ *  2) Add all nodes & edges
+ *  3) dagre.layout(g)
+ *  4) Extract positions & write them back to workflow.nodes
  */
 export function positionWorkflowNodes(workflow) {
-    try {
-        // Step 1: Find the starting nodes
-        const startingNodes = identityStartingNodes(workflow);
-        // Step 2: Place the starting nodes
-        let xPosition = ROOT_X;
-        startingNodes.forEach((startNode) => {
-            startNode.setPosition(xPosition, ROOT_Y);
-            xPosition += xSpacing;
+    // 1) Create a new directed graph
+    // doc: https://github.com/dagrejs/dagre
+    const g = new dagre.graphlib.Graph({ multigraph: false, compound: false });
+    g.setGraph({
+        // Some layout options:
+        rankdir: 'TB', // "top-bottom" layering
+        nodesep: xSpacing * 0.5, // horizontal spacing 
+        ranksep: ySpacing, // vertical spacing between levels
+        marginx: 20, // how much margin to leave around the left/right
+        marginy: 20, // how much margin to leave around the top/bottom
+    });
+    g.setDefaultEdgeLabel(() => ({}));
+    // 2) Add nodes to the graph
+    // Dagre requires each node have an id and some approximate width/height
+    workflow.nodes.forEach((node) => {
+        const nodeId = node.getRef();
+        // For a typical text-based node, approximate width & height
+        g.setNode(nodeId, {
+            label: nodeId,
+            width: 100,
+            height: 50
         });
-        // Step 3: For all other nodes, position them based on their parent(s)
-        const nodesToPosition = workflow.nodes.filter((node) => !startingNodes.includes(node));
-        nodesToPosition.forEach((node) => positionNode(node, workflow.edges, xSpacing, ySpacing, workflow));
-    }
-    catch (e) {
-        console.error(e);
-    }
-}
-export function positionNode(node, edges, xSpacing, ySpacing, workflow) {
-    const parents = getParents(node, edges);
-    if (!parents.length)
-        return; // Edge case: no parents?
-    // Sort children of the first parent by edge labels (true/false) so "true" is left, "false" is right
-    const children = getChildren(parents[0], edges).sort((a, b) => {
-        var _a, _b;
-        const edgeA = edges.find((edge) => edge.source === parents[0] && edge.target === a);
-        const edgeB = edges.find((edge) => edge.source === parents[0] && edge.target === b);
-        const labelA = (_a = edgeA === null || edgeA === void 0 ? void 0 : edgeA.label) !== null && _a !== void 0 ? _a : "";
-        const labelB = (_b = edgeB === null || edgeB === void 0 ? void 0 : edgeB.label) !== null && _b !== void 0 ? _b : "";
-        if (labelA === "true" && labelB !== "true")
-            return -1;
-        if (labelB === "true" && labelA !== "true")
-            return 1;
-        if (labelA === "false" && labelB !== "false")
-            return 1;
-        if (labelB === "false" && labelA !== "false")
-            return -1;
-        return 0;
     });
-    const parentX = parents.reduce((sum, p) => { var _a, _b; return sum + ((_b = (_a = p.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : ROOT_X); }, 0) /
-        parents.length;
-    const parentY = Math.max(...parents.map((p) => { var _a, _b; return (_b = (_a = p.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : ROOT_Y; }));
-    if (children.length <= 1) {
-        node.setPosition(parentX, parentY + ySpacing);
-    }
-    else {
-        // This node’s index among siblings
-        const index = children.indexOf(node);
-        const offset = index - (children.length - 1) / 2;
-        node.setPosition(parentX + offset * xSpacing, parentY + ySpacing);
-    }
-}
-/**
- * Repositions each parent node so that its X = average of its children’s X.
- */
-function centerParentXPositions(workflow) {
-    var _a, _b;
-    // Identify the leaf nodes to start a bottom-up pass
-    const queue = identifyLeafNodes(workflow);
-    while (queue.length > 0) {
-        const child = queue.shift();
-        const parents = getParents(child, workflow.edges);
-        for (const parent of parents) {
-            const children = getChildren(parent, workflow.edges);
-            if (children.length) {
-                const sumX = children.reduce((acc, c) => { var _a, _b; return acc + ((_b = (_a = c.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0); }, 0);
-                const avgX = sumX / children.length;
-                parent.setPosition(avgX, (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0);
-            }
-            // Push this parent upward in the queue to continue up the chain
-            if (!queue.includes(parent)) {
-                queue.push(parent);
-            }
-        }
-    }
-}
-/**
- * Recursively shifts a node and all its descendants by `shift` in the x-direction.
- */
-function moveNodeAndChildren(node, shift, edges) {
-    node.setPosition(node.position.x + shift, node.position.y);
-    edges
-        .filter((edge) => edge.source === node)
-        .forEach((edge) => {
-        moveNodeAndChildren(edge.target, shift, edges);
+    // 3) Add edges
+    // Dagre identifies edges by (sourceId, targetId). We don’t need labels for layout,
+    // but we can store them if we want. If you rely on “true/false” ordering, we can tweak
+    // e.g. use edge label as a tie-break. (See advanced docs.)
+    workflow.edges.forEach((edge) => {
+        var _a;
+        const fromId = edge.source.getRef();
+        const toId = edge.target.getRef();
+        g.setEdge(fromId, toId, { label: (_a = edge.label) !== null && _a !== void 0 ? _a : '' });
+    });
+    // 4) Run Dagre layout
+    dagre.layout(g);
+    // 5) Extract positions from Dagre graph and store them back to your Node objects
+    g.nodes().forEach((nodeId) => {
+        const dagreNode = g.node(nodeId); // { x, y, width, height, ... }
+        const nodeObj = workflow.nodes.find((n) => n.getRef() === nodeId);
+        if (!nodeObj || !dagreNode)
+            return;
+        // Store x,y in your node’s position
+        nodeObj.setPosition(dagreNode.x, dagreNode.y);
     });
 }
 /**
- * A "leaf" node is one that has no children (it’s never the source of an edge).
- */
-export function identifyLeafNodes(workflow) {
-    const sources = new Set(workflow.edges.map((edge) => edge.source.getRef()));
-    return workflow.nodes.filter((node) => !sources.has(node.getRef()));
-}
-/**
- * Identify starting nodes (no incoming edges).
+ * We keep these helper functions the same for external usage (if your code or tests need them),
+ * but we’re not actively using them in the new Dagre-based layout.
  */
-export function identityStartingNodes(workflow) {
-    const childRefs = new Set(workflow.edges.map((edge) => edge.target.getRef()));
-    return workflow.nodes.filter((node) => !childRefs.has(node.getRef()));
-}
 export function getChildren(node, edges) {
     return edges
         .filter((edge) => edge.source === node)
@@ -165,3 +87,16 @@ export function getEndNodePositions(workflow) {
         });
     });
 }
+/**
+ * In Dagre, we no longer do an explicit “identify leaf nodes” or “center parents by average,”
+ * because the layout library handles that.
+ * But here’s your old method if something else depends on it.
+ */
+export function identifyLeafNodes(workflow) {
+    const sources = new Set(workflow.edges.map((edge) => edge.source.getRef()));
+    return workflow.nodes.filter((node) => !sources.has(node.getRef()));
+}
+export function identityStartingNodes(workflow) {
+    const childRefs = new Set(workflow.edges.map((edge) => edge.target.getRef()));
+    return workflow.nodes.filter((node) => !childRefs.has(node.getRef()));
+}

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-2-protocols.d.ts

@@ -1,4 +1,4 @@
 /*************************************
- * 4. Main Workflow Builder
+ * 6. Main Workflow Builder
  *************************************/
 export declare function aggregatorWorkflow(): Promise<void>;

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-3-protocols.d.ts

@@ -0,0 +1,4 @@
+/*************************************
+ * 5. Main Workflow Builder (No manual edges or pushes)
+ *************************************/
+export declare function lendingAggregatorWorkflow(): Promise<void>;

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-v3.d.ts

@@ -0,0 +1,4 @@
+/*************************************
+ * 6. Main Workflow Builder
+ *************************************/
+export declare function aggregatorWorkflow(): Promise<void>;

package/dist/types/src/models/Workflow.d.ts

@@ -38,7 +38,7 @@ export declare class Workflow {
      * @param edgeValueAfter    (Optional) Value for the edge nodeToInsert->nodeAfter
      */
     insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, edgeLabelBefore?: string | null, edgeValueBefore?: any | null, edgeLabelAfter?: string | null, edgeValueAfter?: any | null): void;
-    insertCondition(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, addElseCase?: boolean): void;
+    insertCondition(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, addElseCase?: boolean, addEmptyNodes?: boolean): void;
     /**
      * Inserts a "split" node, creating `numberOfBranches` parallel branches.
      *

package/dist/types/src/utils/WorkflowNodePositioner.d.ts

@@ -1,25 +1,23 @@
 import { Workflow } from '../models/Workflow.js';
 import { Node } from '../models/Node.js';
 import { Edge } from '../models/Edge.js';
-export declare const xSpacing = 500;
-export declare const ySpacing = 120;
+export declare const xSpacing = 700;
+export declare const ySpacing = 75;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
-export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
 /**
- * Lays out the workflow nodes in a rough top-down manner,
- * then positions each node relative to its parent.
+ * Dagre-based layout for the “top-down” pass. We’re effectively ignoring the old
+ * manual code. Instead, we:
+ *  1) Build a dagre graph
+ *  2) Add all nodes & edges
+ *  3) dagre.layout(g)
+ *  4) Extract positions & write them back to workflow.nodes
  */
 export declare function positionWorkflowNodes(workflow: Workflow): void;
-export declare function positionNode(node: Node, edges: Edge[], xSpacing: number, ySpacing: number, workflow: Workflow): void;
 /**
- * A "leaf" node is one that has no children (it’s never the source of an edge).
+ * We keep these helper functions the same for external usage (if your code or tests need them),
+ * but we’re not actively using them in the new Dagre-based layout.
  */
-export declare function identifyLeafNodes(workflow: Workflow): Node[];
-/**
- * Identify starting nodes (no incoming edges).
- */
-export declare function identityStartingNodes(workflow: Workflow): Node[];
 export declare function getChildren(node: Node, edges: Edge[]): Node[];
 export declare function getParents(node: Node, edges: Edge[]): Node[];
 export declare function getEdges(node: Node, edges: Edge[]): Edge[];
@@ -27,3 +25,10 @@ export declare function getEndNodePositions(workflow: Workflow): {
     x: number;
     y: number;
 }[];
+/**
+ * In Dagre, we no longer do an explicit “identify leaf nodes” or “center parents by average,”
+ * because the layout library handles that.
+ * But here’s your old method if something else depends on it.
+ */
+export declare function identifyLeafNodes(workflow: Workflow): Node[];
+export declare function identityStartingNodes(workflow: Workflow): Node[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "2.0.36",
+  "version": "2.0.37",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",
@@ -31,6 +31,7 @@
   "devDependencies": {
     "@types/axios": "^0.14.0",
     "@types/chai": "^4.3.16",
+    "@types/dagre": "^0.7.52",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/mocha": "^10.0.6",
     "@types/mustache": "^4.2.5",
@@ -43,6 +44,7 @@
   },
   "dependencies": {
     "axios": "^1.7.2",
+    "dagre": "^0.8.5",
     "ethers": "^6.13.1",
     "jsonwebtoken": "^9.0.2",
     "mustache": "^4.2.0"