@usebruno/js 0.45.1 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.45.1",
+  "version": "0.46.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -13,7 +13,7 @@
     "prepack": "npm run test"
   },
   "dependencies": {
-    "@usebruno/common": "0.18.0",
+    "@usebruno/common": "0.20.0",
     "@usebruno/query": "0.2.0",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
@@ -35,7 +35,8 @@
     "tv4": "^1.3.0",
     "uuid": "^9.0.0",
     "xml-formatter": "^3.5.0",
-    "xml2js": "^0.6.2"
+    "xml2js": "^0.6.2",
+    "yaml": "^2.3.4"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^23.0.2",

package/src/bru.js

@@ -84,12 +84,19 @@ class Bru {
           deleteCookie: (url, cookieName, callback) => {
             const interpolatedUrl = this.interpolate(url);
             return cookieJar.deleteCookie(interpolatedUrl, cookieName, callback);
+          },
+
+          hasCookie: (url, cookieName, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.hasCookie(interpolatedUrl, cookieName, callback);
           }
         };
       }
     };
     // Holds variables that are marked as persistent by scripts
     this.persistentEnvVariables = {};
+    // Holds credential IDs to be reset after script execution
+    this.oauth2CredentialsToReset = [];
     this.runner = {
       skipRequest: () => {
         this.skipRequest = true;
@@ -211,15 +218,6 @@ class Bru {
       throw new Error(`Persistent environment variables must be strings. Received ${typeof value} for key "${key}".`);
     }
 
-    if (this.historyLogger) {
-      this.historyLogger({
-        uid: uuid(),
-        type: 'setEnvVar()',
-        data: { key, value },
-        createdAt: new Date().toISOString()
-      });
-    }
-
     this.envVariables[key] = value;
 
     if (options?.persist) {
@@ -235,6 +233,24 @@ class Bru {
     delete this.envVariables[key];
   }
 
+  getAllEnvVars() {
+    const vars = Object.assign({}, this.envVariables);
+    delete vars.__name__;
+    return vars;
+  }
+
+  deleteAllEnvVars() {
+    const envName = this.envVariables.__name__;
+    for (let key in this.envVariables) {
+      if (this.envVariables.hasOwnProperty(key)) {
+        delete this.envVariables[key];
+      }
+    }
+    if (envName !== undefined) {
+      this.envVariables.__name__ = envName;
+    }
+  }
+
   getGlobalEnvVar(key) {
     return this.interpolate(this.globalEnvironmentVariables[key]);
   }
@@ -247,10 +263,48 @@ class Bru {
     this.globalEnvironmentVariables[key] = value;
   }
 
+  // TODO: deleteGlobalEnvVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // deleteGlobalEnvVar(key) {
+  //   delete this.globalEnvironmentVariables[key];
+  // }
+
+  getAllGlobalEnvVars() {
+    return Object.assign({}, this.globalEnvironmentVariables);
+  }
+
+  // TODO: deleteAllGlobalEnvVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // deleteAllGlobalEnvVars() {
+  //   for (let key in this.globalEnvironmentVariables) {
+  //     if (this.globalEnvironmentVariables.hasOwnProperty(key)) {
+  //       delete this.globalEnvironmentVariables[key];
+  //     }
+  //   }
+  // }
+
   getOauth2CredentialVar(key) {
     return this.interpolate(this.oauth2CredentialVariables[key]);
   }
 
+  resetOauth2Credential(credentialId) {
+    if (!credentialId || typeof credentialId !== 'string') {
+      throw new Error('credentialId must be a non-empty string');
+    }
+
+    if (!this.oauth2CredentialsToReset.includes(credentialId)) {
+      this.oauth2CredentialsToReset.push(credentialId);
+    }
+
+    // Remove matching credential variables so subsequent getOauth2CredentialVar() calls return undefined
+    const prefix = `$oauth2.${credentialId}.`;
+    for (const key of Object.keys(this.oauth2CredentialVariables)) {
+      if (key.startsWith(prefix)) {
+        delete this.oauth2CredentialVariables[key];
+      }
+    }
+  }
+
   hasVar(key) {
     return Object.hasOwn(this.runtimeVariables, key);
   }
@@ -267,15 +321,6 @@ class Bru {
       );
     }
 
-    if (this.historyLogger) {
-      this.historyLogger({
-        uid: uuid(),
-        type: 'setVar()',
-        data: { key, value: value },
-        createdAt: new Date().toISOString()
-      });
-    }
-
     this.runtimeVariables[key] = value;
   }
 
@@ -302,10 +347,57 @@ class Bru {
     }
   }
 
