otomato-sdk 2.0.15 → 2.0.16

package/dist/src/constants/version.js

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

package/dist/src/models/Workflow.js

@@ -11,6 +11,7 @@ import { Node } from './Node.js';
 import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
 import { Note } from './Note.js';
+import { positionWorkflowNodesAvoidOverlap } from '../utils/WorkflowNodePositioner.js';
 export class Workflow {
     constructor(name = '', nodes = [], edges = []) {
         this.id = null;
@@ -22,18 +23,101 @@ export class Workflow {
         this.nodes = nodes;
         this.edges = edges;
         this.state = 'inactive';
+        positionWorkflowNodesAvoidOverlap(this);
     }
     setName(name) {
         this.name = name;
     }
     addNode(node) {
         this.nodes.push(node);
+        positionWorkflowNodesAvoidOverlap(this);
     }
     addNodes(nodes) {
         this.nodes.push(...nodes);
+        positionWorkflowNodesAvoidOverlap(this);
+    }
+    deleteNode(nodeToDelete) {
+        // Remove the node from the nodes array
+        const nodeIndex = this.nodes.findIndex(node => node === nodeToDelete);
+        if (nodeIndex === -1) {
+            throw new Error(`Node not found in the workflow.`);
+        }
+        this.nodes.splice(nodeIndex, 1);
+        // Collect incoming and outgoing edges
+        const incomingEdges = this.edges.filter(edge => edge.target === nodeToDelete);
+        const outgoingEdges = this.edges.filter(edge => edge.source === nodeToDelete);
+        // Create new edges to replace the deleted node's connections
+        const newEdges = [];
+        incomingEdges.forEach(inEdge => {
+            outgoingEdges.forEach(outEdge => {
+                newEdges.push(new Edge({ source: inEdge.source, target: outEdge.target }));
+            });
+        });
+        // Update the edges array: remove edges involving the deleted node and add the new ones
+        this.edges = this.edges.filter(edge => edge.source !== nodeToDelete && edge.target !== nodeToDelete);
+        this.edges.push(...newEdges);
+        // Recalculate positions
+        positionWorkflowNodesAvoidOverlap(this);
+    }
+    insertNode(nodeToInsert, nodeBefore, nodeAfter) {
+        // Ensure nodeBefore exists in the workflow
+        if (!this.nodes.includes(nodeBefore)) {
+            throw new Error('The nodeBefore must exist in the workflow.');
+        }
+        // If nodeAfter is not provided, insert the new node as a child of nodeBefore
+        if (!nodeAfter) {
+            // Add the new node to the workflow
+            this.addNode(nodeToInsert);
+            // Add a new edge between nodeBefore and nodeToInsert
+            const newEdge = new Edge({ source: nodeBefore, target: nodeToInsert });
+            this.addEdge(newEdge);
+            // Recalculate positions
+            positionWorkflowNodesAvoidOverlap(this);
+            return;
+        }
+        // If nodeAfter is provided, ensure both nodes exist in the workflow
+        if (!this.nodes.includes(nodeAfter)) {
+            throw new Error('The nodeAfter must exist in the workflow.');
+        }
+        // Check if an edge exists between nodeBefore and nodeAfter
+        const edgeBetween = this.edges.find(edge => edge.source === nodeBefore && edge.target === nodeAfter);
+        if (!edgeBetween) {
+            throw new Error('No edge exists between nodeBefore and nodeAfter.');
+        }
+        // Add the new node to the workflow
+        this.addNode(nodeToInsert);
+        // Remove the existing edge between nodeBefore and nodeAfter
+        this.edges = this.edges.filter(edge => edge !== edgeBetween);
+        // Add new edges
+        const newEdge1 = new Edge({ source: nodeBefore, target: nodeToInsert });
+        const newEdge2 = new Edge({ source: nodeToInsert, target: nodeAfter });
+        this.addEdges([newEdge1, newEdge2]);
+        // Recalculate positions
+        positionWorkflowNodesAvoidOverlap(this);
+    }
+    swapNode(oldNode, newNode) {
+        // Find the index of the node to replace
+        const nodeIndex = this.nodes.findIndex(node => node === oldNode);
+        if (nodeIndex === -1) {
+            throw new Error(`Node to swap not found in the workflow.`);
+        }
+        // Replace the old node with the new node in the nodes array
+        this.nodes[nodeIndex] = newNode;
+        // Update edges to point to the new node
+        this.edges.forEach(edge => {
+            if (edge.source === oldNode) {
+                edge.source = newNode;
+            }
+            if (edge.target === oldNode) {
+                edge.target = newNode;
+            }
+        });
+        // Recalculate positions
+        positionWorkflowNodesAvoidOverlap(this);
     }
     addEdge(edge) {
         this.edges.push(edge);
+        positionWorkflowNodesAvoidOverlap(this);
     }
     updateEdge(edgeId, newEdge) {
         const edgeToUpdate = this.edges.find(e => e.id === edgeId);
@@ -44,9 +128,11 @@ export class Workflow {
         else {
             throw new Error(`Edge with id ${edgeId} not found`);
         }
+        positionWorkflowNodesAvoidOverlap(this);
     }
     addEdges(edges) {
         this.edges.push(...edges);
+        positionWorkflowNodesAvoidOverlap(this);
     }
     getState() {
         return this.state;
@@ -90,7 +176,7 @@ export class Workflow {
             executionId: this.executionId,
             nodes: this.nodes.map(node => node.toJSON()),
             edges: this.edges.map(edge => edge.toJSON()),
-            notes: this.getNotes(), // Include notes
+            notes: this.getNotes(),
         };
     }
     create() {
@@ -175,6 +261,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);
                 return this;
             }
             catch (error) {

package/dist/src/utils/WorkflowNodePositioner.js

@@ -0,0 +1,202 @@
+// workflowNodePositioner.ts
+/**
+ * Positions nodes in a BFS manner, assuming exactly one root node.
+ * - The root is placed at (400, 120) unless it already has a position.
+ * - If a parent has exactly 1 child, that child is placed directly below the parent
+ *   (same x, with an offset in y).
+ * - If a parent has multiple children, they are horizontally spread around the parent's X.
+ * - Existing positions are not overwritten.
+ */
+/*export function autoPositionNodes(workflow: Workflow): void {
+    // 1. Build adjacency & incoming edge count
+    const adjacency = new Map<string, Node[]>();
+    const incomingCount = new Map<string, number>();
+
+    // Constants you can tweak or increase if you see overlap or crossing edges
+    const ROOT_X = 400;
+    const ROOT_Y = 120;
+    const MIN_SPACING_X = 500;  // Horizontal spacing between siblings
+    const MIN_SPACING_Y = 120;  // Vertical spacing from parent to child
+
+    // Initialize adjacency and incoming counts
+    workflow.nodes.forEach((node) => {
+        adjacency.set(node.getRef(), []);
+        incomingCount.set(node.getRef(), 0);
+    });
+
+    // Fill adjacency list (source -> array of targets) and count incoming edges
+    workflow.edges.forEach((edge: Edge) => {
+        const sourceRef = edge.source.getRef();
+        const targetRef = edge.target.getRef();
+        adjacency.get(sourceRef)?.push(edge.target);
+        incomingCount.set(targetRef, (incomingCount.get(targetRef) ?? 0) + 1);
+    });
+
+    // 2. Find all root nodes (no incoming edges). If multiple, just pick the first.
+    const rootNodes = workflow.nodes.filter(
+        (n) => (incomingCount.get(n.getRef()) || 0) === 0
+    );
+    if (rootNodes.length === 0) {
+        // No root found; nothing to do
+        return;
+    }
+
+    // We'll assume the first root is "the" root for this layout
+    const root = rootNodes[0];
+    if (!hasPosition(root)) {
+        root.setPosition(ROOT_X, ROOT_Y);
+    }
+
+    // 3. BFS from that single root
+    const queue = [root];
+    while (queue.length > 0) {
+        const parent = queue.shift()!;
+        const parentRef = parent.getRef();
+
+        // Identify the children
+        const children = adjacency.get(parentRef) || [];
+
+        // Among those children, find any that do NOT already have positions
+        const unpositionedKids = children.filter((c) => !hasPosition(c));
+
+        if (unpositionedKids.length > 0) {
+            const parentX = parent.position?.x ?? 0;
+            const parentY = parent.position?.y ?? 0;
+
+            if (unpositionedKids.length === 1) {
+                // Single child: place it straight below the parent
+                const onlyChild = unpositionedKids[0];
+                onlyChild.setPosition(parentX, parentY + MIN_SPACING_Y);
+            } else {
+                // Multiple children: spread them horizontally around the parent's X
+                const count = unpositionedKids.length;
+                unpositionedKids.forEach((child, i) => {
+                    const offset = i - (count - 1) / 2;
+                    const childX = parentX + offset * MIN_SPACING_X;
+                    const childY = parentY + MIN_SPACING_Y;
+                    child.setPosition(childX, childY);
+                });
+            }
+        }
+
+        // Decrement incoming edges for each child. Once a child hits 0, enqueue it
+        children.forEach((c) => {
+            const cRef = c.getRef();
+            const oldCount = incomingCount.get(cRef) ?? 0;
+            const newCount = oldCount - 1;
+            incomingCount.set(cRef, newCount);
+            if (newCount === 0) {
+                queue.push(c);
+            }
+        });
+    }
+}*/
+export const xSpacing = 400;
+export const ySpacing = 120;
+export const ROOT_X = 400;
+export const ROOT_Y = 120;
+export function positionWorkflowNodes(workflow) {
+    try {
+        // Step 1: Find the starting nodes using identityStartingNodes function
+        const startingNodes = identityStartingNodes(workflow);
+        // Step 2: Place the starting nodes
+        let xPosition = ROOT_X;
+        startingNodes.forEach((startNode) => {
+            startNode.setPosition(xPosition, ROOT_Y);
+            xPosition += xSpacing;
+        });
+        // Step 3: Place all other nodes relative to their parents
+        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) {
+    // Get children of the node
+    const parents = getParents(node, edges);
+    // todo: what if we have multiple parents?
+    const children = getChildren(parents[0], edges);
+    const childrenCountOfParent = children.length;
+    const parentX = parents.reduce((sum, parent) => { var _a, _b; return sum + ((_b = (_a = parent.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(parent => { var _a, _b; return (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : ROOT_Y; }));
+    // Compute position based on parent children count
+    if (childrenCountOfParent === 1) {
+        node.setPosition(parentX, parentY + ySpacing);
+    }
+    else {
+        const index = children.indexOf(node); // Get the position of this node among its siblings
+        const totalChildren = children.length;
+        // Compute the x position for this node
+        const offset = index - (totalChildren - 1) / 2; // Center the children around the parent
+        node.setPosition(parentX + offset * xSpacing, parentY + ySpacing);
+    }
+}
+export function positionWorkflowNodesAvoidOverlap(workflow) {
+    const levels = new Map();
+    // Helper: Add node to its level
+    function addToLevel(node) {
+        const level = Math.round(node.position.y / ySpacing);
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level).push(node);
+    }
+    // Step 1: Position nodes using the existing logic
+    positionWorkflowNodes(workflow);
+    // Step 2: Populate levels
+    workflow.nodes.forEach((node) => {
+        if (node.position) {
+            addToLevel(node);
+        }
+    });
+    // Step 3: Resolve overlaps for each level
+    levels.forEach((nodes, level) => {
+        // Sort nodes by X position
+        nodes.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); });
+        // Adjust overlapping nodes
+        for (let i = 1; i < nodes.length; i++) {
+            const prevNode = nodes[i - 1];
+            const currentNode = nodes[i];
+            if (currentNode.position.x - prevNode.position.x < xSpacing) {
+                const shift = xSpacing - (currentNode.position.x - prevNode.position.x);
+                moveNodeAndChildren(currentNode, shift, workflow.edges);
+            }
+        }
+    });
+}
+function moveNodeAndChildren(node, shift, edges) {
+    // Move the node
+    node.setPosition(node.position.x + shift, node.position.y);
+    // Propagate to children
+    edges
+        .filter((edge) => edge.source === node)
+        .forEach((edge) => {
+        moveNodeAndChildren(edge.target, shift, edges);
+    });
+}
+export function identifyLeafNodes(workflow) {
+    const nonLeafNodes = new Set(workflow.edges.map(edge => edge.source.getRef()));
+    return workflow.nodes.filter(node => !nonLeafNodes.has(node.getRef()));
+}
+/**
+ * Identifies starting nodes (nodes with no incoming edges).
+ * A starting node is defined as one that is not a target of any edge.
+ *
+ * @param workflow The workflow to analyze.
+ * @returns An array of nodes that have no incoming edges.
+ */
+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).map(edge => edge.target);
+}
+export function getParents(node, edges) {
+    return edges.filter(edge => edge.target === node).map(edge => edge.source);
+}
+export function getEdges(node, edges) {
+    return edges.filter(edge => edge.source === node || edge.target === node);
+}

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

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

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

@@ -17,6 +17,9 @@ export declare class Workflow {
     setName(name: string): void;
     addNode(node: Node): void;
     addNodes(nodes: Node[]): void;
+    deleteNode(nodeToDelete: Node): void;
+    insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node): void;
+    swapNode(oldNode: Node, newNode: Node): void;
     addEdge(edge: Edge): void;
     updateEdge(edgeId: string, newEdge: Edge): void;
     addEdges(edges: Edge[]): void;

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

@@ -0,0 +1,30 @@
+import { Workflow } from '../models/Workflow.js';
+import { Node } from '../models/Node.js';
+import { Edge } from '../models/Edge.js';
+/**
+ * Positions nodes in a BFS manner, assuming exactly one root node.
+ * - The root is placed at (400, 120) unless it already has a position.
+ * - If a parent has exactly 1 child, that child is placed directly below the parent
+ *   (same x, with an offset in y).
+ * - If a parent has multiple children, they are horizontally spread around the parent's X.
+ * - Existing positions are not overwritten.
+ */
+export declare const xSpacing = 400;
+export declare const ySpacing = 120;
+export declare const ROOT_X = 400;
+export declare const ROOT_Y = 120;
+export declare function positionWorkflowNodes(workflow: Workflow): void;
+export declare function positionNode(node: Node, edges: Edge[], xSpacing: number, ySpacing: number, workflow: Workflow): void;
+export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
+export declare function identifyLeafNodes(workflow: Workflow): Node[];
+/**
+ * Identifies starting nodes (nodes with no incoming edges).
+ * A starting node is defined as one that is not a target of any edge.
+ *
+ * @param workflow The workflow to analyze.
+ * @returns An array of nodes that have 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[];

package/dist/types/test/nodePositioning.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",