@usebruno/js 0.14.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -11,10 +11,11 @@
     "@usebruno/vm2": "^3.9.13"
   },
   "scripts": {
-    "test": "jest --testPathIgnorePatterns test.js"
+    "test": "node --experimental-vm-modules $(npx which jest) --testPathIgnorePatterns test.js",
+    "sandbox:bundle-libraries": "node ./src/sandbox/bundle-libraries.js"
   },
   "dependencies": {
-    "@usebruno/common": "0.2.0",
+    "@usebruno/common": "0.3.0",
     "@usebruno/query": "0.1.0",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
@@ -24,12 +25,29 @@
     "chai": "^4.3.7",
     "chai-string": "^1.5.0",
     "crypto-js": "^4.1.1",
+    "crypto-js-3.1.9-1": "npm:crypto-js@^3.1.9-1",
     "json-query": "^2.2.2",
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
     "nanoid": "3.3.4",
-    "node-fetch": "2.*",
+    "node-fetch": "^2.7.0",
     "node-vault": "^0.10.2",
+    "path": "^0.12.7",
+    "quickjs-emscripten": "^0.29.2",
     "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^23.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "rollup": "3.2.5",
+    "rollup-plugin-node-builtins": "^2.1.2",
+    "rollup-plugin-node-globals": "^1.4.0",
+    "rollup-plugin-polyfill-node": "^0.13.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "stream": "^0.0.2",
+    "terser": "^5.31.1",
+    "uglify-js": "^3.18.0",
+    "util": "^0.12.5"
   }
 }

package/src/bru.js