+  getAllVars() {
+    return Object.assign({}, this.runtimeVariables);
+  }
+
   getCollectionVar(key) {
     return this.interpolate(this.collectionVariables[key]);
   }
 
+  // TODO: setCollectionVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // setCollectionVar(key, value) {
+  //   if (!key) {
+  //     throw new Error('Creating a variable without specifying a name is not allowed.');
+  //   }
+  //
+  //   if (variableNameRegex.test(key) === false) {
+  //     throw new Error(
+  //       `Variable name: "${key}" contains invalid characters!`
+  //       + ' Names must only contain alpha-numeric characters, "-", "_", "."'
+  //     );
+  //   }
+  //
+  //   this.collectionVariables[key] = value;
+  // }
+
+  hasCollectionVar(key) {
+    return Object.hasOwn(this.collectionVariables, key);
+  }
+
+  // TODO: deleteCollectionVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // deleteCollectionVar(key) {
+  //   delete this.collectionVariables[key];
+  // }
+
+  // TODO: deleteAllCollectionVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // deleteAllCollectionVars() {
+  //   for (let key in this.collectionVariables) {
+  //     if (this.collectionVariables.hasOwnProperty(key)) {
+  //       delete this.collectionVariables[key];
+  //     }
+  //   }
+  // }
+
+  // TODO: getAllCollectionVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // getAllCollectionVars() {
+  //   return Object.assign({}, this.collectionVariables);
+  // }
+
   getFolderVar(key) {
     return this.interpolate(this.folderVariables[key]);
   }

package/src/bruno-request.js

