@usebruno/js 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "main": "src/index.js",
   "files": [
     "src",

package/src/bru.js

@@ -1,8 +1,11 @@
-
 class Bru {
   constructor(envVariables, collectionVariables) {
-    this._envVariables = envVariables;
-    this._collectionVariables = collectionVariables;
+    this.envVariables = envVariables;
+    this.collectionVariables = collectionVariables;
+  }
+
+  getEnvName() {
+    return this.envVariables.__name__;
   }
 
   getProcessEnv(key) {
@@ -10,32 +13,32 @@ class Bru {
   }
 
   getEnvVar(key) {
-    return this._envVariables[key];
+    return this.envVariables[key];
   }
 
   setEnvVar(key, value) {
-    if(!key) {
+    if (!key) {
       throw new Error('Key is required');
     }
 
     // gracefully ignore if key is not present in environment
-    if(!this._envVariables.hasOwnProperty(key)) {
-       return;
+    if (!this.envVariables.hasOwnProperty(key)) {
+      return;
     }
 
-    this._envVariables[key] = value;
+    this.envVariables[key] = value;
   }
 
   setVar(key, value) {
-    if(!key) {
+    if (!key) {
       throw new Error('Key is required');
     }
 
-    this._collectionVariables[key] = value;
+    this.collectionVariables[key] = value;
   }
 
   getVar(key) {
-    return this._collectionVariables[key];
+    return this.collectionVariables[key];
   }
 }
 

package/src/bruno-request.js

@@ -46,6 +46,10 @@ class BrunoRequest {
   setBody(data) {
     this.req.data = data;
   }
+
+  setMaxRedirects(maxRedirects) {
+    this.req.maxRedirects = maxRedirects;
+  }
 }
 
-module.exports = BrunoRequest;
+module.exports = BrunoRequest;

package/src/bruno-response.js

@@ -12,7 +12,7 @@ class BrunoResponse {
   }
 
   getHeader(name) {
-    return (this.res && this.res.headers) ? this.res.headers[name] : null;
+    return this.res && this.res.headers ? this.res.headers[name] : null;
   }
 
   getHeaders() {

package/src/runtime/assert-runtime.js

@@ -12,11 +12,7 @@ chai.use(function (chai, utils) {
     const obj = this._obj;
     const isJson = typeof obj === 'object' && obj !== null && !Array.isArray(obj) && obj.constructor === Object;
 
-    this.assert(
-      isJson,
-      `expected ${utils.inspect(obj)} to be JSON`,
-      `expected ${utils.inspect(obj)} not to be JSON`
-    );
+    this.assert(isJson, `expected ${utils.inspect(obj)} to be JSON`, `expected ${utils.inspect(obj)} not to be JSON`);
   });
 });
 
@@ -25,7 +21,7 @@ chai.use(function (chai, utils) {
   chai.Assertion.addMethod('match', function (regex) {
     const obj = this._obj;
     let match = false;
-    if(obj === undefined) {
+    if (obj === undefined) {
       match = false;
     } else {
       match = regex.test(obj);
@@ -41,7 +37,7 @@ chai.use(function (chai, utils) {
 
 /**
  * Assertion operators
- * 
+ *
  * eq          : equal to
  * neq         : not equal to
  * gt          : greater than
@@ -70,7 +66,7 @@ chai.use(function (chai, utils) {
  * isBoolean   : is boolean
  */
 const parseAssertionOperator = (str = '') => {
-  if(!str || typeof str !== 'string' || !str.length) {
+  if (!str || typeof str !== 'string' || !str.length) {
     return {
       operator: 'eq',
       value: str
@@ -78,27 +74,58 @@ const parseAssertionOperator = (str = '') => {
   }
 
   const operators = [
-    'eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn',
-    'contains', 'notContains', 'length', 'matches', 'notMatches',
-    'startsWith', 'endsWith', 'between', 'isEmpty', 'isNull', 'isUndefined',
-    'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+    'eq',
+    'neq',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'in',
+    'notIn',
+    'contains',
+    'notContains',
+    'length',
+    'matches',
+    'notMatches',
+    'startsWith',
+    'endsWith',
+    'between',
+    'isEmpty',
+    'isNull',
+    'isUndefined',
+    'isDefined',
+    'isTruthy',
+    'isFalsy',
+    'isJson',
+    'isNumber',
+    'isString',
+    'isBoolean'
   ];
 
   const unaryOperators = [
-    'isEmpty', 'isNull', 'isUndefined', 'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+    'isEmpty',
+    'isNull',
+    'isUndefined',
+    'isDefined',
+    'isTruthy',
+    'isFalsy',
+    'isJson',
+    'isNumber',
+    'isString',
+    'isBoolean'
   ];
 
   const [operator, ...rest] = str.trim().split(' ');
   const value = rest.join(' ');
 
-  if(unaryOperators.includes(operator)) {
+  if (unaryOperators.includes(operator)) {
     return {
       operator,
       value: ''
     };
   }
 
-  if(operators.includes(operator)) {
+  if (operators.includes(operator)) {
     return {
       operator,
       value
@@ -113,34 +140,43 @@ const parseAssertionOperator = (str = '') => {
 
 const isUnaryOperator = (operator) => {
   const unaryOperators = [
-    'isEmpty', 'isNull', 'isUndefined', 'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+    'isEmpty',
+    'isNull',
+    'isUndefined',
+    'isDefined',
+    'isTruthy',
+    'isFalsy',
+    'isJson',
+    'isNumber',
+    'isString',
+    'isBoolean'
   ];
 
   return unaryOperators.includes(operator);
 };
 
 const evaluateRhsOperand = (rhsOperand, operator, context) => {
-  if(isUnaryOperator(operator)) {
+  if (isUnaryOperator(operator)) {
     return;
   }
 
   // gracefully allow both a,b as well as [a, b]
-  if(operator === 'in' || operator === 'notIn') {
-    if(rhsOperand.startsWith('[') && rhsOperand.endsWith(']')) {
+  if (operator === 'in' || operator === 'notIn') {
+    if (rhsOperand.startsWith('[') && rhsOperand.endsWith(']')) {
       rhsOperand = rhsOperand.substring(1, rhsOperand.length - 1);
     }
 
     return rhsOperand.split(',').map((v) => evaluateJsTemplateLiteral(v.trim(), context));
   }
 
-  if(operator === 'between') {
+  if (operator === 'between') {
     const [lhs, rhs] = rhsOperand.split(',').map((v) => evaluateJsTemplateLiteral(v.trim(), context));
     return [lhs, rhs];
   }
 
   // gracefully allow both ^[a-Z] as well as /^[a-Z]/
-  if(operator === 'matches' || operator === 'notMatches') {
-    if(rhsOperand.startsWith('/') && rhsOperand.endsWith('/')) {
+  if (operator === 'matches' || operator === 'notMatches') {
+    if (rhsOperand.startsWith('/') && rhsOperand.endsWith('/')) {
       rhsOperand = rhsOperand.substring(1, rhsOperand.length - 1);
     }
 
@@ -153,7 +189,7 @@ const evaluateRhsOperand = (rhsOperand, operator, context) => {
 class AssertRuntime {
   runAssertions(assertions, request, response, envVariables, collectionVariables, collectionPath) {
     const enabledAssertions = _.filter(assertions, (a) => a.enabled);
-    if(!enabledAssertions.length) {
+    if (!enabledAssertions.length) {
       return [];
     }
 
@@ -171,7 +207,7 @@ class AssertRuntime {
       ...envVariables,
       ...collectionVariables,
       ...bruContext
-    }
+    };
 
     const assertionResults = [];
 
@@ -179,16 +215,13 @@ class AssertRuntime {
     for (const v of enabledAssertions) {
       const lhsExpr = v.name;
       const rhsExpr = v.value;
-      const {
-        operator,
-        value: rhsOperand
-      } = parseAssertionOperator(rhsExpr);
+      const { operator, value: rhsOperand } = parseAssertionOperator(rhsExpr);
 
       try {
         const lhs = evaluateJsExpression(lhsExpr, context);
         const rhs = evaluateRhsOperand(rhsOperand, operator, context);
 
-        switch(operator) {
+        switch (operator) {
           case 'eq':
             expect(lhs).to.equal(rhs);
             break;
@@ -281,8 +314,7 @@ class AssertRuntime {
           operator,
           status: 'pass'
         });
-      }
-      catch (err) {
+      } catch (err) {
         assertionResults.push({
           uid: nanoid(),
           lhsExpr,

package/src/runtime/script-runtime.js

@@ -10,6 +10,7 @@ const punycode = require('punycode');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
+const { cleanJson } = require('../utils');
 
 // Inbuilt Library Support
 const atob = require('atob');
@@ -23,16 +24,31 @@ const fetch = require('node-fetch');
 const CryptoJS = require('crypto-js');
 
 class ScriptRuntime {
-  constructor() {
-  }
+  constructor() {}
 
-  async runRequestScript(script, request, envVariables, collectionVariables, collectionPath){
+  async runRequestScript(script, request, envVariables, collectionVariables, collectionPath, onConsoleLog) {
     const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
+
     const context = {
       bru,
       req
     };
+
+    if (onConsoleLog && typeof onConsoleLog === 'function') {
+      const customLogger = (type) => {
+        return (...args) => {
+          onConsoleLog(type, cleanJson(args));
+        };
+      };
+      context.console = {
+        log: customLogger('log'),
+        info: customLogger('info'),
+        warn: customLogger('warn'),
+        error: customLogger('error')
+      };
+    }
+
     const vm = new NodeVM({
       sandbox: context,
       require: {
@@ -62,16 +78,16 @@ class ScriptRuntime {
         }
       }
     });
-    const asyncVM = vm.run(`module.exports = async () => { ${script} }`,  path.join(collectionPath, 'vm.js'));
+    const asyncVM = vm.run(`module.exports = async () => { ${script} }`, path.join(collectionPath, 'vm.js'));
     await asyncVM();
     return {
       request,
-      envVariables,
-      collectionVariables
+      envVariables: cleanJson(envVariables),
+      collectionVariables: cleanJson(collectionVariables)
     };
   }
 
-  async runResponseScript(script, request, response, envVariables, collectionVariables, collectionPath) {
+  async runResponseScript(script, request, response, envVariables, collectionVariables, collectionPath, onConsoleLog) {
     const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
     const res = new BrunoResponse(response);
@@ -81,6 +97,21 @@ class ScriptRuntime {
       req,
       res
     };
+
+    if (onConsoleLog && typeof onConsoleLog === 'function') {
+      const customLogger = (type) => {
+        return (...args) => {
+          onConsoleLog(type, cleanJson(args));
+        };
+      };
+      context.console = {
+        log: customLogger('log'),
+        info: customLogger('info'),
+        warn: customLogger('warn'),
+        error: customLogger('error')
+      };
+    }
+
     const vm = new NodeVM({
       sandbox: context,
       require: {
@@ -101,13 +132,13 @@ class ScriptRuntime {
       }
     });
 
-    const asyncVM = vm.run(`module.exports = async () => { ${script} }`,  path.join(collectionPath, 'vm.js'));
+    const asyncVM = vm.run(`module.exports = async () => { ${script} }`, path.join(collectionPath, 'vm.js'));
     await asyncVM();
 
     return {
       response,
-      envVariables,
-      collectionVariables
+      envVariables: cleanJson(envVariables),
+      collectionVariables: cleanJson(collectionVariables)
     };
   }
 }

package/src/runtime/test-runtime.js

@@ -1,11 +1,12 @@
 const { NodeVM } = require('vm2');
-const chai = require('chai');  
+const chai = require('chai');
 const path = require('path');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
 const Test = require('../test');
 const TestResults = require('../test-results');
+const { cleanJson } = require('../utils');
 
 // Inbuilt Library Support
 const atob = require('atob');
@@ -17,10 +18,9 @@ const nanoid = require('nanoid');
 const CryptoJS = require('crypto-js');
 
 class TestRuntime {
-  constructor() {
-  }
+  constructor() {}
 
-  runTests(testsFile, request, response, envVariables, collectionVariables, collectionPath) {
+  runTests(testsFile, request, response, envVariables, collectionVariables, collectionPath, onConsoleLog) {
     const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
     const res = new BrunoResponse(response);
@@ -28,7 +28,7 @@ class TestRuntime {
     const __brunoTestResults = new TestResults();
     const test = Test(__brunoTestResults, chai);
 
-    if(!testsFile || !testsFile.length) {
+    if (!testsFile || !testsFile.length) {
       return {
         request,
         envVariables,
@@ -47,6 +47,20 @@ class TestRuntime {
       __brunoTestResults: __brunoTestResults
     };
 
+    if (onConsoleLog && typeof onConsoleLog === 'function') {
+      const customLogger = (type) => {
+        return (...args) => {
+          onConsoleLog(type, cleanJson(args));
+        };
+      };
+      context.console = {
+        log: customLogger('log'),
+        info: customLogger('info'),
+        warn: customLogger('warn'),
+        error: customLogger('error')
+      };
+    }
+
     const vm = new NodeVM({
       sandbox: context,
       require: {
@@ -69,9 +83,9 @@ class TestRuntime {
 
     return {
       request,
-      envVariables,
-      collectionVariables,
-      results: __brunoTestResults.getResults()
+      envVariables: cleanJson(envVariables),
+      collectionVariables: cleanJson(collectionVariables),
+      results: cleanJson(__brunoTestResults.getResults())
     };
   }
 }

package/src/runtime/vars-runtime.js

@@ -6,7 +6,7 @@ const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser }
 class VarsRuntime {
   runPreRequestVars(vars, request, envVariables, collectionVariables, collectionPath) {
     const enabledVars = _.filter(vars, (v) => v.enabled);
-    if(!enabledVars.length) {
+    if (!enabledVars.length) {
       return;
     }
 
@@ -22,7 +22,7 @@ class VarsRuntime {
       ...envVariables,
       ...collectionVariables,
       ...bruContext
-    }
+    };
 
     _.each(enabledVars, (v) => {
       const value = evaluateJsTemplateLiteral(v.value, context);
@@ -36,7 +36,7 @@ class VarsRuntime {
 
   runPostResponseVars(vars, request, response, envVariables, collectionVariables, collectionPath) {
     const enabledVars = _.filter(vars, (v) => v.enabled);
-    if(!enabledVars.length) {
+    if (!enabledVars.length) {
       return;
     }
 
@@ -54,7 +54,7 @@ class VarsRuntime {
       ...envVariables,
       ...collectionVariables,
       ...bruContext
-    }
+    };
 
     _.each(enabledVars, (v) => {
       const value = evaluateJsExpression(v.value, context);

package/src/test.js

@@ -1,14 +1,14 @@
 const Test = (__brunoTestResults, chai) => (description, callback) => {
   try {
     callback();
-    __brunoTestResults.addResult({ description, status: "pass" });
+    __brunoTestResults.addResult({ description, status: 'pass' });
   } catch (error) {
     console.log(chai.AssertionError);
     if (error instanceof chai.AssertionError) {
       const { message, actual, expected } = error;
       __brunoTestResults.addResult({
         description,
-        status: "fail",
+        status: 'fail',
         error: message,
         actual,
         expected
@@ -16,12 +16,12 @@ const Test = (__brunoTestResults, chai) => (description, callback) => {
     } else {
       __brunoTestResults.addResult({
         description,
-        status: "fail",
+        status: 'fail',
         error: error.message || 'An unexpected error occurred.'
       });
     }
     console.log(error);
   }
-}
+};
 
-module.exports = Test;
+module.exports = Test;

package/src/utils.js

@@ -1,21 +1,23 @@
 const jsonQuery = require('json-query');
-const { get } = require("@usebruno/query");
+const { get } = require('@usebruno/query');
 
 const JS_KEYWORDS = `
   break case catch class const continue debugger default delete do
   else export extends false finally for function if import in instanceof
   new null return super switch this throw true try typeof var void while with
   undefined let static yield arguments of
-`.split(/\s+/).filter(word => word.length > 0);
+`
+  .split(/\s+/)
+  .filter((word) => word.length > 0);
 
 /**
  * Creates a function from a Javascript expression
- * 
+ *
  * When the function is called, the variables used in this expression are picked up from the context
- * 
+ *
  * ```js
  * res.data.pets.map(pet => pet.name.toUpperCase())
- * 
+ *
  * function(context) {
  *   const { res, pet } = context;
  *   return res.data.pets.map(pet => pet.name.toUpperCase())
@@ -29,25 +31,23 @@ const compileJsExpression = (expr) => {
   // get valid js identifiers (foo, bar)
   const vars = new Set(
     matches
-      .filter(match => /^[a-zA-Z$_]/.test(match))   // starts with valid js identifier (foo.bar)
-      .map(match => match.split('.')[0])            // top level identifier (foo)
-      .filter(name => !JS_KEYWORDS.includes(name))  // exclude js keywords
+      .filter((match) => /^[a-zA-Z$_]/.test(match)) // starts with valid js identifier (foo.bar)
+      .map((match) => match.split('.')[0]) // top level identifier (foo)
+      .filter((name) => !JS_KEYWORDS.includes(name)) // exclude js keywords
   );
 
   // globals such as Math
-  const globals = [...vars].filter(name => name in globalThis);
+  const globals = [...vars].filter((name) => name in globalThis);
 
   const code = {
-    vars: [...vars].join(", "),
+    vars: [...vars].join(', '),
     // pick global from context or globalThis
-    globals: globals
-      .map(name => ` ${name} = ${name} ?? globalThis.${name};`)
-      .join('')
+    globals: globals.map((name) => ` ${name} = ${name} ?? globalThis.${name};`).join('')
   };
 
   const body = `let { ${code.vars} } = context; ${code.globals}; return ${expr}`;
 
-  return new Function("context", body);
+  return new Function('context', body);
 };
 
 const internalExpressionCache = new Map();
@@ -55,47 +55,47 @@ const internalExpressionCache = new Map();
 const evaluateJsExpression = (expression, context) => {
   let fn = internalExpressionCache.get(expression);
   if (fn == null) {
-    internalExpressionCache.set(expression, fn = compileJsExpression(expression));
+    internalExpressionCache.set(expression, (fn = compileJsExpression(expression)));
   }
   return fn(context);
 };
 
 const evaluateJsTemplateLiteral = (templateLiteral, context) => {
-  if(!templateLiteral || !templateLiteral.length || typeof templateLiteral !== 'string') {
+  if (!templateLiteral || !templateLiteral.length || typeof templateLiteral !== 'string') {
     return templateLiteral;
   }
 
   templateLiteral = templateLiteral.trim();
 
-  if(templateLiteral === 'true') {
+  if (templateLiteral === 'true') {
     return true;
   }
 
-  if(templateLiteral === 'false') {
+  if (templateLiteral === 'false') {
     return false;
   }
 
-  if(templateLiteral === 'null') {
+  if (templateLiteral === 'null') {
     return null;
   }
 
-  if(templateLiteral === 'undefined') {
+  if (templateLiteral === 'undefined') {
     return undefined;
   }
 
-  if(templateLiteral.startsWith('"') && templateLiteral.endsWith('"')) {
+  if (templateLiteral.startsWith('"') && templateLiteral.endsWith('"')) {
     return templateLiteral.slice(1, -1);
   }
 
-  if(templateLiteral.startsWith("'") && templateLiteral.endsWith("'")) {
+  if (templateLiteral.startsWith("'") && templateLiteral.endsWith("'")) {
     return templateLiteral.slice(1, -1);
   }
 
-  if(!isNaN(templateLiteral)) {
+  if (!isNaN(templateLiteral)) {
     return Number(templateLiteral);
   }
 
-  templateLiteral = "`" + templateLiteral + "`";
+  templateLiteral = '`' + templateLiteral + '`';
 
   return evaluateJsExpression(templateLiteral, context);
 };
@@ -118,9 +118,28 @@ const createResponseParser = (response = {}) => {
   return res;
 };
 
+/**
+ * Objects that are created inside vm2 execution context result in an serilaization error when sent to the renderer process
+ * Error sending from webFrameMain:  Error: Failed to serialize arguments
+ *    at s.send (node:electron/js2c/browser_init:169:631)
+ *    at g.send (node:electron/js2c/browser_init:165:2156)
+ * How to reproduce
+ *    Remove the cleanJson fix and execute the below post response script
+ *    bru.setVar("a", {b:3});
+ * Todo: Find a better fix
+ */
+const cleanJson = (data) => {
+  try {
+    return JSON.parse(JSON.stringify(data));
+  } catch (e) {
+    return data;
+  }
+};
+
 module.exports = {
   evaluateJsExpression,
   evaluateJsTemplateLiteral,
   createResponseParser,
-  internalExpressionCache
-};
+  internalExpressionCache,
+  cleanJson
+};