Merge pull request #46 from FlowTestAI/send-http-request

Ability to send http requests for graph run

Author: jsajal

packages/flowtest-electron/package.json

@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",
+    "axios": "^1.6.7",
     "chokidar": "^3.6.0",
     "dotenv": "^16.4.5",
     "electron-store": "^8.1.0",

packages/flowtest-electron/src/ipc/collection.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const axios = require('axios');
 const { ipcMain, shell, dialog, app } = require('electron');
 const SwaggerParser = require('@apidevtools/swagger-parser');
 const JsonRefs = require('json-refs');
@@ -17,6 +18,22 @@ const readFile = require('../utils/filemanager/readfile');
 
 const collectionStore = new Collections();
 
+const timeout = 60000;
+
+const newAbortSignal = () => {
+  const abortController = new AbortController();
+  setTimeout(() => abortController.abort(), timeout || 0);
+
+  return abortController.signal;
+};
+
+/** web platform: blob. */
+const convertBase64ToBlob = async (base64) => {
+  const response = await fetch(base64);
+  const blob = await response.blob();
+  return blob;
+};
+
 const registerRendererEventHandlers = (mainWindow, watcher) => {
   ipcMain.handle('renderer:open-directory-selection-dialog', async (event, arg) => {
     try {
@@ -189,6 +206,47 @@ const registerRendererEventHandlers = (mainWindow, watcher) => {
       return Promise.reject(error);
     }
   });
+
+  ipcMain.handle('renderer:run-http-request', async (event, request) => {
+    try {
+      if (request.headers['Content-type'] === 'multipart/form-data') {
+        const requestData = new FormData();
+        const file = await convertBase64ToBlob(request.data.value);
+        requestData.append(request.data.key, file, request.data.name);
+
+        request.data = requestData;
+      }
+
+      // assuming 'application/json' type
+      const options = {
+        ...request,
+        signal: newAbortSignal(),
+      };
+
+      const result = await axios(options);
+      return {
+        status: result.status,
+        statusText: result.statusText,
+        data: result.data,
+      };
+    } catch (error) {
+      if (error?.response) {
+        return {
+          error: {
+            status: error.response.status,
+            statusText: error.response.statusText,
+            data: error.response.data,
+          },
+        };
+      } else {
+        return {
+          error: {
+            message: 'An unknown error occurred while running the request',
+          },
+        };
+      }
+    }
+  });
 };
 
 module.exports = registerRendererEventHandlers;

src/components/molecules/flow/graph/Graph.js

@@ -1,195 +1,24 @@
-import Operators from '../constants/operators.js';
-
 // assumption is that apis are giving json as output
 
+import { computeEvaluateNode } from './compute/evaluatenode';
+import { computeRequestNode } from './compute/requestnode';
+
 class Graph {
-  constructor(nodes, edges, onGraphComplete, authKey, runRequest) {
+  constructor(nodes, edges, onGraphComplete) {
     this.nodes = nodes;
     this.edges = edges;
     this.onGraphComplete = onGraphComplete;
-    this.authKey = authKey;
-    this.runRequest = runRequest;
     this.logs = [];
     this.timeout = 60000; // 1m timeout
     this.startTime = Date.now();
     this.graphRunNodeOutput = {};
+    this.auth = undefined;
   }
 
   #checkTimeout() {
     return Date.now() - this.startTime > this.timeout;
   }
 
-  #formulateRequest(node, finalUrl) {
-    let restMethod = node.data.requestType.toLowerCase();
-    let contentType = 'application/json';
-    let requestData = undefined;
-
-    if (restMethod === 'get') {
-      if (node.data.requestBody) {
-        if (node.data.requestBody.type === 'raw-json') {
-          contentType = 'application/json';
-          requestData = node.data.requestBody.body ? JSON.parse(node.data.requestBody.body) : JSON.parse('{}');
-        }
-      }
-    } else if (restMethod === 'post' || restMethod === 'put') {
-      if (node.data.requestBody) {
-        if (node.data.requestBody.type === 'form-data') {
-          contentType = 'multipart/form-data';
-          requestData = {
-            key: node.data.requestBody.body.key,
-            value: node.data.requestBody.body.value,
-            name: node.data.requestBody.body.name,
-          };
-        } else if (node.data.requestBody.type === 'raw-json') {
-          contentType = 'application/json';
-          requestData = node.data.requestBody.body ? JSON.parse(node.data.requestBody.body) : JSON.parse('{}');
-        }
-      }
-    }
-
-    const options = {
-      method: restMethod,
-      url: finalUrl,
-      headers: {
-        'Content-type': contentType,
-      },
-      data: requestData,
-      auth: {
-        username: this.authKey ? this.authKey.accessId : '',
-        password: this.authKey ? this.authKey.accessKey : '',
-      },
-    };
-
-    this.logs.push(`${restMethod} ${finalUrl}`);
-    return options;
-  }
-
-  #computeNodeVariable(variable, prevNodeOutputData) {
-    if (variable.type.toLowerCase() === 'string') {
-      return variable.value;
-    }
-
-    if (variable.type.toLowerCase() === 'number') {
-      return variable.value;
-    }
-
-    if (variable.type.toLowerCase() === 'bool') {
-      return Boolean(variable.value);
-    }
-
-    if (variable.type.toLowerCase() === 'select') {
-      if (prevNodeOutputData == undefined || Object.keys(prevNodeOutputData).length === 0) {
-        this.logs.push(
-          `Cannot evaluate variable ${variable} as previous node output data ${JSON.stringify(prevNodeOutputData)} is empty`,
-        );
-        throw 'Error evaluating node variables';
-      }
-      const jsonTree = variable.value.split('.');
-      const getVal = (parent, pos) => {
-        if (pos == jsonTree.length) {
-          return parent;
-        }
-        const key = jsonTree[pos];
-        if (key == '') {
-          return parent;
-        }
-
-        return getVal(parent[key], pos + 1);
-      };
-      const result = getVal(prevNodeOutputData, 0);
-      if (result == undefined) {
-        this.logs.push(
-          `Cannot evaluate variable ${JSON.stringify(variable)} as previous node output data ${JSON.stringify(prevNodeOutputData)} did not contain the variable`,
-        );
-        throw 'Error evaluating node variables';
-      }
-      return result;
-    }
-  }
-
-  #computeNodeVariables(variables, prevNodeOutputData) {
-    let evalVariables = {};
-    Object.entries(variables).map(([vname, variable], index) => {
-      evalVariables[vname] = this.#computeNodeVariable(variable, prevNodeOutputData);
-    });
-    return evalVariables;
-  }
-
-  async #computeRequestNode(node, prevNodeOutputData) {
-    try {
-      // step1 evaluate variables of this node
-      const evalVariables = this.#computeNodeVariables(node.data.variables, prevNodeOutputData);
-
-      // step2 replace variables in url with value
-      let finalUrl = node.data.url;
-      Object.entries(evalVariables).map(([vname, vvalue], index) => {
-        finalUrl = finalUrl.replace(`{${vname}}`, vvalue);
-      });
-
-      // step 3
-      const options = this.#formulateRequest(node, finalUrl);
-
-      console.debug('Evaluated variables: ', evalVariables);
-      console.debug('Evaluated Url: ', finalUrl);
-      //const res = await axios(options);
-      const res = await this.runRequest(JSON.stringify(options));
-      this.logs.push(`Request successful: ${JSON.stringify(res.data)}`);
-      console.debug('Response: ', res);
-      return ['Success', node, res];
-    } catch (error) {
-      console.debug('Failure at node: ', node);
-      console.debug('Error encountered: ', error);
-      if (error.response) {
-        // The request was made and the server responded with a status code
-        // that falls out of the range of 2xx
-        console.debug(error.response.data);
-        console.debug(error.response.status);
-        console.debug(error.response.headers);
-        this.logs.push(
-          `Request failed. Status: ${error.response.status}, Data: ${JSON.stringify(error.response.data)}`,
-        );
-      } else if (error.request) {
-        // The request was made but no response was received
-        // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
-        // http.ClientRequest in node.js
-        console.debug('Response: ', error.request);
-        this.logs.push(`Request failed: ${error.request}`);
-      } else if (error.message) {
-        // Something happened in setting up the request that triggered an Error
-        console.debug('Response: ', error.message);
-        this.logs.push(`Request failed: ${error.message}`);
-      } else {
-        // Something not related to axios request
-        console.debug('Failure: ', error);
-        this.logs.push(`Request failed: ${error}`);
-      }
-      return ['Failed', node, error];
-    }
-  }
-
-  #computeEvaluateNode(node, prevNodeOutputData) {
-    const evalVariables = this.#computeNodeVariables(node.data.variables, prevNodeOutputData);
-    const var1 = evalVariables.var1;
-    const var2 = evalVariables.var2;
-
-    const operator = node.data.operator;
-    if (operator == undefined) {
-      throw 'Operator undefined';
-    }
-    this.logs.push(
-      `Evaluate var1: ${JSON.stringify(var1)} of type: ${typeof var1}, var2: ${JSON.stringify(var2)} of type: ${typeof var2} with operator: ${operator}`,
-    );
-    if (operator == Operators.isEqualTo) {
-      return var1 === var2;
-    } else if (operator == Operators.isNotEqualTo) {
-      return var1 != var2;
-    } else if (operator == Operators.isGreaterThan) {
-      return var1 > var2;
-    } else if (operator == Operators.isLessThan) {
-      return var1 < var2;
-    }
-  }
-
   #computeConnectingEdge(node, result) {
     let connectingEdge = undefined;
 
