otomato-sdk 2.0.50 → 2.0.52

package/dist/src/constants/version.js

@@ -1,4 +1,4 @@
-export const SDK_VERSION = '2.0.50';
+export const SDK_VERSION = '2.0.51';
 export function compareVersions(v1, v2) {
     // Split the version strings into parts
     const v1Parts = v1.split('.').map(Number);

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,81 +1,67 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import ELK from 'elkjs/lib/elk.bundled.js';
-export const xSpacing = 700; // similar to Dagre’s node separation
+// Note: Using 'dagre' for layered DAG layout
+import * as dagre from '@dagrejs/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; // reference positions (if needed)
+export const ROOT_X = 400; // we’ll keep references, but Dagre decides actual positions
 export const ROOT_Y = 120;
-// Create a single ELK instance for reuse
-const elk = new ELK();
 /**
- * ELK-based layout for workflow nodes.
- *
- * This function builds an ELK-compatible graph:
- *  1) It creates a root graph object with layout options.
- *  2) It adds all workflow nodes as children, with id, width, and height.
- *  3) It adds all edges (as ELK expects sources/targets arrays).
- *  4) It calls elk.layout() (asynchronously) to compute positions.
- *  5) It then updates each node in workflow.nodes with the computed positions.
- *
- * Note: ELK returns (x,y) for the top-left of each node’s bounding box.
- * If your SDK expects center positions, we adjust by adding half the width/height.
+ * 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) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // 1) Create an ELK graph structure
-        const elkGraph = {
-            id: 'root',
-            // Layout options can be tuned as needed.
-            layoutOptions: {
-                // 'DOWN' makes the layout top-to-bottom (like Dagre’s rankdir: 'TB')
-                'elk.direction': 'DOWN',
-                // Space between nodes (ELK uses this for both horizontal and vertical spacing)
-                'elk.layered.spacing.nodeNode': ySpacing.toString(),
-                // Add some padding around the graph
-                'elk.padding': '20', // you can also use "20,20,20,20" for (top,right,bottom,left)
-            },
-            // 2) Map workflow nodes to ELK “children”
-            children: workflow.nodes.map((node) => ({
-                id: node.getRef(),
-                width: 100, // approximate width
-                height: 50, // approximate height
-            })),
-            // 3) Map workflow edges to ELK “edges”
-            edges: workflow.edges.map((edge) => ({
-                id: `${edge.source.getRef()}_${edge.target.getRef()}`,
-                sources: [edge.source.getRef()],
-                targets: [edge.target.getRef()],
-                // Optionally, you can pass edge-specific layout options here.
-            })),
-        };
-        // 4) Run the ELK layout (this returns a Promise)
-        const layout = yield elk.layout(elkGraph);
-        // 5) Extract positions from ELK’s result and store them back on the workflow nodes.
-        // ELK returns an array of children nodes with computed { x, y, width, height }.
-        if (layout.children) {
-            layout.children.forEach((elkNode) => {
-                // Find the corresponding Node object by its unique reference
-                const nodeObj = workflow.nodes.find((n) => n.getRef() === elkNode.id);
-                if (!nodeObj)
-                    return;
-                // ELK gives x,y as the top-left. To match Dagre’s “center” output, we add half the dimensions.
-                const centerX = elkNode.x + (elkNode.width / 2);
-                const centerY = elkNode.y + (elkNode.height / 2);
-                nodeObj.setPosition(centerX, centerY);
-            });
-        }
+    // 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
+        });
+    });
+    // 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);
     });
 }
 /**
- * The following helper functions remain unchanged,
- * as they depend only on your workflow model.
+ * 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 getChildren(node, edges) {
     return edges
@@ -102,7 +88,9 @@ export function getEndNodePositions(workflow) {
     });
 }
 /**
- * Old methods for identifying “leaf” or starting nodes.
+ * 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()));

package/dist/types/examples/test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Example workflow:
+ *   Trigger -> Delay -> Condition
+ *      ├─(true)─> Split(3)
+ *      └─(false)-> Delay
+ */
+export declare function conditionSplitDemo(): Promise<void>;

package/dist/types/src/constants/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "2.0.50";
+export declare const SDK_VERSION = "2.0.51";
 export declare function compareVersions(v1: string, v2: string): number;

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

@@ -6,22 +6,17 @@ export declare const ySpacing = 75;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
 /**
- * ELK-based layout for workflow nodes.
- *
- * This function builds an ELK-compatible graph:
- *  1) It creates a root graph object with layout options.
- *  2) It adds all workflow nodes as children, with id, width, and height.
- *  3) It adds all edges (as ELK expects sources/targets arrays).
- *  4) It calls elk.layout() (asynchronously) to compute positions.
- *  5) It then updates each node in workflow.nodes with the computed positions.
- *
- * Note: ELK returns (x,y) for the top-left of each node’s bounding box.
- * If your SDK expects center positions, we adjust by adding half the width/height.
+ * 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): Promise<void>;
+export declare function positionWorkflowNodes(workflow: Workflow): void;
 /**
- * The following helper functions remain unchanged,
- * as they depend only on your workflow model.
+ * 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 getChildren(node: Node, edges: Edge[]): Node[];
 export declare function getParents(node: Node, edges: Edge[]): Node[];
@@ -31,7 +26,9 @@ export declare function getEndNodePositions(workflow: Workflow): {
     y: number;
 }[];
 /**
- * Old methods for identifying “leaf” or starting nodes.
+ * 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.50",
+  "version": "2.0.52",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",
@@ -43,9 +43,9 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
+    "@dagrejs/dagre": "^1.1.4",
     "axios": "^1.7.2",
     "dagre": "^0.8.5",
-    "elkjs": "^0.9.3",
     "ethers": "^6.13.1",
     "jsonwebtoken": "^9.0.2",
     "mustache": "^4.2.0"