@@ -5,24 +5,17 @@ const { interpolate } = require('@usebruno/common');
 const variableNameRegex = /^[\w-.]*$/;
 
 class Bru {
-  constructor(
-    envVariables,
-    collectionVariables,
-    processEnvVars,
-    collectionPath,
-    historyLogger,
-    setHtmlVisualizationString,
-    secretVariables,
-    requestVariables
-  ) {
+  constructor(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables) {
     this.envVariables = envVariables || {};
-    this.collectionVariables = collectionVariables || {};
+    this.runtimeVariables = runtimeVariables || {};
     this.processEnvVars = cloneDeep(processEnvVars || {});
     this.secretVariables = cloneDeep(secretVariables || {});
+    this.collectionVariables = collectionVariables || {};
+    this.folderVariables = folderVariables || {};
     this.requestVariables = requestVariables || {};
     this.collectionPath = collectionPath;
     this.historyLogger = historyLogger;
-    this.setHtmlVisualizationString = setHtmlVisualizationString;
+    this.setVisualizations = setVisualizations;
   }
 
   _interpolate = (str) => {
@@ -31,9 +24,11 @@ class Bru {
     }
 
     const combinedVars = {
+      ...this.collectionVariables,
       ...this.envVariables,
+      ...this.folderVariables,
       ...this.requestVariables,
-      ...this.collectionVariables,
+      ...this.runtimeVariables,
       process: {
         env: {
           ...this.processEnvVars
@@ -82,7 +77,7 @@ class Bru {
   }
 
   hasVar(key) {
-    return Object.hasOwn(this.collectionVariables, key);
+    return Object.hasOwn(this.runtimeVariables, key);
   }
 
   setVar(key, value) {
@@ -93,7 +88,7 @@ class Bru {
     if (variableNameRegex.test(key) === false) {
       throw new Error(
         `Variable name: "${key}" contains invalid characters!` +
-          ' Names must only contain alpha-numeric characters, "-", "_", "."'
+        ' Names must only contain alpha-numeric characters, "-", "_", "."'
       );
     }
 
@@ -106,22 +101,30 @@ class Bru {
       });
     }
 
-    this.collectionVariables[key] = value;
+    this.runtimeVariables[key] = value;
   }
 
   getVar(key) {
     if (variableNameRegex.test(key) === false) {
       throw new Error(
         `Variable name: "${key}" contains invalid characters!` +
-          ' Names must only contain alpha-numeric characters, "-", "_", "."'
+        ' Names must only contain alpha-numeric characters, "-", "_", "."'
       );
     }
 
-    return this._interpolate(this.collectionVariables[key]);
+    return this._interpolate(this.runtimeVariables[key]);
   }
 
   deleteVar(key) {
-    delete this.collectionVariables[key];
+    delete this.runtimeVariables[key];
+  }
+
+  getCollectionVar(key) {
+    return this._interpolate(this.collectionVariables[key]);
+  }
+
+  getFolderVar(key) {
+    return this._interpolate(this.folderVariables[key]);
   }
 
   getRequestVar(key) {
@@ -132,13 +135,36 @@ class Bru {
     this.nextRequest = nextRequest;
   }
 
-  visualize(htmlString) {
-    this.setHtmlVisualizationString(htmlString);
-  }
 
   getSecretVar(key) {
     return this.secretVariables?.[`$secrets.${key}`];
   }
+
+
+  visualize(type, data) {
+    if (type == 'table') {
+      if (data?.provider == 'ag-grid') {
+        if (!data?.props?.columnDefinitions) {
+          throw new Error(`columns definitions are required`);
+        }
+        if (!data?.props?.rowData) {
+          throw new Error(`row data is required`);
+        }
+        this.setVisualizations({ uid: uuid(), type, data });
+      } else if (data?.provider == 'react-table') {
+        this.setVisualizations({ uid: uuid(), type, data });
+      }
+    } else if (type == 'html') {
+      if (!data?.content) {
+        throw new Error(`html content is required`);
+      }
+      this.setVisualizations({ uid: uuid(), type, data });
+    }
+  }
+
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
 }
 
 module.exports = Bru;

package/src/bruno-request.js

@@ -1,14 +1,37 @@
 const { uuid } = require('./utils');
 
 class BrunoRequest {
+  /**
+   * The following properties are available as shorthand:
+   * - req.url
+   * - req.method
+   * - req.headers
+   * - req.timeout
+   * - req.body
+   * 
+   * Above shorthands are useful for accessing the request properties directly in the scripts
+   * It must be noted that the user cannot set these properties directly.
+   * They should use the respective setter methods to set these properties.
+   */
   constructor(req, historyLogger) {
     this.req = req;
     this.url = req.url;
     this.method = req.method;
     this.headers = req.headers;
-    this.body = req.data;
     this.timeout = req.timeout;
     this.historyLogger = historyLogger;
+
+    /**
+     * We automatically parse the JSON body if the content type is JSON
+     * This is to make it easier for the user to access the body directly
+     * 
+     * It must be noted that the request data is always a string and is what gets sent over the network
+     * If the user wants to access the raw data, they can use getBody({raw: true}) method 
+     */
+    const isJson = this.hasJSONContentType(this.req.headers);
+    if (isJson) {
+      this.body = this.__safeParseJSON(req.data);
+    }
   }
 
   getUrl() {
@@ -16,6 +39,7 @@ class BrunoRequest {
   }
 
   setUrl(url) {
+    this.url = url;
     this.req.url = url;
   }
 
@@ -40,6 +64,7 @@ class BrunoRequest {
   }
 
   setMethod(method) {
+    this.method = method;
     this.req.method = method;
   }
 
@@ -48,6 +73,7 @@ class BrunoRequest {
   }
 
   setHeaders(headers) {
+    this.headers = headers;
     this.req.headers = headers;
   }
 
@@ -64,14 +90,45 @@ class BrunoRequest {
         createdAt: new Date().toISOString()
       });
     }
+    this.headers[name] = value;
     this.req.headers[name] = value;
   }
 
-  getBody() {
+  hasJSONContentType(headers) {
+    const contentType = headers?.['Content-Type'] || headers?.['content-type'] || '';
+    return contentType.includes('json');
+  }
+
+  /**
+   * Get the body of the request
+   * 
+   * We automatically parse and return the JSON body if the content type is JSON
+   * If the user wants the raw body, they can pass the raw option as true
+   */
+  getBody(options = {}) {
+    if (options.raw) {
+      return this.req.data;
+    }
+
+    const isJson = this.hasJSONContentType(this.req.headers);
+    if (isJson) {
+      return this.__safeParseJSON(this.req.data);
+    }
+
     return this.req.data;
   }
 
-  setBody(data) {
+  /**
+   * If the content type is JSON and if the data is an object
+   *  - We set the body property as the object itself
+   *  - We set the request data as the stringified JSON as it is what gets sent over the network
+   * Otherwise
+   *  - We set the request data as the data itself
+   *  - We set the body property as the data itself
+   * 
+   * If the user wants to override this behavior, they can pass the raw option as true
+   */
+  setBody(data, options = {}) {
     if (this.historyLogger) {
       this.historyLogger({
         uid: uuid(),
@@ -80,7 +137,22 @@ class BrunoRequest {
         createdAt: new Date().toISOString()
       });
     }
+    
+    if (options.raw) {
+      this.req.data = data;
+      this.body = data;
+      return;
+    }
+
+    const isJson = this.hasJSONContentType(this.req.headers);
+    if (isJson && this.__isObject(data)) {
+      this.body = data;
+      this.req.data = this.__safeStringifyJSON(data);
+      return;
+    }
+
     this.req.data = data;
+    this.body = data;
   }
 
   setMaxRedirects(maxRedirects) {
@@ -92,8 +164,34 @@ class BrunoRequest {
   }
 
   setTimeout(timeout) {
+    this.timeout = timeout;
     this.req.timeout = timeout;
   }
+
+  __safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      return str;
+    }
+  }
+
+  __safeStringifyJSON(obj) {
+    try {
+      return JSON.stringify(obj);
+    } catch (e) {
+      return obj;
+    }
+  }
+
+  __isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+  }
+  
+
+  disableParsingResponseJson() {
+    this.req.__brunoDisableParsingResponseJson = true;
+  }
 }
 
 module.exports = BrunoRequest;

package/src/interpolate-string.js

@@ -2,16 +2,18 @@ const { interpolate } = require('@usebruno/common');
 
 const interpolateString = (
   str,
-  { envVariables = {}, collectionVariables = {}, processEnvVars = {}, requestVariables = {} }
+  { envVariables = {}, runtimeVariables = {}, processEnvVars = {}, collectionVariables = {}, folderVariables = {}, requestVariables = {} }
 ) => {
   if (!str || !str.length || typeof str !== 'string') {
     return str;
   }
 
   const combinedVars = {
+    ...collectionVariables,
     ...envVariables,
+    ...folderVariables,
     ...requestVariables,
-    ...collectionVariables,
+    ...runtimeVariables,
     process: {
       env: {
         ...processEnvVars

package/src/runtime/assert-runtime.js

@@ -5,6 +5,7 @@ const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser, uuid } = require('../utils');
 const { interpolateString } = require('../interpolate-string');
+const { executeQuickJsVm } = require('../sandbox/quickjs');
 
 const { expect } = chai;
 chai.use(require('chai-string'));
@@ -161,14 +162,40 @@ const isUnaryOperator = (operator) => {
   return unaryOperators.includes(operator);
 };
 
-const evaluateRhsOperand = (rhsOperand, operator, context) => {
+const evaluateJsTemplateLiteralBasedOnRuntime = (literal, context, runtime) => {
+  if (runtime === 'quickjs') {
+    return executeQuickJsVm({
+      script: literal,
+      context,
+      scriptType: 'template-literal'
+    });
+  }
+
+  return evaluateJsTemplateLiteral(literal, context);
+};
+
+const evaluateJsExpressionBasedOnRuntime = (expr, context, runtime) => {
+  if (runtime === 'quickjs') {
+    return executeQuickJsVm({
+      script: expr,
+      context,
+      scriptType: 'expression'
+    });
+  }
+
+  return evaluateJsExpression(expr, context);
+};
+
+const evaluateRhsOperand = (rhsOperand, operator, context, runtime) => {
   if (isUnaryOperator(operator)) {
     return;
   }
 
   const interpolationContext = {
-    requestVariables: context.bru.requestVariables,
     collectionVariables: context.bru.collectionVariables,
+    folderVariables: context.bru.folderVariables,
+    requestVariables: context.bru.requestVariables,
+    runtimeVariables: context.bru.runtimeVariables,
     envVariables: context.bru.envVariables,
     processEnvVars: context.bru.processEnvVars
   };
@@ -181,13 +208,17 @@ const evaluateRhsOperand = (rhsOperand, operator, context) => {
 
     return rhsOperand
       .split(',')
-      .map((v) => evaluateJsTemplateLiteral(interpolateString(v.trim(), interpolationContext), context));
+      .map((v) =>
+        evaluateJsTemplateLiteralBasedOnRuntime(interpolateString(v.trim(), interpolationContext), context, runtime)
+      );
   }
 
   if (operator === 'between') {
     const [lhs, rhs] = rhsOperand
       .split(',')
-      .map((v) => evaluateJsTemplateLiteral(interpolateString(v.trim(), interpolationContext), context));
+      .map((v) =>
+        evaluateJsTemplateLiteralBasedOnRuntime(interpolateString(v.trim(), interpolationContext), context, runtime)
+      );
     return [lhs, rhs];
   }
 
@@ -200,20 +231,17 @@ const evaluateRhsOperand = (rhsOperand, operator, context) => {
     return interpolateString(rhsOperand, interpolationContext);
   }
 
-  return evaluateJsTemplateLiteral(interpolateString(rhsOperand, interpolationContext), context);
+  return evaluateJsTemplateLiteralBasedOnRuntime(interpolateString(rhsOperand, interpolationContext), context, runtime);
 };
 
 class AssertRuntime {
-  runAssertions(
-    assertions,
-    request,
-    response,
-    envVariables,
-    collectionVariables,
-    processEnvVars,
-    historyLogger,
-    secretVariables
-  ) {
+  constructor(props) {
+    this.runtime = props?.runtime || 'vm2';
+  }
+
+  runAssertions(assertions, request, response, envVariables, runtimeVariables, processEnvVars, historyLogger, secretVariables) {
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
     const enabledAssertions = _.filter(assertions, (a) => a.enabled);
     if (!enabledAssertions.length) {
@@ -222,12 +250,14 @@ class AssertRuntime {
 
     const bru = new Bru(
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       processEnvVars,
       undefined, // collectionPath,
       undefined, // historyLogger,
-      undefined, // setHtmlVisualizationString,
+      undefined, // setVisualizations,
       secretVariables,
+      collectionVariables,
+      folderVariables,
       requestVariables
     );
     const req = new BrunoRequest(request, historyLogger);
@@ -240,9 +270,11 @@ class AssertRuntime {
     };
 
     const context = {
+      ...collectionVariables,
       ...envVariables,
+      ...folderVariables,
       ...requestVariables,
-      ...collectionVariables,
+      ...runtimeVariables,
       ...processEnvVars,
       ...bruContext
     };
@@ -256,8 +288,8 @@ class AssertRuntime {
       const { operator, value: rhsOperand } = parseAssertionOperator(rhsExpr);
 
       try {
-        const lhs = evaluateJsExpression(lhsExpr, context);
-        const rhs = evaluateRhsOperand(rhsOperand, operator, context);
+        const lhs = evaluateJsExpressionBasedOnRuntime(lhsExpr, context, this.runtime);
+        const rhs = evaluateRhsOperand(rhsOperand, operator, context, this.runtime);
 
         switch (operator) {
           case 'eq':

package/src/runtime/script-runtime.js

@@ -27,10 +27,13 @@ const axios = require('axios');
 const fetch = require('node-fetch');
 const chai = require('chai');
 const CryptoJS = require('crypto-js');
-const NodeSecrets = require('node-vault');
+const NodeVault = require('node-vault');
+const { executeQuickJsVmAsync } = require('../sandbox/quickjs');
 
 class ScriptRuntime {
-  constructor() {}
+  constructor(props) {
+    this.runtime = props?.runtime || 'vm2';
+  }
 
   // This approach is getting out of hand
   // Need to refactor this to use a single arg (object) instead of 7
@@ -38,7 +41,7 @@ class ScriptRuntime {
     script,
     request,
     envVariables,
-    collectionVariables,
+    runtimeVariables,
     collectionPath,
     onConsoleLog,
     processEnvVars,
@@ -46,21 +49,14 @@ class ScriptRuntime {
     historyLogger,
     secretVariables
   ) {
-    let htmlVisualizationString;
-    let setHtmlVisualizationString = (htmlString) => {
-      htmlVisualizationString = htmlString;
-    };
+    let visualizations = [];
+    let setVisualizations = (data) => {
+      visualizations.push(data);
+    }
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      collectionVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      setHtmlVisualizationString,
-      secretVariables,
-      requestVariables
-    );
+    const bru = new Bru(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables);
     const req = new BrunoRequest(request, historyLogger);
     const allowScriptFilesystemAccess = get(scriptingConfig, 'filesystemAccess.allow', false);
     const moduleWhitelist = get(scriptingConfig, 'moduleWhitelist', []);
@@ -101,6 +97,23 @@ class ScriptRuntime {
       };
     }
 
+    if (this.runtime === 'quickjs') {
+      await executeQuickJsVmAsync({
+        script: script,
+        context: context,
+        collectionPath
+      });
+
+      return {
+        request,
+        envVariables: cleanJson(envVariables),
+        runtimeVariables: cleanJson(runtimeVariables),
+        visualizations,
+        nextRequestName: bru.nextRequest
+      };
+    }
+
+    // default runtime is vm2
     const vm = new NodeVM({
       sandbox: context,
       require: {
@@ -132,17 +145,18 @@ class ScriptRuntime {
           'crypto-js': CryptoJS,
           ...whitelistedModules,
           fs: allowScriptFilesystemAccess ? fs : undefined,
-          'node-vault': NodeSecrets
+          'node-vault': NodeVault
         }
       }
     });
     const asyncVM = vm.run(`module.exports = async () => { ${script} }`, path.join(collectionPath, 'vm.js'));
     await asyncVM();
+
     return {
       request,
       envVariables: cleanJson(envVariables),
-      collectionVariables: cleanJson(collectionVariables),
-      htmlVisualizationString,
+      runtimeVariables: cleanJson(runtimeVariables),
+      visualizations,
       nextRequestName: bru.nextRequest
     };
   }
@@ -152,7 +166,7 @@ class ScriptRuntime {
     request,
     response,
     envVariables,
-    collectionVariables,
+    runtimeVariables,
     collectionPath,
     onConsoleLog,
     processEnvVars,
@@ -160,21 +174,14 @@ class ScriptRuntime {
     historyLogger,
     secretVariables
   ) {
-    let htmlVisualizationString;
-    let setHtmlVisualizationString = (htmlString) => {
-      htmlVisualizationString = htmlString;
-    };
+    let visualizations = [];
+    let setVisualizations = (data) => {
+      visualizations.push(data);
+    }
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      collectionVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      setHtmlVisualizationString,
-      secretVariables,
-      requestVariables
-    );
+    const bru = new Bru(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables);
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
     const allowScriptFilesystemAccess = get(scriptingConfig, 'filesystemAccess.allow', false);
@@ -207,10 +214,28 @@ class ScriptRuntime {
         log: customLogger('log'),
         info: customLogger('info'),
         warn: customLogger('warn'),
-        error: customLogger('error')
+        error: customLogger('error'),
+        debug: customLogger('debug')
+      };
+    }
+
+    if (this.runtime === 'quickjs') {
+      await executeQuickJsVmAsync({
+        script: script,
+        context: context,
+        collectionPath
+      });
+
+      return {
+        response,
+        envVariables: cleanJson(envVariables),
+        runtimeVariables: cleanJson(runtimeVariables),
+        visualizations,
+        nextRequestName: bru.nextRequest
       };
     }
 
+    // default runtime is vm2
     const vm = new NodeVM({
       sandbox: context,
       require: {
@@ -241,7 +266,7 @@ class ScriptRuntime {
           'crypto-js': CryptoJS,
           ...whitelistedModules,
           fs: allowScriptFilesystemAccess ? fs : undefined,
-          'node-vault': NodeSecrets
+          'node-vault': NodeVault
         }
       }
     });
@@ -252,8 +277,8 @@ class ScriptRuntime {
     return {
       response,
       envVariables: cleanJson(envVariables),
-      collectionVariables: cleanJson(collectionVariables),
-      htmlVisualizationString,
+      runtimeVariables: cleanJson(runtimeVariables),
+      visualizations,
       nextRequestName: bru.nextRequest
     };
   }