@usebruno/js 0.15.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [

package/src/bru.js

@@ -5,20 +5,13 @@ const { interpolate } = require('@usebruno/common');
 const variableNameRegex = /^[\w-.]*$/;
 
 class Bru {
-  constructor(
-    envVariables,
-    runtimeVariables,
-    processEnvVars,
-    collectionPath,
-    historyLogger,
-    setVisualizations,
-    secretVariables,
-    requestVariables
-  ) {
+  constructor(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables) {
     this.envVariables = envVariables || {};
     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;
@@ -31,7 +24,9 @@ class Bru {
     }
 
     const combinedVars = {
+      ...this.collectionVariables,
       ...this.envVariables,
+      ...this.folderVariables,
       ...this.requestVariables,
       ...this.runtimeVariables,
       process: {
@@ -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, "-", "_", "."'
       );
     }
 
@@ -113,7 +108,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, "-", "_", "."'
       );
     }
 
@@ -124,6 +119,14 @@ class Bru {
     delete this.runtimeVariables[key];
   }
 
+  getCollectionVar(key) {
+    return this._interpolate(this.collectionVariables[key]);
+  }
+
+  getFolderVar(key) {
+    return this._interpolate(this.folderVariables[key]);
+  }
+
   getRequestVar(key) {
     return this._interpolate(this.requestVariables[key]);
   }
@@ -158,7 +161,7 @@ class Bru {
       this.setVisualizations({ uid: uuid(), type, data });
     }
   }
-  
+
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }

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/bruno-response.js

@@ -27,6 +27,15 @@ class BrunoResponse {
   getResponseTime() {
     return this.res ? this.res.responseTime : null;
   }
+
+  setBody(data) {
+    if (!this.res) {
+      return;
+    }
+
+    this.body = data;
+    this.res.data = data;
+  }
 }
 
 module.exports = BrunoResponse;

package/src/interpolate-string.js

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

package/src/runtime/assert-runtime.js

@@ -192,6 +192,8 @@ const evaluateRhsOperand = (rhsOperand, operator, context, runtime) => {
   }
 
   const interpolationContext = {
+    collectionVariables: context.bru.collectionVariables,
+    folderVariables: context.bru.folderVariables,
     requestVariables: context.bru.requestVariables,
     runtimeVariables: context.bru.runtimeVariables,
     envVariables: context.bru.envVariables,
@@ -238,6 +240,8 @@ class AssertRuntime {
   }
 
   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) {
@@ -252,6 +256,8 @@ class AssertRuntime {
       undefined, // historyLogger,
       undefined, // setVisualizations,
       secretVariables,
+      collectionVariables,
+      folderVariables,
       requestVariables
     );
     const req = new BrunoRequest(request, historyLogger);
@@ -264,7 +270,9 @@ class AssertRuntime {
     };
 
     const context = {
+      ...collectionVariables,
       ...envVariables,
+      ...folderVariables,
       ...requestVariables,
       ...runtimeVariables,
       ...processEnvVars,

package/src/runtime/script-runtime.js

@@ -53,17 +53,10 @@ class ScriptRuntime {
     let setVisualizations = (data) => {
       visualizations.push(data);
     }
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      runtimeVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      setVisualizations,
-      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', []);
@@ -185,17 +178,10 @@ class ScriptRuntime {
     let setVisualizations = (data) => {
       visualizations.push(data);
     }
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      runtimeVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      setVisualizations,
-      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);

package/src/runtime/test-runtime.js

@@ -50,17 +50,10 @@ class TestRuntime {
     historyLogger,
     secretVariables
   ) {
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      runtimeVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      undefined, // setVisualizations
-      secretVariables,
-      requestVariables
-    );
+    const bru = new Bru(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, undefined, secretVariables, collectionVariables, folderVariables, requestVariables);
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
     const allowScriptFilesystemAccess = get(scriptingConfig, 'filesystemAccess.allow', false);
@@ -95,8 +88,6 @@ class TestRuntime {
       };
     }
 
-    // add 'await' prefix to the test function calls
-    testsFile = appendAwaitToTestFunc(testsFile);
 
     const context = {
       test,

package/src/runtime/vars-runtime.js

@@ -1,22 +1,10 @@
 const _ = require('lodash');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
-const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser } = require('../utils');
+const { evaluateJsExpression, createResponseParser } = require('../utils');
 
 const { executeQuickJsVm } = require('../sandbox/quickjs');
 
-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, mode) => {
   if (runtime === 'quickjs') {
     return executeQuickJsVm({
@@ -35,56 +23,7 @@ class VarsRuntime {
     this.mode = props?.mode || 'developer';
   }
 
-  runPreRequestVars(vars, request, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVars = {}) {
-    if (!request?.requestVariables) {
-      request.requestVariables = {};
-    }
-    const enabledVars = _.filter(vars, (v) => v.enabled);
-    if (!enabledVars.length) {
-      return;
-    }
-
-    const bru = new Bru(
-      envVariables,
-      runtimeVariables,
-      processEnvVars,
-      null,
-      historyLogger,
-      undefined, // setVisualizations
-      secretVars,
-      undefined, // requestVariables
-    );
-    const req = new BrunoRequest(request, historyLogger);
-
-    const bruContext = {
-      bru,
-      req
-    };
-
-    const context = {
-      ...envVariables,
-      ...runtimeVariables,
-      ...secretVars,
-      ...bruContext
-    };
-
-    _.each(enabledVars, (v) => {
-      const value = evaluateJsTemplateLiteralBasedOnRuntime(v.value, context, this.runtime);
-      request?.requestVariables && (request.requestVariables[v.name] = value);
-    });
-  }
-
-  runPostResponseVars(
-    vars,
-    request,
-    response,
-    envVariables,
-    runtimeVariables,
-    collectionPath,
-    processEnvVars,
-    historyLogger,
-    secretVars = {}
-  ) {
+  runPostResponseVars(vars, request, response, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVars = {}) {
     const requestVariables = request?.requestVariables || {};
     const enabledVars = _.filter(vars, (v) => v.enabled);
     if (!enabledVars.length) {

package/src/sandbox/quickjs/shims/bru.js

@@ -69,6 +69,18 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'getRequestVar', getRequestVar);
   getRequestVar.dispose();
 
+  let getFolderVar = vm.newFunction('getFolderVar', function (key) {
+    return marshallToVm(bru.getFolderVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getFolderVar', getFolderVar);
+  getFolderVar.dispose();
+
+  let getCollectionVar = vm.newFunction('getCollectionVar', function (key) {
+    return marshallToVm(bru.getCollectionVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getCollectionVar', getCollectionVar);
+  getCollectionVar.dispose();
+
   const sleep = vm.newFunction('sleep', (timer) => {
     const t = vm.getString(timer);
     const promise = vm.newPromise();

package/src/sandbox/quickjs/shims/bruno-request.js

@@ -105,6 +105,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'setTimeout', setTimeout);
   setTimeout.dispose();
 
+  let disableParsingResponseJson = vm.newFunction('disableParsingResponseJson', function () {
+    req.disableParsingResponseJson();
+  });
+  vm.setProp(reqObject, 'disableParsingResponseJson', disableParsingResponseJson);
+  disableParsingResponseJson.dispose();
+
   vm.setProp(vm.global, 'req', reqObject);
   reqObject.dispose();
 };

package/src/sandbox/quickjs/utils/index.js

@@ -25,6 +25,8 @@ const marshallToVm = (value, vm) => {
       }
       return obj;
     }
+  } else if (typeof value === 'function') {
+    return vm.newString('[Function (anonymous)]');
   }
 };