compute set variable node in graph run

Author: jsajal

src/components/molecules/flow/constants/evaluateOperators.js

@@ -1,6 +1,6 @@
 const EvaluateOperators = {
-  Add: '+',
-  Subtract: '-',
+  Add: 'Add two numbers',
+  Subtract: 'Subtract two numbers',
 };
 
 export default EvaluateOperators;

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

@@ -7,6 +7,7 @@ import authNode from './compute/authnode';
 import complexNode from './compute/complexnode';
 import assertNode from './compute/assertnode';
 import requestNode from './compute/requestNode';
+import setVarNode from './compute/setvarnode';
 
 class Graph {
   constructor(nodes, edges, startTime, initialEnvVars, initialLogs) {
@@ -150,6 +151,21 @@ class Graph {
         }
       }
 
+      if (node.type === 'setVarNode') {
+        const sNode = new setVarNode(node.data, prevNodeOutputData, this.envVariables);
+        const newVariable = sNode.evaluate();
+        if (newVariable != undefined) {
+          this.logs.push(`Evaluate variable: ${newVariable}`);
+          this.envVariables = {
+            ...this.envVariables,
+            ...newVariable,
+          };
+        }
+        result = {
+          status: 'Success',
+        };
+      }
+
       if (this.#checkTimeout()) {
         throw `Timeout of ${this.timeout} ms exceeded, stopping graph run`;
       }
@@ -171,8 +187,9 @@ class Graph {
       if (connectingEdge != undefined) {
         const nextNode = this.nodes.find(
           (node) =>
-            ['requestNode', 'outputNode', 'assertNode', 'delayNode', 'authNode', 'complexNode'].includes(node.type) &&
-            node.id === connectingEdge.target,
+            ['requestNode', 'outputNode', 'assertNode', 'delayNode', 'authNode', 'complexNode', 'setVarNode'].includes(
+              node.type,
+            ) && node.id === connectingEdge.target,
         );
         this.graphRunNodeOutput[node.id] = result.data ? result.data : {};
         return this.#computeNode(nextNode);

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

@@ -0,0 +1,68 @@
+import { computeNodeVariable } from './utils';
+import Node from './node';
+import EvaluateOperators from '../../constants/evaluateOperators';
+
+class setVarNode extends Node {
+  constructor(nodeData, prevNodeOutputData, envVariables) {
+    super('setVarNode');
+    this.nodeData = nodeData;
+    this.prevNodeOutputData = prevNodeOutputData;
+    this.envVariables = envVariables;
+  }
+
+  getVariableValue(variable) {
+    if (variable.type.toLowerCase() === 'variable') {
+      if (Object.prototype.hasOwnProperty.call(this.envVariables, variable.value)) {
+        return this.envVariables[variable.value];
+      } else {
+        throw Error(`Cannot find value of variable ${variable.value}`);
+      }
+    } else {
+      return computeNodeVariable(variable, this.prevNodeOutputData);
+    }
+  }
+
+  evaluate() {
+    console.log('Evaluating set variable node');
+    if (this.nodeData.variable) {
+      if (this.nodeData.variable.name && this.nodeData.variable.name.trim() != '') {
+        const vName = this.nodeData.variable.name;
+        const vType = this.nodeData.variable.type.trim();
+        if (['String', 'Number', 'Boolean', 'Now', 'Select'].includes(vType)) {
+          const value = computeNodeVariable(this.nodeData.variable, this.prevNodeOutputData);
+          return {
+            [vName]: value,
+          };
+        } else if (vType === 'Expression') {
+          const variables = this.nodeData.variable.value.variables;
+          if (variables && variables.var1 && variables.var2) {
+            const var1 = this.getVariableValue(this.nodeData.variable.value.variables.var1);
+            const var2 = this.getVariableValue(this.nodeData.variable.value.variables.var2);
+
+            const operator = this.nodeData.variable.value.operator;
+            if (operator == undefined) {
+              throw 'Operator undefined';
+            }
+            if (operator == EvaluateOperators.Add) {
+              if (typeof var1 !== 'number' || typeof var2 !== 'number') {
+                throw Error(`Cannot perform ${typeof var1} + ${typeof var2}`);
+              }
+              return {
+                [vName]: var1 + var2,
+              };
+            } else if (operator == EvaluateOperators.Subtract) {
+              if (typeof var1 !== 'number' || typeof var2 !== 'number') {
+                throw Error(`Cannot perform ${typeof var1} + ${typeof var2}`);
+              }
+              return {
+                [vName]: var1 - var2,
+              };
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+export default setVarNode;

src/components/molecules/flow/nodes/SetVarNode.js

@@ -70,8 +70,11 @@ const SetVarNode = ({ id, data }) => {
           <option value={CHOOSE_OPERATOR_DEFAULT_VALUE_OBJ.value}>
             {CHOOSE_OPERATOR_DEFAULT_VALUE_OBJ.displayValue}
           </option>
-          <option value={EvaluateOperators.Add}>{EvaluateOperators.Add}</option>
-          <option value={EvaluateOperators.Subtract}>{EvaluateOperators.Subtract}</option>
+          {Object.entries(EvaluateOperators).map(([key, value], index) => (
+            <option key={key} value={value}>
+              {value}
+            </option>
+          ))}
         </select>
       </div>
     );