@@ -238,7 +67,7 @@ class Graph {
       }
 
       if (node.type === 'evaluateNode') {
-        if (this.#computeEvaluateNode(node, prevNodeOutputData)) {
+        if (computeEvaluateNode(node, prevNodeOutputData, this.logs)) {
           this.logs.push('Result: true');
           result = ['Success', node, prevNodeOutput, true];
         } else {
@@ -257,8 +86,13 @@ class Graph {
         result = ['Success', node, prevNodeOutput];
       }
 
+      if (node.type === 'authNode') {
+        this.auth = node.data.auth;
+        result = ['Success', node, prevNodeOutput];
+      }
+
       if (node.type === 'requestNode') {
-        result = await this.#computeRequestNode(node, prevNodeOutputData);
+        result = await computeRequestNode(node, prevNodeOutputData, this.auth, this.logs);
       }
 
       if (this.#checkTimeout()) {
@@ -278,7 +112,7 @@ class Graph {
       if (connectingEdge != undefined) {
         const nextNode = this.nodes.find(
           (node) =>
-            ['requestNode', 'outputNode', 'evaluateNode', 'delayNode'].includes(node.type) &&
+            ['requestNode', 'outputNode', 'evaluateNode', 'delayNode', 'authNode'].includes(node.type) &&
             node.id === connectingEdge.target,
         );
         this.graphRunNodeOutput[node.id] = result[2] && result[2].data ? result[2].data : {};
@@ -298,7 +132,6 @@ class Graph {
     });
     this.graphRunNodeOutput = {};
 
-    console.debug('Using authkey: ', this.authKey);
     this.logs.push('Start Flowtest');
     const startNode = this.nodes.find((node) => node.type === 'startNode');
     if (startNode == undefined) {
@@ -317,6 +150,7 @@ class Graph {
         }
         this.logs.push('End Flowtest');
         this.logs.push(`Total time: ${Date.now() - this.startTime} ms`);
+        console.log(this.logs);
         this.onGraphComplete(result, this.logs);
       });
     } else {

src/components/molecules/flow/graph/compute/evaluatenode.js

@@ -0,0 +1,25 @@
+import Operators from '../../constants/operators';
+import { computeNodeVariables } from './utils';
+
+export const computeEvaluateNode = (node, prevNodeOutputData, logs) => {
+  const evalVariables = computeNodeVariables(node.data.variables, prevNodeOutputData);
+  const var1 = evalVariables.var1;
+  const var2 = evalVariables.var2;
+
+  const operator = node.data.operator;
+  if (operator == undefined) {
+    throw 'Operator undefined';
+  }
+  logs.push(
+    `Evaluate var1: ${JSON.stringify(var1)} of type: ${typeof var1}, var2: ${JSON.stringify(var2)} of type: ${typeof var2} with operator: ${operator}`,
+  );
+  if (operator == Operators.isEqualTo) {
+    return var1 === var2;
+  } else if (operator == Operators.isNotEqualTo) {
+    return var1 != var2;
+  } else if (operator == Operators.isGreaterThan) {
+    return var1 > var2;
+  } else if (operator == Operators.isLessThan) {
+    return var1 < var2;
+  }
+};