otomato-sdk 1.1.0 → 1.2.0

package/dist/examples/create-automation.js

@@ -7,18 +7,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken } from '../src/index.js';
+import { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken, Edge } from '../src/index.js';
 const main = () => __awaiter(void 0, void 0, void 0, function* () {
-    const usdcTransferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+    const usdcTransferTrigger = new Trigger({
+        id: TRIGGERS.TOKENS.ERC20.TRANSFER.id,
+        name: TRIGGERS.TOKENS.ERC20.TRANSFER.name,
+        description: TRIGGERS.TOKENS.ERC20.TRANSFER.description,
+        type: TRIGGERS.TOKENS.ERC20.TRANSFER.type,
+        parameters: TRIGGERS.TOKENS.ERC20.TRANSFER.parameters,
+        ref: 'n-1',
+    });
     usdcTransferTrigger.setChainId(CHAINS.ETHEREUM);
     usdcTransferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-    usdcTransferTrigger.setCoordinates(0, 0);
-    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    usdcTransferTrigger.setPosition(0, 0);
+    const slackAction = new Action({
+        id: ACTIONS.NOTIFICATIONS.SLACK.id,
+        name: ACTIONS.NOTIFICATIONS.SLACK.name,
+        description: ACTIONS.NOTIFICATIONS.SLACK.description,
+        parameters: ACTIONS.NOTIFICATIONS.SLACK.parameters,
+        // not forced to provide a ref id, it will generate it
+    });
     slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
     slackAction.setParams("text", "USDC has been transferred!");
-    slackAction.setCoordinates(0, -10);
-    const automation = new Automation("USDC Transfer Notification", usdcTransferTrigger, [slackAction]);
+    slackAction.setPosition(0, -10);
+    const automation = new Automation("USDC Transfer Notification", [usdcTransferTrigger, slackAction]);
+    const edge = new Edge({
+        source: usdcTransferTrigger,
+        target: slackAction,
+    });
+    automation.addEdge(edge);
     console.log(JSON.stringify(automation.toJSON(), null, 2));
-    yield automation.save();
+    //await automation.save();
 });
 main();

package/dist/src/index.js

@@ -9,5 +9,6 @@ export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
 export * from './models/Node.js';
+export * from './models/Edge.js';
 // Exporting services
 export * from './services/ApiService.js';

package/dist/src/models/Action.js

@@ -1,6 +1,6 @@
 import { Node } from './Node.js';
 export class Action extends Node {
     constructor(action) {
-        super(action);
+        super(Object.assign(Object.assign({}, action), { class: 'action' }));
     }
 }

package/dist/src/models/Automation.js

