otomato-sdk 1.2.0 → 1.3.0

package/src/index.ts

@@ -5,7 +5,7 @@ export * from './constants/tokens.js';
 
 // Exporting models
 export * from './models/Action.js';
-export * from './models/Automation.js';
+export * from './models/Workflow.js';
 export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';

package/src/models/Action.ts

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

package/src/models/Condition.ts

@@ -1,6 +1,6 @@
 export interface COndition {
-    key: string;
-    type: string;
-    description: string;
-    value: any;
-  }
+  key: string;
+  type: string;
+  description: string;
+  value: any;
+}

package/src/models/Edge.ts

@@ -25,9 +25,15 @@ export class Edge {
 
     toJSON(): { [key: string]: any } {
         return {
-            id: this.id,
             source: this.source.getRef(),
             target: this.target.getRef(),
         };
     }
-}
+
+    static fromJSON(json: { [key: string]: any }): Edge {
+        return new Edge({
+            source: json.source,
+            target: json.target,
+        });
+    }
+}

package/src/models/Node.ts

@@ -1,5 +1,8 @@
+// Assuming you have the ACTIONS constant defined as you provided
+
 import { Parameter } from './Parameter.js';
 import { validateType } from '../utils/typeValidator.js';
+import { ACTIONS, TRIGGERS } from '../constants/Blocks.js';
 
 export interface Position {
   x: number;
@@ -10,23 +13,27 @@ let nodeCounter = 0;
 const generatedRefs = new Set<string>();
 
 export class Node {
-  id: number;
+  id: string | null = null;
+  blockId: number;
   name: string;
   description: string;
   parameters: { [key: string]: Parameter };
   keyMap: { [key: string]: string };
   position?: Position;
   ref: string;
-  class: string;  // Updated to use class instead of type
+  class: string;
+  image: string;
 
-  constructor(node: { id: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string }) {
-    this.id = node.id;
+  constructor(node: { blockId: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string; image: string }) {
+    this.id = null;
+    this.blockId = node.blockId;
     this.name = node.name;
     this.description = node.description;
+    this.image = node.image;
     this.parameters = {};
     this.keyMap = {};
-    this.class = node.class;  // Set class property
-
+    this.class = node.class;
+    
     if (node.ref) {
       this.ref = node.ref;
     } else {
@@ -48,6 +55,10 @@ export class Node {
     }
   }
 
+  setId(id: string): void {
+    this.id = id;
+  }
+
   setChainId(value: number): void {
     this.setParameter('chainId', value);
   }
@@ -92,7 +103,15 @@ export class Node {
 
   getParameters(): { [key: string]: any } {
     return Object.keys(this.parameters).reduce((acc, key) => {
-      acc[key] = this.parameters[key].value;
+      if (key.startsWith('abiParams.')) {
+        const abiKey = key.replace('abiParams.', '');
+        if (!acc.abi) {
+          acc.abi = { parameters: {} };
+        }
+        acc.abi.parameters[abiKey] = this.parameters[key].value;
+      } else {
+        acc[key] = this.parameters[key].value;
+      }
       return acc;
     }, {} as { [key: string]: any });
   }
@@ -101,10 +120,9 @@ export class Node {
     const json: { [key: string]: any } = {
       id: this.id,
       ref: this.ref,
+      blockId: this.blockId,
       type: this.class,
-      data: {
-        parameters: this.getParameters(),
-      }
+      parameters: this.getParameters(),
     };
     if (this.position) {
       json.position = this.position;
@@ -115,4 +133,66 @@ export class Node {
   private getSimplifiedKey(key: string): string {
     return key.replace(/[.\[\]]/g, '_');
   }
+
+  static fromJSON(json: { [key: string]: any }): Node {
+
+    let enriched = findActionByBlockId(json.blockId);
+    if (!enriched) 
+      enriched = findTriggerByBlockId(json.blockId);
+    if (!enriched)
+      enriched = {name: "Unknown", description: "Unknown", image: "Unknown"}
+
+    const parameters = Object.keys(json.parameters).map(key => ({
+      key,
+      type: typeof json.parameters[key], // Assuming type can be derived from the value's type
+      description: '', // Add appropriate description if needed
+      value: json.parameters[key]
+    }));
+    const node = new Node({
+      blockId: json.blockId,
+      name: enriched.name,
+      description: enriched.description,
+      image: enriched.image,
+      parameters,
+      ref: json.ref,
+      position: json.position,
+      class: json.type
+    });
+    node.setId(json.id);
+    return node;
+  }
 }
+
+const findActionByBlockId = (blockId: number): { name: string; description: string; image: string } | null => {
+  for (const category in ACTIONS) {
+    for (const service in (ACTIONS as any)[category]) {
+      for (const actionKey in (ACTIONS as any)[category][service]) {
+        if ((ACTIONS as any)[category][service][actionKey].blockId === blockId) {
+          return {
+            name: (ACTIONS as any)[category][service][actionKey].name,
+            description: (ACTIONS as any)[category][service][actionKey].description,
+            image: (ACTIONS as any)[category][service][actionKey].image,
+          };
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const findTriggerByBlockId = (blockId: number): { name: string; description: string; image: string } | null => {
+  for (const category in TRIGGERS) {
+    for (const service in (TRIGGERS as any)[category]) {
+      for (const triggerKey in (TRIGGERS as any)[category][service]) {
+        if ((TRIGGERS as any)[category][service][triggerKey].blockId === blockId) {
+          return {
+            name: (TRIGGERS as any)[category][service][triggerKey].name,
+            description: (TRIGGERS as any)[category][service][triggerKey].description,
+            image: (TRIGGERS as any)[category][service][triggerKey].image,
+          };
+        }
+      }
+    }
+  }
+  return null;
+};

package/src/models/Parameter.ts

@@ -1,6 +1,6 @@
 export interface Parameter {
-    key: string;
-    type: string;
-    description: string;
-    value: any;
-  }
+  key: string;
+  type: string;
+  description: string;
+  value?: any;
+}

package/src/models/Trigger.ts

@@ -4,29 +4,33 @@ 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[], ref?: string, position?: Position }) {
+  constructor(trigger: { blockId: number; name: string; description: string; type: number; parameters: Parameter[], image: string, ref?: string, position?: Position }) {
     super({ ...trigger, class: 'trigger' });
     this.type = trigger.type;
   }
 
+  private notAPollingTrigger(): boolean {
+    return this.type === 0;
+  }
+
   setCondition(value: string): void {
-    if (this.type !== 1) {
+    if (this.notAPollingTrigger()) {
       throw new Error('Condition setting is not applicable for subscription based triggers.');
     }
     this.setParameter('condition', value);
   }
 
   setComparisonValue(value: number): void {
-    if (this.type !== 1) {
+    if (this.notAPollingTrigger()) {
       throw new Error('Comparison value setting is not applicable for subscription based triggers.');
     }
     this.setParameter('comparisonValue', value);
   }
 
   setInterval(value: number): void {
-    if (this.type !== 1) {
+    if (this.notAPollingTrigger()) {
       throw new Error('Interval setting is not applicable for subscription based triggers.');
     }
     this.setParameter('interval', value);
   }
-}
+}

package/src/models/Workflow.ts

@@ -0,0 +1,69 @@
+import { Node } from './Node.js';
+import { Edge } from './Edge.js';
+import { apiServices } from '../services/ApiService.js';
+
+export class Workflow {
+  id: string | null = null;
+  name: string;
+  nodes: Node[];
+  edges: Edge[];
+
+  constructor(name: string = '', nodes: Node[] = [], edges: Edge[] = []) {
+    this.name = name;
+    this.nodes = nodes;
+    this.edges = edges;
+  }
+
+  setName(name: string): void {
+    this.name = name;
+  }
+
+  addNode(node: Node): void {
+    this.nodes.push(node);
+  }
+
+  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 {
+      id: this.id,
+      name: this.name,
+      nodes: this.nodes.map(node => node.toJSON()),
+      edges: this.edges.map(edge => edge.toJSON()),
+    };
+  }
+
+  async create() {
+    const response = await apiServices.post('/workflows', this.toJSON());
+    this.id = response.id; // Assign the returned ID to the workflow instance
+
+    // Assign IDs to the nodes based on the response
+    response.nodes.forEach((nodeResponse: any) => {
+      const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
+      if (node) {
+        node.setId(nodeResponse.id);
+      }
+    });
+
+    return response;
+  }
+
+  async load(workflowId: string): Promise<Workflow> {
+    const response = await apiServices.get(`/workflows/${workflowId}`);
+    this.id = response.id;
+    this.name = response.name;
+    this.nodes = response.nodes.map((nodeData: any) => Node.fromJSON(nodeData));
+    this.edges = response.edges.map((edgeData: any) => Edge.fromJSON(edgeData));
+    return this;
+  }
+}

package/src/services/ApiService.ts

@@ -2,30 +2,37 @@
 import axios from 'axios';
 
 const API_CONFIG = {
-  BASE_URL: 'http://localhost:3040/api',
+  BASE_URL: 'https://staging-api.otomato.xyz/api',
   HEADERS: {
-    'Content-Type': 'application/json'
+    'Content-Type': 'application/json',
   }
-}
+};
 
 const axiosInstance = axios.create({
   baseURL: API_CONFIG.BASE_URL,
   headers: API_CONFIG.HEADERS
 });
 
-export const apiServices = {
-  async post(endpoint: string, data: any) {
-    try {
-      const response = await axiosInstance.post(endpoint, data);
-      return response.data;
-    } catch (error) {
-      console.error('Network request failed', error);
-      throw error;
-    }
-  },
-
-  // Add other HTTP methods if needed
-  // async get(endpoint: string) { ... }
-  // async put(endpoint: string, data: any) { ... }
-  // async delete(endpoint: string) { ... }
-};
+class ApiServices {
+  private cookie: string | null = null;
+
+  setCookie(cookie: string) {
+    this.cookie = `token=${cookie}`;
+  }
+
+  async post(url: string, data: any) {
+    const headers = this.cookie ? { 'Cookie': this.cookie } : {};
+    const response = await axiosInstance.post(url, data, { headers });
+    return response.data;
+  }
+
+  async get(url: string) {
+    const headers = this.cookie ? { 'Cookie': this.cookie } : {};
+    const response = await axiosInstance.get(url, { headers });
+    return response.data;
+  }
+
+  // You can add other methods (get, put, delete) similarly
+}
+
+export const apiServices = new ApiServices();

package/src/utils/typeValidator.ts

@@ -24,10 +24,11 @@ export function validateType(expectedType: string, value: any): boolean {
             return typeof value === 'string' && isValidUrl(value);
         case 'phone_number':
             return typeof value === 'string' && isValidPhoneNumber(value);
+        case 'string':
         case 'paragraph':
             return typeof value === 'string';
         case 'logic_operator':
-            const validOperators = new Set(['<', '>', '<=', '>=', '==', '!=']);
+            const validOperators = new Set(['gte', 'gt', 'lte', 'lt', 'eq', 'neq']);
             return typeof value === 'string' && validOperators.has(value);
         case 'any':
             return true;

package/test/action.spec.ts

@@ -38,7 +38,9 @@ describe('Action Class', () => {
 
     const json = transferAction.toJSON();
     expect(json).to.deep.equal({
-      id: ACTIONS.TOKENS.ERC20.TRANSFER.id,
+      blockId: ACTIONS.TOKENS.ERC20.TRANSFER.blockId,
+      ref: transferAction.getRef(),
+      type: 'action',
       parameters: {
         chainId: CHAINS.ETHEREUM,
         'abiParams.value': 1000,
@@ -48,7 +50,7 @@ describe('Action Class', () => {
     });
   });
 
-  it('should create an SMS action and set parameters correctly', () => {
+  /*it('should create an SMS action and set parameters correctly', () => {
     const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
     smsAction.setParams("phoneNumber", "+1234567890");
     smsAction.setParams("text", "Hello, this is a test message!");
@@ -56,16 +58,16 @@ describe('Action Class', () => {
     const params = smsAction.getParameters();
     expect(params.phoneNumber).to.equal("+1234567890");
     expect(params.text).to.equal("Hello, this is a test message!");
-  });
+  });*/
 
   it('should create a Slack action and set parameters correctly', () => {
-    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
     slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    slackAction.setParams("text", "This is a test message!");
+    slackAction.setParams("message", "This is a test message!");
 
     const params = slackAction.getParameters();
     expect(params.webhook).to.equal("https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    expect(params.text).to.equal("This is a test message!");
+    expect(params.message).to.equal("This is a test message!");
   });
 
   it('should throw an error for invalid parameter type', () => {
@@ -79,12 +81,12 @@ describe('Action Class', () => {
   });
 
   it('should throw an error for invalid URL', () => {
-    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
     expect(() => slackAction.setParams("webhook", "invalid_url")).to.throw('Invalid type for parameter webhook. Expected url.');
   });
 
-  it('should throw an error for invalid phone number', () => {
+  /*it('should throw an error for invalid phone number', () => {
     const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
     expect(() => smsAction.setParams("phoneNumber", "invalid_phone_number")).to.throw('Invalid type for parameter phoneNumber. Expected phone_number.');
-  });
+  });*/
 });

package/test/automation.spec.ts

@@ -1,11 +1,11 @@
 import { expect } from 'chai';
-import { Automation } from '../src/models/Automation.js';
+import { Workflow } from '../src/models/Workflow.js';
 import { Trigger } from '../src/models/Trigger.js';
 import { Action } from '../src/models/Action.js';
 import { TRIGGERS, ACTIONS, getToken, CHAINS } from '../src/index.js';
 
-describe('Automation Class', () => {
-  it('should create an automation with a trigger and actions', () => {
+describe('Workflow Class', () => {
+  it('should create a workflow with a trigger and actions', () => {
     const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     trigger.setChainId(CHAINS.ETHEREUM);
     trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -18,33 +18,34 @@ describe('Automation Class', () => {
     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 action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
+    action2.setParams("webhook", "https://webhook.url");
+    action2.setParams("message", "This is a test message");
     action2.setPosition(2, 0);
 
-    const automation = new Automation("Test Automation", [trigger, action1, action2]);
+    const workflow = new Workflow("Test Workflow", [trigger, action1, action2]);
 
-    const json = automation.toJSON();
+    const json = workflow.toJSON();
     expect(json).to.deep.equal({
-      name: "Test Automation",
+      name: "Test Workflow",
       nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
+      edges: []
     });
   });
 
-  it('should set the name of the automation', () => {
+  it('should set the name of the workflow', () => {
     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]);
-    automation.setName("Updated Name");
+    const workflow = new Workflow("Initial Name", [trigger]);
+    workflow.setName("Updated Name");
 
-    expect(automation.name).to.equal("Updated Name");
+    expect(workflow.name).to.equal("Updated Name");
   });
 
-  it('should add a trigger to the automation', () => {
+  it('should add a trigger to the workflow', () => {
     const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     initialTrigger.setChainId(CHAINS.ETHEREUM);
     initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -55,13 +56,13 @@ describe('Automation Class', () => {
     newTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
     newTrigger.setPosition(1, 0);
 
-    const automation = new Automation("Test Automation", [initialTrigger]);
-    automation.addNode(newTrigger);
+    const workflow = new Workflow("Test Workflow", [initialTrigger]);
+    workflow.addNode(newTrigger);
 
-    expect(automation.nodes).to.deep.equal([initialTrigger, newTrigger]);
+    expect(workflow.nodes).to.deep.equal([initialTrigger, newTrigger]);
   });
 
-  it('should add actions to the automation', () => {
+  it('should add actions to the workflow', () => {
     const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     trigger.setChainId(CHAINS.ETHEREUM);
     trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -74,15 +75,15 @@ describe('Automation Class', () => {
     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 action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
+    action2.setParams("webhook", "https://webhook.url");
+    action2.setParams("message", "This is a test message");
     action2.setPosition(2, 0);
 
-    const automation = new Automation("Test Automation", [trigger]);
-    automation.addNode(action1);
-    automation.addNode(action2);
+    const workflow = new Workflow("Test Workflow", [trigger]);
+    workflow.addNode(action1);
+    workflow.addNode(action2);
 
-    expect(automation.nodes).to.deep.equal([trigger, action1, action2]);
+    expect(workflow.nodes).to.deep.equal([trigger, action1, action2]);
   });
-});
+});