@@ -1,5 +1,3 @@
-const { uuid } = require('./utils');
-
 class BrunoRequest {
   /**
    * The following properties are available as shorthand:
@@ -129,23 +127,36 @@ class BrunoRequest {
     this.req.headers = headers;
   }
 
+  deleteHeaders(headers) {
+    headers.forEach((name) => this.deleteHeader(name));
+  }
+
   getHeader(name) {
     return this.req.headers[name];
   }
 
   setHeader(name, value) {
-    if (this.historyLogger) {
-      this.historyLogger({
-        uid: uuid(),
-        type: 'setHeader()',
-        data: { name, value },
-        createdAt: new Date().toISOString()
-      });
-    }
     this.headers[name] = value;
     this.req.headers[name] = value;
   }
 
+  deleteHeader(name) {
+    delete this.headers[name];
+    delete this.req.headers[name];
+
+    /**
+      Store header name to be applied in the axios request interceptor.
+      Default headers (user-agent, accept, accept-encoding, etc.) are added after
+      the pre-request script runs, so we track them here and delete them later.
+    */
+    if (!this.req.__headersToDelete) {
+      this.req.__headersToDelete = [];
+    }
+    if (!this.req.__headersToDelete.includes(name)) {
+      this.req.__headersToDelete.push(name);
+    }
+  }
+
   hasJSONContentType(headers) {
     const contentType = headers?.['Content-Type'] || headers?.['content-type'] || '';
     return contentType.includes('json');
@@ -181,15 +192,6 @@ class BrunoRequest {
    * 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(),
-        type: 'setBody()',
-        data: { body: data },
-        createdAt: new Date().toISOString()
-      });
-    }
-
     if (options.raw) {
       this.req.data = data;
       this.body = data;

package/src/index.js

@@ -3,11 +3,14 @@ const TestRuntime = require('./runtime/test-runtime');
 const VarsRuntime = require('./runtime/vars-runtime');
 const AssertRuntime = require('./runtime/assert-runtime');
 const { runScriptInNodeVm } = require('./sandbox/node-vm');
+const { formatErrorWithContext, SCRIPT_TYPES } = require('./utils/error-formatter');
 
 module.exports = {
   ScriptRuntime,
   TestRuntime,
   VarsRuntime,
   AssertRuntime,
-  runScriptInNodeVm
+  runScriptInNodeVm,
+  formatErrorWithContext,
+  SCRIPT_TYPES
 };

package/src/runtime/script-runtime.js

@@ -6,6 +6,7 @@ const { cleanJson } = require('../utils');
 const { createBruTestResultMethods } = require('../utils/results');
 const { runScriptInNodeVm } = require('../sandbox/node-vm');
 const { executeQuickJsVmAsync } = require('../sandbox/quickjs');
+const { SANDBOX } = require('../utils/sandbox');
 
 class ScriptRuntime {
   constructor(props) {
@@ -41,6 +42,7 @@ class ScriptRuntime {
     const iterationDetails = request?.runnerIterationDetails || {};
     const assertionResults = request?.assertionResults || [];
     const certsAndProxyConfig = request?.certsAndProxyConfig;
+    const scriptPath = request?.pathname;
     const bru = new Bru(this.runtime, envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables, globalEnvironmentVariables, oauth2CredentialVariables, iterationDetails, collectionName, promptVariables, certsAndProxyConfig);
     const req = new BrunoRequest(request);
 
@@ -75,47 +77,68 @@ class ScriptRuntime {
       context.bru.runRequest = runRequestByItemPathname;
     }
 
-    if (this.runtime === 'nodevm') {
-      await runScriptInNodeVm({
-        script,
-        context,
-        collectionPath,
-        scriptingConfig
-      });
-
-      return {
-        request,
-        envVariables: cleanJson(envVariables),
-        runtimeVariables: cleanJson(runtimeVariables),
-        visualizations,
-        persistentEnvVariables: bru.persistentEnvVariables,
-        globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
-        results: cleanJson(__brunoTestResults.getResults()),
-        nextRequestName: bru.nextRequest,
-        skipRequest: bru.skipRequest,
-        stopExecution: bru.stopExecution
-      };
-    }
-
-    // default runtime is `quickjs`
-    await executeQuickJsVmAsync({
-      script: script,
-      context: context,
-      collectionPath
-    });
-
-    return {
+    // Helper to build the result object for pre-request scripts
+    // Extracted to avoid duplication across runtime branches
+    const buildRequestScriptResult = () => ({
       request,
       envVariables: cleanJson(envVariables),
       runtimeVariables: cleanJson(runtimeVariables),
       visualizations,
       persistentEnvVariables: bru.persistentEnvVariables,
       globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
+      oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,
       skipRequest: bru.skipRequest,
       stopExecution: bru.stopExecution
-    };
+    });
+
+    // Track script errors to attach partial results before re-throwing
+    // This ensures that any test() calls that passed before the error are preserved
+    // Similar pattern to test-runtime.js which already handles this correctly
+    let scriptError = null;
+
+    if (this.runtime === SANDBOX.NODEVM) {
+      try {
+        await runScriptInNodeVm({
+          script,
+          context,
+          collectionPath,
+          scriptingConfig,
+          scriptPath
+        });
+      } catch (error) {
+        scriptError = error;
+      }
+
+      // If script errored, attach partial results so callers can display passed tests
+      // before the error occurred (e.g., 2 tests pass, then script throws)
+      if (scriptError) {
+        scriptError.partialResults = buildRequestScriptResult();
+        throw scriptError;
+      }
+
+      return buildRequestScriptResult();
+    }
+
+    // default runtime is `quickjs`
+    try {
+      await executeQuickJsVmAsync({
+        script: script,
+        context: context,
+        collectionPath,
+        scriptPath
+      });
+    } catch (error) {
+      scriptError = error;
+    }
+
+    if (scriptError) {
+      scriptError.partialResults = buildRequestScriptResult();
+      throw scriptError;
+    }
+
+    return buildRequestScriptResult();
   }
 
   async runResponseScript(
@@ -146,6 +169,7 @@ class ScriptRuntime {
     const iterationDetails = request?.runnerIterationDetails || {};
     const assertionResults = request?.assertionResults || [];
     const certsAndProxyConfig = request?.certsAndProxyConfig;
+    const scriptPath = request?.pathname;
     const bru = new Bru(this.runtime, envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, setVisualizations, secretVariables, collectionVariables, folderVariables, requestVariables, globalEnvironmentVariables, oauth2CredentialVariables, iterationDetails, collectionName, promptVariables, certsAndProxyConfig);
     const req = new BrunoRequest(request);
     const res = new BrunoResponse(response);
@@ -182,47 +206,68 @@ class ScriptRuntime {
       context.bru.runRequest = runRequestByItemPathname;
     }
 
-    if (this.runtime === 'nodevm') {
-      await runScriptInNodeVm({
-        script,
-        context,
-        collectionPath,
-        scriptingConfig
-      });
-
-      return {
-        response,
-        envVariables: cleanJson(envVariables),
-        persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
-        runtimeVariables: cleanJson(runtimeVariables),
-        visualizations,
-        globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
-        results: cleanJson(__brunoTestResults.getResults()),
-        nextRequestName: bru.nextRequest,
-        skipRequest: bru.skipRequest,
-        stopExecution: bru.stopExecution
-      };
-    }
-
-    // default runtime is `quickjs`
-    await executeQuickJsVmAsync({
-      script: script,
-      context: context,
-      collectionPath
-    });
-
-    return {
+    // Helper to build the result object for post-response scripts
+    // Extracted to avoid duplication across runtime branches
+    const buildResponseScriptResult = () => ({
       response,
       envVariables: cleanJson(envVariables),
       persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
       runtimeVariables: cleanJson(runtimeVariables),
       visualizations,
       globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
+      oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,
       skipRequest: bru.skipRequest,
       stopExecution: bru.stopExecution
-    };
+    });
+
+    // Track script errors to attach partial results before re-throwing
+    // This ensures that any test() calls that passed before the error are preserved
+    // Similar pattern to test-runtime.js which already handles this correctly
+    let scriptError = null;
+
+    if (this.runtime === SANDBOX.NODEVM) {
+      try {
+        await runScriptInNodeVm({
+          script,
+          context,
+          collectionPath,
+          scriptingConfig,
+          scriptPath
+        });
+      } catch (error) {
+        scriptError = error;
+      }
+
+      // If script errored, attach partial results so callers can display passed tests
+      // before the error occurred (e.g., 2 tests pass, then script throws)
+      if (scriptError) {
+        scriptError.partialResults = buildResponseScriptResult();
+        throw scriptError;
+      }
+
+      return buildResponseScriptResult();
+    }
+
+    // default runtime is `quickjs`
+    try {
+      await executeQuickJsVmAsync({
+        script: script,
+        context: context,
+        collectionPath,
+        scriptPath
+      });
+    } catch (error) {
+      scriptError = error;
+    }
+
+    if (scriptError) {
+      scriptError.partialResults = buildResponseScriptResult();
+      throw scriptError;
+    }
+
+    return buildResponseScriptResult();
   }
 }
 

package/src/runtime/test-runtime.js

@@ -8,6 +8,7 @@ const { createBruTestResultMethods } = require('../utils/results');
 const { runScriptInNodeVm } = require('../sandbox/node-vm');
 const jsonwebtoken = require('jsonwebtoken');
 const { executeQuickJsVmAsync } = require('../sandbox/quickjs');
+const { SANDBOX } = require('../utils/sandbox');
 
 class TestRuntime {
   constructor(props) {
@@ -38,6 +39,7 @@ class TestRuntime {
     const iterationDetails = request?.runnerIterationDetails || {};
     const assertionResults = request?.assertionResults || [];
     const certsAndProxyConfig = request?.certsAndProxyConfig;
+    const scriptPath = request?.pathname;
     const bru = new Bru(this.runtime, envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, undefined, secretVariables, collectionVariables, folderVariables, requestVariables, globalEnvironmentVariables, oauth2CredentialVariables, iterationDetails, collectionName, promptVariables, certsAndProxyConfig);
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
@@ -89,19 +91,21 @@ class TestRuntime {
     let scriptError = null;
 
     try {
-      if (this.runtime === 'nodevm') {
+      if (this.runtime === SANDBOX.NODEVM) {
         await runScriptInNodeVm({
           script: testsFile,
           context,
           collectionPath,
-          scriptingConfig
+          scriptingConfig,
+          scriptPath
         });
       } else {
         // default runtime is `quickjs`
         await executeQuickJsVmAsync({
           script: testsFile,
           context: context,
-          collectionPath
+          collectionPath,
+          scriptPath
         });
       }
     } catch (error) {
@@ -123,6 +127,7 @@ class TestRuntime {
       runtimeVariables: cleanJson(runtimeVariables),
       globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
       persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
+      oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest
     };

package/src/sandbox/node-vm/console.js

@@ -0,0 +1,102 @@
+/**
+ * Gets the type tag of a value using Object.prototype.toString
+ * This works across VM context boundaries unlike instanceof
+ * @param {*} value - The value to check
+ * @returns {string} The type tag (e.g., 'Set', 'Map', 'Array', 'Object')
+ */
+function getTypeTag(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+
+/**
+ * Transforms a value, converting Set and Map to a special format for display
+ * Uses Object.prototype.toString for cross-context type detection
+ * @param {*} value - The value to transform
+ * @param {WeakSet} seen - Set of already visited objects for circular ref detection
+ * @returns {*} Transformed value with Set/Map converted to __brunoType format
+ */
+function transformValue(value, seen = new WeakSet()) {
+  // Return primitives as-is
+  if (value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function') {
+    return value;
+  }
+
+  // Circular reference check for objects
+  if (typeof value === 'object') {
+    if (seen.has(value)) {
+      return '[Circular]';
+    }
+    seen.add(value);
+  }
+
+  const typeTag = getTypeTag(value);
+
+  if (typeTag === 'Set') {
+    return {
+      __brunoType: 'Set',
+      __brunoValue: Array.from(value).map((item) => transformValue(item, seen))
+    };
+  }
+
+  if (typeTag === 'Map') {
+    return {
+      __brunoType: 'Map',
+      __brunoValue: Array.from(value.entries()).map(([k, v]) => [
+        transformValue(k, seen),
+        transformValue(v, seen)
+      ])
+    };
+  }
+
+  if (typeTag === 'Array') {
+    return value.map((item) => transformValue(item, seen));
+  }
+
+  if (typeTag === 'Object') {
+    const transformed = {};
+    for (const [key, val] of Object.entries(value)) {
+      transformed[key] = transformValue(val, seen);
+    }
+    return transformed;
+  }
+
+  // Handle functions - show clean wrapper
+  if (typeTag === 'Function' || typeof value === 'function') {
+    const name = value.name || 'anonymous';
+    return `function ${name}() {\n    [native code]\n}`;
+  }
+
+  // Handle other built-in types (Date, RegExp, Error, etc.) - convert to string representation
+  try {
+    return value?.toString?.() ?? String(value);
+  } catch {
+    return `[${typeTag}]`;
+  }
+}
+
+/**
+ * Wraps a console object to add Set/Map support for logging
+ * @param {Object} originalConsole - The original console object
+ * @returns {Object} Wrapped console with Set/Map transformation
+ */
+function wrapConsoleWithSerializers(originalConsole) {
+  if (!originalConsole) return originalConsole;
+
+  const methodsToWrap = ['log', 'debug', 'info', 'warn', 'error'];
+  const wrappedConsole = { ...originalConsole };
+
+  for (const method of methodsToWrap) {
+    if (typeof originalConsole[method] === 'function') {
+      wrappedConsole[method] = (...args) => {
+        const transformedArgs = args.map((arg) => transformValue(arg));
+        originalConsole[method](...transformedArgs);
+      };
+    }
+  }
+
+  return wrappedConsole;
+}
+
+module.exports = {
+  wrapConsoleWithSerializers
+};