Merge pull request #117 from FlowTestAI/cli-logs-1

feat: Define logger and ability to upload build scan for cli

Author: jsajal

packages/flowtest-cli/bin/axiosClient.js

@@ -0,0 +1,28 @@
+// lib/axiosClient.ts
+const axios = require('axios');
+const axiosRetry = require('axios-retry').default;
+
+const baseUrl = 'http://localhost:3000';
+
+const axiosClient = axios.create({
+  baseURL: `${baseUrl}/api`,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+axiosRetry(axiosClient, {
+  retries: 3, // Number of retries
+  retryDelay: (retryCount) => {
+    return retryCount * 1000; // Time interval between retries (1000 ms = 1 second)
+  },
+  retryCondition: (error) => {
+    // Retry on network errors or 5xx server errors
+    return error.response?.status === 500 || error.code === 'ECONNABORTED';
+  },
+});
+
+module.exports = {
+  baseUrl,
+  axiosClient,
+};

packages/flowtest-cli/bin/index.js

@@ -8,6 +8,8 @@ const { serialize } = require('../../flowtest-electron/src/utils/flowparser/pars
 const { Graph } = require('../graph/Graph');
 const { cloneDeep } = require('lodash');
 const dotenv = require('dotenv');
+const { GraphLogger, LogLevel } = require('../graph/GraphLogger');
+const { baseUrl, axiosClient } = require('./axiosClient');
 
 const getEnvVariables = (pathname) => {
   const content = readFile(pathname);
@@ -16,6 +18,11 @@ const getEnvVariables = (pathname) => {
   return parsed;
 };
 
+function bytesToBase64(bytes) {
+  const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
+  return btoa(binString);
+}
+
 // Define the CLI application using yargs
 const argv = yargs(hideBin(process.argv))
   .usage('Usage: $0 <command> [options]')
@@ -41,6 +48,10 @@ const argv = yargs(hideBin(process.argv))
           describe: 'timeout for graph run in ms',
           demandOption: false,
           type: 'number',
+        })
+        .option('scan', {
+          alias: 's',
+          describe: 'generate and upload build scan',
         });
     },
     async (argv) => {
@@ -57,13 +68,15 @@ const argv = yargs(hideBin(process.argv))
           const flowData = serialize(JSON.parse(content));
           // output json output to a file
           //console.log(chalk.green(JSON.stringify(flowData)));
+          const logger = new GraphLogger();
           const startTime = Date.now();
           const g = new Graph(
             cloneDeep(flowData.nodes),
             cloneDeep(flowData.edges),
             startTime,
             argv.timeout ? argv.timeout : 60000,
             argv.env ? getEnvVariables(argv.env) : {},
+            logger,
           );
           console.log(chalk.yellow('Running Graph \n'));
           if (flowData.nodes.find((n) => n.type === 'complexNode')) {
@@ -80,7 +93,28 @@ const argv = yargs(hideBin(process.argv))
           } else {
             console.log(chalk.bold('Graph Run: ') + chalk.red(`   ✕ `) + chalk.dim(result.status));
           }
+          logger.add(LogLevel.INFO, `Total time: ${Date.now() - startTime} ms`);
           console.log(chalk.bold('Total Time: ') + chalk.dim(`${Date.now() - startTime} ms`));
+          //console.log(logger.get());
+
+          if (argv.scan) {
+            const data = {
+              version: 1,
+              name: argv.file.toString(),
+              scan: logger.get(),
+            };
+            try {
+              const response = await axiosClient.post(
+                '/upload',
+                bytesToBase64(new TextEncoder().encode(JSON.stringify(data))),
+              );
+              console.log(chalk.bold('Build Scan: ') + chalk.dim(`${baseUrl}/scan/${response.data.data[0].id}`));
+            } catch (error) {
+              //console.log(error);
+              console.log(chalk.red(`   ✕ `) + chalk.dim('Unable to upload build scan'));
+            }
+          }
+
           process.exit(1);
           //console.log(chalk.green(JSON.stringify(result)));
         } catch (error) {

packages/flowtest-cli/graph/Graph.js

@@ -10,12 +10,13 @@ const path = require('path');
 const readFile = require('../../flowtest-electron/src/utils/filemanager/readfile');
 const { serialize } = require('../../flowtest-electron/src/utils/flowparser/parser');
 const Node = require('./compute/node');
+const { LogLevel } = require('./GraphLogger');
 
 class nestedFlowNode extends Node {
-  constructor(nodes, edges, startTime, timeout, initialEnvVars) {
+  constructor(nodes, edges, startTime, timeout, initialEnvVars, logger) {
     super('flowNode');
     try {
-      this.internalGraph = new Graph(nodes, edges, startTime, timeout, initialEnvVars);
+      this.internalGraph = new Graph(nodes, edges, startTime, timeout, initialEnvVars, logger);
     } catch (error) {
       console.log(error);
     }
@@ -27,14 +28,15 @@ class nestedFlowNode extends Node {
 }
 
 class Graph {
-  constructor(nodes, edges, startTime, timeout, initialEnvVars) {
+  constructor(nodes, edges, startTime, timeout, initialEnvVars, logger) {
     this.nodes = nodes;
     this.edges = edges;
     this.timeout = timeout;
     this.startTime = startTime;
     this.graphRunNodeOutput = {};
     this.auth = undefined;
     this.envVariables = initialEnvVars;
+    this.logger = logger;
   }
 
   #checkTimeout() {
@@ -83,6 +85,7 @@ class Graph {
       if (node.type === 'outputNode') {
         console.log('Output Node');
         console.log(chalk.green(`   ✓ `) + chalk.dim(`${JSON.stringify(prevNodeOutputData)}`));
+        this.logger.add(LogLevel.INFO, '', { type: 'outputNode', data: { output: prevNodeOutputData } });
         result = {
           status: 'Success',
           data: prevNodeOutputData,
@@ -95,7 +98,7 @@ class Graph {
           node.data.variables,
           prevNodeOutputData,
           this.envVariables,
-          this.logs,
+          this.logger,
         );
         if (eNode.evaluate()) {
           console.log(chalk.green(`   ✓ `) + chalk.dim('True'));
@@ -121,6 +124,7 @@ class Graph {
         };
         console.log('Delay Node: ' + chalk.green(`....waiting for: ${delay} ms`));
         await wait(delay);
+        this.logger.add(LogLevel.INFO, '', { type: 'delayNode', data: { delay } });
         result = {
           status: 'Success',
         };
@@ -137,7 +141,7 @@ class Graph {
 
       if (node.type === 'requestNode') {
         console.log('Request Node');
-        const rNode = new requestNode(node.data, prevNodeOutputData, this.envVariables, this.auth);
+        const rNode = new requestNode(node.data, prevNodeOutputData, this.envVariables, this.auth, this.logger);
         result = await rNode.evaluate();
         // add post response variables if any
         if (result.postRespVars) {
@@ -159,6 +163,7 @@ class Graph {
             this.startTime,
             this.timeout,
             this.envVariables,
+            this.logger,
           );
           result = await cNode.evaluate();
           this.envVariables = result.envVars;
@@ -175,6 +180,13 @@ class Graph {
         const newVariable = sNode.evaluate();
         if (newVariable != undefined) {
           console.log(chalk.green(`   ✓ `) + chalk.dim(`Set variable: ${JSON.stringify(newVariable)}`));
+          this.logger.add(LogLevel.INFO, '', {
+            type: 'setVarNode',
+            data: {
+              name: Object.keys(newVariable)[0],
+              value: newVariable[Object.keys(newVariable)[0]],
+            },
+          });
           this.envVariables = {
             ...this.envVariables,
             ...newVariable,
@@ -186,17 +198,19 @@ class Graph {
       }
 
       if (this.#checkTimeout()) {
-        throw `Timeout of ${this.timeout} ms exceeded, stopping graph run`;
+        throw Error(`Timeout of ${this.timeout} ms exceeded, stopping graph run`);
       }
     } catch (err) {
       console.log(chalk.red(`Flow failed at: ${JSON.stringify(node.data)} due to ${err}`));
+      this.logger.add(LogLevel.ERROR, `Flow failed due to ${err}`, node);
       return {
         status: 'Failed',
       };
     }
 
     if (result === undefined) {
       console.log(chalk.red(`Flow failed due to failure to evaluate result at node: ${node.data}`));
+      this.logger.add(LogLevel.ERROR, 'Flow failed due to failure to evaluate result', node);
       return {
         status: 'Failed',
       };
@@ -222,10 +236,14 @@ class Graph {
     this.graphRunNodeOutput = {};
 
     console.log(chalk.green('Start Flowtest'));
+    this.logger.add(LogLevel.INFO, 'Start Flowtest');
+
     const startNode = this.nodes.find((node) => node.type === 'startNode');
     if (startNode == undefined) {
       console.log(chalk.red(`✕ `) + chalk.red('No start node found'));
       console.log(chalk.red('End Flowtest'));
+      this.logger.add(LogLevel.INFO, 'No start node found');
+      this.logger.add(LogLevel.INFO, 'End Flowtest');
       return {
         status: 'Success',
         envVars: this.envVariables,
@@ -242,12 +260,14 @@ class Graph {
       } else {
         console.log(chalk.green('End Flowtest'));
       }
+      this.logger.add(LogLevel.INFO, 'End Flowtest');
       return {
         status: result.status,
         envVars: this.envVariables,
       };
     } else {
       console.log(chalk.green('End Flowtest'));
+      this.logger.add(LogLevel.INFO, 'End Flowtest');
       return {
         status: 'Success',
         envVars: this.envVariables,

packages/flowtest-cli/graph/GraphLogger.js

@@ -0,0 +1,29 @@
+const LogLevel = Object.freeze({
+  INFO: 'info',
+  WARN: 'warn',
+  ERROR: 'error',
+});
+
+class GraphLogger {
+  constructor() {
+    this.logs = [];
+  }
+
+  add(logLevel, message, node) {
+    this.logs.push({
+      level: logLevel,
+      timestamp: new Date().toISOString(),
+      message,
+      node,
+    });
+  }
+
+  get() {
+    return this.logs;
+  }
+}
+
+module.exports = {
+  GraphLogger,
+  LogLevel,
+};

packages/flowtest-cli/graph/compute/assertnode.js

@@ -2,14 +2,15 @@ const AssertOperators = require('../constants/assertOperators');
 const { computeNodeVariable } = require('./utils');
 const Node = require('./node');
 const chalk = require('chalk');
+const { LogLevel } = require('../GraphLogger');
 
 class assertNode extends Node {
-  constructor(operator, variables, prevNodeOutputData, envVariables, logs) {
+  constructor(operator, variables, prevNodeOutputData, envVariables, logger) {
     super('assertNode');
     this.operator = operator;
     this.variables = variables;
     this.prevNodeOutputData = prevNodeOutputData;
-    this.logs = logs;
+    this.logger = logger;
     this.envVariables = envVariables;
   }
 
@@ -32,7 +33,7 @@ class assertNode extends Node {
 
     const operator = this.operator;
     if (operator == undefined) {
-      throw 'Operator undefined';
+      throw Error('Operator undefined');
     }
     // this.logs.push(
     //   `Assert var1: ${JSON.stringify(var1)} of type: ${typeof var1}, var2: ${JSON.stringify(var2)} of type: ${typeof var2} with operator: ${operator}`,
@@ -43,17 +44,26 @@ class assertNode extends Node {
           `Assert var1: ${JSON.stringify(var1)} of type: ${typeof var1}, var2: ${JSON.stringify(var2)} of type: ${typeof var2} with operator: ${operator}`,
         ),
     );
-    if (operator == AssertOperators.isEqualTo) {
-      return var1 === var2;
-    } else if (operator == AssertOperators.isNotEqualTo) {
-      return var1 != var2;
-    } else if (operator == AssertOperators.isGreaterThan) {
-      return var1 > var2;
-    } else if (operator == AssertOperators.isLessThan) {
-      return var1 < var2;
-    } else {
-      throw 'Operator unrecognized';
+    let result;
+    switch (operator) {
+      case AssertOperators.isEqualTo:
+        result = var1 === var2;
+        break;
+      case AssertOperators.isNotEqualTo:
+        result = var1 != var2;
+        break;
+      case AssertOperators.isGreaterThan:
+        result = var1 > var2;
+        break;
+      case AssertOperators.isLessThan:
+        result = var1 < var2;
+        break;
+      default:
+        throw Error('Unsupported operator');
     }
+    this.logger.add(LogLevel.INFO, '', { type: 'assertNode', data: { var1, var2, operator, result } });
+
+    return result;
   }
 }
 

packages/flowtest-cli/graph/compute/authnode.js

@@ -3,21 +3,24 @@ const Node = require('./node');
 const chalk = require('chalk');
 
 class authNode extends Node {
-  constructor(auth, envVariables) {
+  constructor(auth, envVariables, logger) {
     super('authNode');
     (this.auth = auth), (this.envVariables = envVariables);
+    this.logger = logger;
   }
 
   evaluate() {
     //console.log('Evaluating an auth node');
     if (this.auth.type === 'basic-auth') {
       console.log(chalk.green(`   ✓ `) + chalk.dim('.....setting basic authentication'));
+      this.logger.add(LogLevel.INFO, '', { type: 'authNode', data: { authType: 'Basic Authentication' } });
       this.auth.username = computeVariables(this.auth.username, this.envVariables);
       this.auth.password = computeVariables(this.auth.password, this.envVariables);
 
       return this.auth;
     } else if (this.auth.type === 'no-auth') {
       console.log(chalk.green(`   ✓ `) + chalk.dim('.....using no authentication'));
+      this.logger.add(LogLevel.INFO, '', { type: 'authNode', data: { authType: 'No Authentication' } });
       return this.auth;
     } else {
       throw Error(`auth type: ${this.auth.type} is not valid`);