@@ -9,25 +9,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { apiServices } from '../services/ApiService.js';
 export class Automation {
-    constructor(name, trigger, actions = []) {
+    constructor(name, nodes = [], edges = []) {
         this.name = name;
-        this.trigger = trigger;
-        this.actions = actions;
+        this.nodes = nodes;
+        this.edges = edges;
     }
     setName(name) {
         this.name = name;
     }
-    addTrigger(trigger) {
-        this.trigger = trigger;
+    addNode(node) {
+        this.nodes.push(node);
     }
-    addAction(action) {
-        this.actions.push(action);
+    addNodes(nodes) {
+        this.nodes.push(...nodes);
+    }
+    addEdge(edge) {
+        this.edges.push(edge);
+    }
+    addEdges(edges) {
+        this.edges.push(...edges);
     }
     toJSON() {
         return {
             name: this.name,
-            trigger: this.trigger.toJSON(),
-            actions: this.actions.map(action => action.toJSON()),
+            nodes: this.nodes.map(node => node.toJSON()),
+            edges: this.edges.map(edge => edge.toJSON()),
         };
     }
     save() {

package/dist/src/models/Edge.js

@@ -0,0 +1,25 @@
+let edgeCounter = 0;
+const generatedEdgeIds = new Set();
+export class Edge {
+    constructor(edge) {
+        if (edge.id) {
+            this.id = edge.id;
+        }
+        else {
+            this.id = `e-${++edgeCounter}`;
+            while (generatedEdgeIds.has(this.id)) {
+                this.id = `e-${++edgeCounter}`;
+            }
+        }
+        generatedEdgeIds.add(this.id);
+        this.source = edge.source;
+        this.target = edge.target;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            source: this.source.getRef(),
+            target: this.target.getRef(),
+        };
+    }
+}

package/dist/src/models/Node.js

@@ -1,4 +1,6 @@
 import { validateType } from '../utils/typeValidator.js';
+let nodeCounter = 0;
+const generatedRefs = new Set();
 export class Node {
     constructor(node) {
         this.id = node.id;
@@ -6,13 +8,25 @@ export class Node {
         this.description = node.description;
         this.parameters = {};
         this.keyMap = {};
+        this.class = node.class; // Set class property
+        if (node.ref) {
+            this.ref = node.ref;
+        }
+        else {
+            this.ref = `n-${++nodeCounter}`;
+            while (generatedRefs.has(this.ref)) {
+                this.ref = `n-${++nodeCounter}`;
+            }
+        }
+        generatedRefs.add(this.ref);
         node.parameters.forEach(param => {
             this.parameters[param.key] = Object.assign(Object.assign({}, param), { value: null });
             const simplifiedKey = this.getSimplifiedKey(param.key);
             this.keyMap[simplifiedKey] = param.key;
         });
-        this.x = node.x;
-        this.y = node.y;
+        if (node.position) {
+            this.position = node.position;
+        }
     }
     setChainId(value) {
         this.setParameter('chainId', value);
@@ -24,9 +38,11 @@ export class Node {
         const fullKey = this.parameters[`abiParams.${key}`] ? `abiParams.${key}` : key;
         this.setParameter(fullKey, value);
     }
-    setCoordinates(x, y) {
-        this.x = x;
-        this.y = y;
+    setPosition(x, y) {
+        this.position = { x, y };
+    }
+    getRef() {
+        return this.ref;
     }
     setParameter(key, value) {
         if (key in this.parameters) {
@@ -59,12 +75,15 @@ export class Node {
     toJSON() {
         const json = {
             id: this.id,
-            parameters: this.getParameters(),
+            ref: this.ref,
+            type: this.class,
+            data: {
+                parameters: this.getParameters(),
+            }
         };
-        if (this.x !== undefined)
-            json.x = this.x;
-        if (this.y !== undefined)
-            json.y = this.y;
+        if (this.position) {
+            json.position = this.position;
+        }
         return json;
     }
     getSimplifiedKey(key) {

package/dist/src/models/Trigger.js

@@ -1,7 +1,7 @@
 import { Node } from './Node.js';
 export class Trigger extends Node {
     constructor(trigger) {
-        super(trigger);
+        super(Object.assign(Object.assign({}, trigger), { class: 'trigger' }));
         this.type = trigger.type;
     }
     setCondition(value) {

package/dist/test/automation.spec.js

@@ -8,27 +8,30 @@ describe('Automation Class', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
         trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setPosition(0, 0);
         const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         action1.setChainId(CHAINS.ETHEREUM);
         action1.setParams("value", 1000);
         action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
         action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setPosition(1, 0);
         const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
         action2.setParams("phoneNumber", "+1234567890");
         action2.setParams("text", "This is a test message");
-        const automation = new Automation("Test Automation", trigger, [action1, action2]);
+        action2.setPosition(2, 0);
+        const automation = new Automation("Test Automation", [trigger, action1, action2]);
         const json = automation.toJSON();
         expect(json).to.deep.equal({
             name: "Test Automation",
-            trigger: trigger.toJSON(),
-            actions: [action1.toJSON(), action2.toJSON()],
+            nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
         });
     });
     it('should set the name of the automation', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
         trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-        const automation = new Automation("Initial Name", trigger);
+        trigger.setPosition(0, 0);
+        const automation = new Automation("Initial Name", [trigger]);
         automation.setName("Updated Name");
         expect(automation.name).to.equal("Updated Name");
     });
@@ -36,28 +39,33 @@ describe('Automation Class', () => {
         const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         initialTrigger.setChainId(CHAINS.ETHEREUM);
         initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        initialTrigger.setPosition(0, 0);
         const newTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         newTrigger.setChainId(CHAINS.ETHEREUM);
         newTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-        const automation = new Automation("Test Automation", initialTrigger);
-        automation.addTrigger(newTrigger);
-        expect(automation.trigger).to.deep.equal(newTrigger);
+        newTrigger.setPosition(1, 0);
+        const automation = new Automation("Test Automation", [initialTrigger]);
+        automation.addNode(newTrigger);
+        expect(automation.nodes).to.deep.equal([initialTrigger, newTrigger]);
     });
     it('should add actions to the automation', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
         trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setPosition(0, 0);
         const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         action1.setChainId(CHAINS.ETHEREUM);
         action1.setParams("value", 1000);
         action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
         action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setPosition(1, 0);
         const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
         action2.setParams("phoneNumber", "+1234567890");
         action2.setParams("text", "This is a test message");
-        const automation = new Automation("Test Automation", trigger);
-        automation.addAction(action1);
-        automation.addAction(action2);
-        expect(automation.actions).to.deep.equal([action1, action2]);
+        action2.setPosition(2, 0);
+        const automation = new Automation("Test Automation", [trigger]);
+        automation.addNode(action1);
+        automation.addNode(action2);
+        expect(automation.nodes).to.deep.equal([trigger, action1, action2]);
     });
 });

package/dist/test/node.spec.js

@@ -10,40 +10,44 @@ describe('Node Class', () => {
             id: 1,
             name: 'Test Node',
             description: 'A node for testing',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
-        expect(node.x).to.be.undefined;
-        expect(node.y).to.be.undefined;
+        expect(node.position).to.be.undefined;
     });
     it('should create a node with coordinates', () => {
+        var _a, _b;
         const node = new Node({
             id: 2,
             name: 'Test Node with Coordinates',
             description: 'A node for testing with coordinates',
             parameters: DEFAULT_PARAMETERS,
-            x: 100,
-            y: 200
+            class: 'testClass',
+            position: { x: 100, y: 200 }
         });
-        expect(node.x).to.equal(100);
-        expect(node.y).to.equal(200);
+        expect((_a = node.position) === null || _a === void 0 ? void 0 : _a.x).to.equal(100);
+        expect((_b = node.position) === null || _b === void 0 ? void 0 : _b.y).to.equal(200);
     });
     it('should set and get coordinates correctly', () => {
+        var _a, _b;
         const node = new Node({
             id: 3,
             name: 'Test Node for Coordinates',
             description: 'A node for testing coordinate setting',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
-        node.setCoordinates(300, 400);
-        expect(node.x).to.equal(300);
-        expect(node.y).to.equal(400);
+        node.setPosition(300, 400);
+        expect((_a = node.position) === null || _a === void 0 ? void 0 : _a.x).to.equal(300);
+        expect((_b = node.position) === null || _b === void 0 ? void 0 : _b.y).to.equal(400);
     });
     it('should create a node and set parameters correctly', () => {
         const node = new Node({
             id: 4,
             name: 'Test Node for Parameters',
             description: 'A node for testing parameter setting',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
@@ -56,16 +60,21 @@ describe('Node Class', () => {
             id: 5,
             name: 'Test Node for JSON',
             description: 'A node for testing JSON export',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
             id: 5,
-            parameters: {
-                chainId: 1,
-                contractAddress: "0x0000000000000000000000000000000000000000"
+            ref: node.getRef(),
+            class: 'testClass',
+            data: {
+                parameters: {
+                    chainId: 1,
+                    contractAddress: "0x0000000000000000000000000000000000000000"
+                }
             }
         });
     });
@@ -75,20 +84,23 @@ describe('Node Class', () => {
             name: 'Test Node for JSON with Coordinates',
             description: 'A node for testing JSON export with coordinates',
             parameters: DEFAULT_PARAMETERS,
-            x: 100,
-            y: 200
+            class: 'testClass',
+            position: { x: 1, y: 2 }
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
             id: 6,
-            parameters: {
-                chainId: 1,
-                contractAddress: "0x0000000000000000000000000000000000000000"
+            ref: node.getRef(),
+            class: 'testClass',
+            data: {
+                parameters: {
+                    chainId: 1,
+                    contractAddress: "0x0000000000000000000000000000000000000000"
+                }
             },
-            x: 100,
-            y: 200
+            position: { x: 1, y: 2 }
         });
     });
     it('should throw an error for invalid parameter type', () => {
@@ -96,7 +108,8 @@ describe('Node Class', () => {
             id: 7,
             name: 'Test Node for Invalid Parameter Type',
             description: 'A node for testing invalid parameter type',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
         expect(() => node.setParams("chainId", "invalid")).to.throw('Invalid type for parameter chainId. Expected integer.');
     });
@@ -105,7 +118,8 @@ describe('Node Class', () => {
             id: 8,
             name: 'Test Node for Invalid Address',
             description: 'A node for testing invalid address',
-            parameters: DEFAULT_PARAMETERS
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
         });
         expect(() => node.setParams("contractAddress", "invalid_address")).to.throw('Invalid type for parameter contractAddress. Expected address.');
     });

package/dist/types/src/index.d.ts

@@ -7,4 +7,5 @@ export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
 export * from './models/Node.js';
+export * from './models/Edge.js';
 export * from './services/ApiService.js';

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

@@ -1,12 +1,12 @@
 import { Parameter } from './Parameter.js';
-import { Node } from './Node.js';
+import { Node, Position } from './Node.js';
 export declare class Action extends Node {
     constructor(action: {
         id: number;
         name: string;
         description: string;
         parameters: Parameter[];
-        x?: number;
-        y?: number;
+        ref?: string;
+        position?: Position;
     });
 }

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

@@ -1,19 +1,21 @@
-import { Trigger } from './Trigger.js';
-import { Action } from './Action.js';
+import { Node } from './Node.js';
+import { Edge } from './Edge.js';
 export declare class Automation {
     name: string;
-    trigger: Trigger;
-    actions: Action[];
-    constructor(name: string, trigger: Trigger, actions?: Action[]);
+    nodes: Node[];
+    edges: Edge[];
+    constructor(name: string, nodes?: Node[], edges?: Edge[]);
     setName(name: string): void;
-    addTrigger(trigger: Trigger): void;
-    addAction(action: Action): void;
+    addNode(node: Node): void;
+    addNodes(nodes: Node[]): void;
+    addEdge(edge: Edge): void;
+    addEdges(edges: Edge[]): void;
     toJSON(): {
         name: string;
-        trigger: {
+        nodes: {
             [key: string]: any;
-        };
-        actions: {
+        }[];
+        edges: {
             [key: string]: any;
         }[];
     };

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

@@ -0,0 +1,14 @@
+import { Node } from './Node.js';
+export declare class Edge {
+    id: string;
+    source: Node;
+    target: Node;
+    constructor(edge: {
+        id?: string;
+        source: Node;
+        target: Node;
+    });
+    toJSON(): {
+        [key: string]: any;
+    };
+}

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

@@ -1,4 +1,8 @@
 import { Parameter } from './Parameter.js';
+export interface Position {
+    x: number;
+    y: number;
+}
 export declare class Node {
     id: number;
     name: string;
@@ -9,20 +13,23 @@ export declare class Node {
     keyMap: {
         [key: string]: string;
     };
-    x?: number;
-    y?: number;
+    position?: Position;
+    ref: string;
+    class: string;
     constructor(node: {
         id: number;
         name: string;
         description: string;
         parameters: Parameter[];
-        x?: number;
-        y?: number;
+        ref?: string;
+        position?: Position;
+        class: string;
     });
     setChainId(value: number): void;
     setContractAddress(value: string): void;
     setParams(key: string, value: any): void;
-    setCoordinates(x: number, y: number): void;
+    setPosition(x: number, y: number): void;
+    getRef(): string;
     protected setParameter(key: string, value: any): void;
     getParameter(key: string): any;
     getParameters(): {

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

@@ -1,5 +1,5 @@
 import { Parameter } from './Parameter.js';
-import { Node } from './Node.js';
+import { Node, Position } from './Node.js';
 export declare class Trigger extends Node {
     type: number;
     constructor(trigger: {
@@ -8,8 +8,8 @@ export declare class Trigger extends Node {
         description: string;
         type: number;
         parameters: Parameter[];
-        x?: number;
-        y?: number;
+        ref?: string;
+        position?: Position;
     });
     setCondition(value: string): void;
     setComparisonValue(value: number): void;

package/examples/create-automation.ts

@@ -1,21 +1,41 @@
-import { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken } from '../src/index.js';
+import { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken, Edge } from '../src/index.js';
 
 const main = async () => {
-    const usdcTransferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+    const usdcTransferTrigger = new Trigger({
+        id: TRIGGERS.TOKENS.ERC20.TRANSFER.id,
+        name: TRIGGERS.TOKENS.ERC20.TRANSFER.name,
+        description: TRIGGERS.TOKENS.ERC20.TRANSFER.description,
+        type: TRIGGERS.TOKENS.ERC20.TRANSFER.type,
+        parameters: TRIGGERS.TOKENS.ERC20.TRANSFER.parameters,
+        ref: 'n-1',
+    });
     usdcTransferTrigger.setChainId(CHAINS.ETHEREUM);
     usdcTransferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-    usdcTransferTrigger.setCoordinates(0, 0);
+    usdcTransferTrigger.setPosition(0, 0);
 
-    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    const slackAction = new Action({
+        id: ACTIONS.NOTIFICATIONS.SLACK.id,
+        name: ACTIONS.NOTIFICATIONS.SLACK.name,
+        description: ACTIONS.NOTIFICATIONS.SLACK.description,
+        parameters: ACTIONS.NOTIFICATIONS.SLACK.parameters,
+        // not forced to provide a ref id, it will generate it
+    });
     slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
     slackAction.setParams("text", "USDC has been transferred!");
-    slackAction.setCoordinates(0, -10);
+    slackAction.setPosition(0, -10);
 
-    const automation = new Automation("USDC Transfer Notification", usdcTransferTrigger, [slackAction]);
+    const automation = new Automation("USDC Transfer Notification", [usdcTransferTrigger, slackAction]);
+
+    const edge = new Edge({
+        source: usdcTransferTrigger,
+        target: slackAction,
+    });
+
+    automation.addEdge(edge);
 
     console.log(JSON.stringify(automation.toJSON(), null, 2));
 
-    await automation.save();
+    //await automation.save();
 }
 
-main();
+main();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "otomato-sdk",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "npx tsc",
-    "test": "mocha --config .mocharc.json"
+    "test": "mocha --config .mocharc.json",
+    "publish": "npm publish"
   },
   "keywords": [
     "sdk",
@@ -34,4 +35,4 @@
     "axios": "^1.7.2",
     "ethers": "^6.13.0"
   }
-}
+}

package/src/constants/json.json

@@ -0,0 +1,16 @@
+{
+    "id": 1,
+    "refId": "n-1",
+    "data": {
+        "parameters": {
+            "chainId": 1,
+            "abiParams.value": null,
+            "abiParams.to": null,
+            "contractAddress": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+        },
+    },
+    "position": {
+        "x": 0,
+        "y": 0
+    }
+}

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
 export * from './models/Node.js';
+export * from './models/Edge.js';
 
 // Exporting services
 export * from './services/ApiService.js';

package/src/models/Action.ts

@@ -1,8 +1,8 @@
 import { Parameter } from './Parameter.js';
-import { Node } from './Node.js';
+import { Node, Position } from './Node.js';
 
 export class Action extends Node {
-  constructor(action: { id: number; name: string; description: string; parameters: Parameter[], x?: number, y?: number }) {
-    super(action);
+  constructor(action: { id: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position }) {
+    super({ ...action, class: 'action' });
   }
-}
+}

package/src/models/Automation.ts

@@ -1,39 +1,47 @@
-import { Trigger } from './Trigger.js';
-import { Action } from './Action.js';
+import { Node } from './Node.js';
+import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
 
 export class Automation {
   name: string;
-  trigger: Trigger;
-  actions: Action[];
+  nodes: Node[];
+  edges: Edge[];
 
-  constructor(name: string, trigger: Trigger, actions: Action[] = []) {
+  constructor(name: string, nodes: Node[] = [], edges: Edge[] = []) {
     this.name = name;
-    this.trigger = trigger;
-    this.actions = actions;
+    this.nodes = nodes;
+    this.edges = edges;
   }
 
   setName(name: string): void {
     this.name = name;
   }
 
-  addTrigger(trigger: Trigger): void {
-    this.trigger = trigger;
+  addNode(node: Node): void {
+    this.nodes.push(node);
   }
 
-  addAction(action: Action): void {
-    this.actions.push(action);
+  addNodes(nodes: Node[]): void {
+    this.nodes.push(...nodes);
+  }
+
+  addEdge(edge: Edge): void {
+    this.edges.push(edge);
+  }
+
+  addEdges(edges: Edge[]): void {
+    this.edges.push(...edges);
   }
 
   toJSON() {
     return {
       name: this.name,
-      trigger: this.trigger.toJSON(),
-      actions: this.actions.map(action => action.toJSON()),
+      nodes: this.nodes.map(node => node.toJSON()),
+      edges: this.edges.map(edge => edge.toJSON()),
     };
   }
 
   async save() {
     return apiServices.post('/workflows', this.toJSON());
   }
-}
+}

package/src/models/Edge.ts

@@ -0,0 +1,33 @@
+import { Node } from './Node.js';
+
+let edgeCounter = 0;
+const generatedEdgeIds = new Set<string>();
+
+export class Edge {
+    id: string;
+    source: Node;
+    target: Node;
+
+    constructor(edge: { id?: string, source: Node, target: Node }) {
+        if (edge.id) {
+            this.id = edge.id;
+        } else {
+            this.id = `e-${++edgeCounter}`;
+            while (generatedEdgeIds.has(this.id)) {
+                this.id = `e-${++edgeCounter}`;
+            }
+        }
+        generatedEdgeIds.add(this.id);
+
+        this.source = edge.source;
+        this.target = edge.target;
+    }
+
+    toJSON(): { [key: string]: any } {
+        return {
+            id: this.id,
+            source: this.source.getRef(),
+            target: this.target.getRef(),
+        };
+    }
+}

package/src/models/Node.ts

@@ -1,28 +1,51 @@
 import { Parameter } from './Parameter.js';
 import { validateType } from '../utils/typeValidator.js';
 
+export interface Position {
+  x: number;
+  y: number;
+}
+
+let nodeCounter = 0;
+const generatedRefs = new Set<string>();
+
 export class Node {
   id: number;
   name: string;
   description: string;
   parameters: { [key: string]: Parameter };
   keyMap: { [key: string]: string };
-  x?: number;
-  y?: number;
+  position?: Position;
+  ref: string;
+  class: string;  // Updated to use class instead of type
 
-  constructor(node: { id: number; name: string; description: string; parameters: Parameter[], x?: number, y?: number }) {
+  constructor(node: { id: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string }) {
     this.id = node.id;
     this.name = node.name;
     this.description = node.description;
     this.parameters = {};
     this.keyMap = {};
+    this.class = node.class;  // Set class property
+
+    if (node.ref) {
+      this.ref = node.ref;
+    } else {
+      this.ref = `n-${++nodeCounter}`;
+      while (generatedRefs.has(this.ref)) {
+        this.ref = `n-${++nodeCounter}`;
+      }
+    }
+    generatedRefs.add(this.ref);
+
     node.parameters.forEach(param => {
       this.parameters[param.key] = { ...param, value: null };
       const simplifiedKey = this.getSimplifiedKey(param.key);
       this.keyMap[simplifiedKey] = param.key;
     });
-    this.x = node.x;
-    this.y = node.y;
+
+    if (node.position) {
+      this.position = node.position;
+    }
   }
 
   setChainId(value: number): void {
@@ -38,9 +61,12 @@ export class Node {
     this.setParameter(fullKey, value);
   }
 
-  setCoordinates(x: number, y: number): void {
-    this.x = x;
-    this.y = y;
+  setPosition(x: number, y: number): void {
+    this.position = { x, y };
+  }
+
+  getRef(): string {
+    return this.ref;
   }
 
   protected setParameter(key: string, value: any): void {
@@ -74,10 +100,15 @@ export class Node {
   toJSON(): { [key: string]: any } {
     const json: { [key: string]: any } = {
       id: this.id,
-      parameters: this.getParameters(),
+      ref: this.ref,
+      type: this.class,
+      data: {
+        parameters: this.getParameters(),
+      }
     };
-    if (this.x !== undefined) json.x = this.x;
-    if (this.y !== undefined) json.y = this.y;
+    if (this.position) {
+      json.position = this.position;
+    }
     return json;
   }
 

package/src/models/Trigger.ts

@@ -1,11 +1,11 @@
 import { Parameter } from './Parameter.js';
-import { Node } from './Node.js';
+import { Node, Position } from './Node.js';
 
 export class Trigger extends Node {
   type: number;
 
-  constructor(trigger: { id: number; name: string; description: string; type: number; parameters: Parameter[], x?: number, y?: number }) {
-    super(trigger);
+  constructor(trigger: { id: number; name: string; description: string; type: number; parameters: Parameter[], ref?: string, position?: Position }) {
+    super({ ...trigger, class: 'trigger' });
     this.type = trigger.type;
   }
 
@@ -29,4 +29,4 @@ export class Trigger extends Node {
     }
     this.setParameter('interval', value);
   }
-}
+}

package/test/automation.spec.ts

@@ -9,24 +9,26 @@ describe('Automation Class', () => {
     const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     trigger.setChainId(CHAINS.ETHEREUM);
     trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    trigger.setPosition(0, 0);
 
     const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
     action1.setChainId(CHAINS.ETHEREUM);
     action1.setParams("value", 1000);
     action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
     action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    action1.setPosition(1, 0);
 
     const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
     action2.setParams("phoneNumber", "+1234567890");
     action2.setParams("text", "This is a test message");
+    action2.setPosition(2, 0);
 
-    const automation = new Automation("Test Automation", trigger, [action1, action2]);
+    const automation = new Automation("Test Automation", [trigger, action1, action2]);
 
     const json = automation.toJSON();
     expect(json).to.deep.equal({
       name: "Test Automation",
-      trigger: trigger.toJSON(),
-      actions: [action1.toJSON(), action2.toJSON()],
+      nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
     });
   });
 
@@ -34,8 +36,9 @@ describe('Automation Class', () => {
     const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     trigger.setChainId(CHAINS.ETHEREUM);
     trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    trigger.setPosition(0, 0);
 
-    const automation = new Automation("Initial Name", trigger);
+    const automation = new Automation("Initial Name", [trigger]);
     automation.setName("Updated Name");
 
     expect(automation.name).to.equal("Updated Name");
@@ -45,36 +48,41 @@ describe('Automation Class', () => {
     const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     initialTrigger.setChainId(CHAINS.ETHEREUM);
     initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    initialTrigger.setPosition(0, 0);
 
     const newTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     newTrigger.setChainId(CHAINS.ETHEREUM);
     newTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    newTrigger.setPosition(1, 0);
 
-    const automation = new Automation("Test Automation", initialTrigger);
-    automation.addTrigger(newTrigger);
+    const automation = new Automation("Test Automation", [initialTrigger]);
+    automation.addNode(newTrigger);
 
-    expect(automation.trigger).to.deep.equal(newTrigger);
+    expect(automation.nodes).to.deep.equal([initialTrigger, newTrigger]);
   });
 
   it('should add actions to the automation', () => {
     const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     trigger.setChainId(CHAINS.ETHEREUM);
     trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    trigger.setPosition(0, 0);
 
     const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
     action1.setChainId(CHAINS.ETHEREUM);
     action1.setParams("value", 1000);
     action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
     action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    action1.setPosition(1, 0);
 
     const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
     action2.setParams("phoneNumber", "+1234567890");
     action2.setParams("text", "This is a test message");
+    action2.setPosition(2, 0);
 
-    const automation = new Automation("Test Automation", trigger);
-    automation.addAction(action1);
-    automation.addAction(action2);
+    const automation = new Automation("Test Automation", [trigger]);
+    automation.addNode(action1);
+    automation.addNode(action2);
 
-    expect(automation.actions).to.deep.equal([action1, action2]);
+    expect(automation.nodes).to.deep.equal([trigger, action1, action2]);
   });
 });

package/test/node.spec.ts

@@ -13,11 +13,11 @@ describe('Node Class', () => {
       id: 1,
       name: 'Test Node',
       description: 'A node for testing',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
 
-    expect(node.x).to.be.undefined;
-    expect(node.y).to.be.undefined;
+    expect(node.position).to.be.undefined;
   });
 
   it('should create a node with coordinates', () => {
@@ -26,12 +26,12 @@ describe('Node Class', () => {
       name: 'Test Node with Coordinates',
       description: 'A node for testing with coordinates',
       parameters: DEFAULT_PARAMETERS,
-      x: 100,
-      y: 200
+      class: 'testClass',
+      position: {x: 100, y: 200}
     });
 
-    expect(node.x).to.equal(100);
-    expect(node.y).to.equal(200);
+    expect(node.position?.x).to.equal(100);
+    expect(node.position?.y).to.equal(200);
   });
 
   it('should set and get coordinates correctly', () => {
@@ -39,12 +39,13 @@ describe('Node Class', () => {
       id: 3,
       name: 'Test Node for Coordinates',
       description: 'A node for testing coordinate setting',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
 
-    node.setCoordinates(300, 400);
-    expect(node.x).to.equal(300);
-    expect(node.y).to.equal(400);
+    node.setPosition(300, 400);
+    expect(node.position?.x).to.equal(300);
+    expect(node.position?.y).to.equal(400);
   });
 
   it('should create a node and set parameters correctly', () => {
@@ -52,7 +53,8 @@ describe('Node Class', () => {
       id: 4,
       name: 'Test Node for Parameters',
       description: 'A node for testing parameter setting',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
 
     node.setChainId(1);
@@ -68,7 +70,8 @@ describe('Node Class', () => {
       id: 5,
       name: 'Test Node for JSON',
       description: 'A node for testing JSON export',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
 
     node.setChainId(1);
@@ -77,9 +80,13 @@ describe('Node Class', () => {
     const json = node.toJSON();
     expect(json).to.deep.equal({
       id: 5,
-      parameters: {
-        chainId: 1,
-        contractAddress: "0x0000000000000000000000000000000000000000"
+      ref: node.getRef(),
+      class: 'testClass',
+      data: {
+        parameters: {
+          chainId: 1,
+          contractAddress: "0x0000000000000000000000000000000000000000"
+        }
       }
     });
   });
@@ -90,8 +97,8 @@ describe('Node Class', () => {
       name: 'Test Node for JSON with Coordinates',
       description: 'A node for testing JSON export with coordinates',
       parameters: DEFAULT_PARAMETERS,
-      x: 100,
-      y: 200
+      class: 'testClass',
+      position: {x: 1, y: 2}
     });
 
     node.setChainId(1);
@@ -100,12 +107,15 @@ describe('Node Class', () => {
     const json = node.toJSON();
     expect(json).to.deep.equal({
       id: 6,
-      parameters: {
-        chainId: 1,
-        contractAddress: "0x0000000000000000000000000000000000000000"
+      ref: node.getRef(),
+      class: 'testClass',
+      data: {
+        parameters: {
+          chainId: 1,
+          contractAddress: "0x0000000000000000000000000000000000000000"
+        }
       },
-      x: 100,
-      y: 200
+      position: {x: 1, y: 2}
     });
   });
 
@@ -114,7 +124,8 @@ describe('Node Class', () => {
       id: 7,
       name: 'Test Node for Invalid Parameter Type',
       description: 'A node for testing invalid parameter type',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
     expect(() => node.setParams("chainId", "invalid")).to.throw('Invalid type for parameter chainId. Expected integer.');
   });
@@ -124,7 +135,8 @@ describe('Node Class', () => {
       id: 8,
       name: 'Test Node for Invalid Address',
       description: 'A node for testing invalid address',
-      parameters: DEFAULT_PARAMETERS
+      parameters: DEFAULT_PARAMETERS,
+      class: 'testClass'
     });
     expect(() => node.setParams("contractAddress", "invalid_address")).to.throw('Invalid type for parameter contractAddress. Expected address.');
   });