@usebruno/js 0.46.0 → 0.47.0

package/src/property-list.js

@@ -0,0 +1,184 @@
+const ReadOnlyPropertyList = require('./readonly-property-list');
+
+/**
+ * PropertyList - A mutable collection data structure.
+ *
+ * Extends ReadOnlyPropertyList with mutation methods that operate on the
+ * internal _items array in static mode. In dynamic mode, all mutations
+ * throw — subclasses (e.g. CookieList) override with async implementations.
+ *
+ * Class hierarchy:
+ *   ReadOnlyPropertyList  (read-only, both modes)
+ *     └── PropertyList    (sync mutations in static mode; throws in dynamic mode)
+ *          └── CookieList (overrides add/upsert/remove/clear/delete with async jar ops)
+ */
+class PropertyList extends ReadOnlyPropertyList {
+  /**
+   * Guard that throws in dynamic mode. Called by all mutation methods.
+   * @param {string} method - Name of the calling method (for error message)
+   */
+  #ensureStaticMode(method) {
+    if (this._dynamic) {
+      throw new Error(`${method}() is not supported in dynamic mode. Override in subclass.`);
+    }
+  }
+
+  // ── Mutation methods ──────────────────────────────────────────────────
+
+  /**
+   * Append an item to the end of the list.
+   * @param {object} item
+   */
+  add(item) {
+    this.#ensureStaticMode('add');
+    this._items.push(item);
+  }
+
+  /**
+   * Alias for add().
+   * @param {object} item
+   */
+  append(item) {
+    return this.add(item);
+  }
+
+  /**
+   * Insert an item at the beginning of the list.
+   * @param {object} item
+   */
+  prepend(item) {
+    this.#ensureStaticMode('prepend');
+    this._items.unshift(item);
+  }
+
+  /**
+   * Insert an item before a reference item.
+   * @param {object} item - The item to insert
+   * @param {string|object} before - Key string or item object to insert before
+   */
+  insert(item, before) {
+    this.#ensureStaticMode('insert');
+    const idx = this.#findIndex(before);
+    if (idx === -1) {
+      this._items.push(item);
+    } else {
+      this._items.splice(idx, 0, item);
+    }
+  }
+
+  /**
+   * Insert an item after a reference item.
+   * @param {object} item - The item to insert
+   * @param {string|object} after - Key string or item object to insert after
+   */
+  insertAfter(item, after) {
+    this.#ensureStaticMode('insertAfter');
+    const idx = this.#findIndex(after);
+    if (idx === -1) {
+      this._items.push(item);
+    } else {
+      this._items.splice(idx + 1, 0, item);
+    }
+  }
+
+  /**
+   * Remove items matching a predicate, key string, or item reference.
+   * @param {Function|string|object} predicate
+   */
+  remove(predicate) {
+    this.#ensureStaticMode('remove');
+    if (typeof predicate === 'function') {
+      this._items = this._items.filter((item) => !predicate(item));
+    } else if (typeof predicate === 'string') {
+      this._items = this._items.filter((item) => item[this._keyProperty] !== predicate);
+    } else if (predicate && typeof predicate === 'object') {
+      const idx = this.indexOf(predicate);
+      if (idx !== -1) {
+        this._items.splice(idx, 1);
+      }
+    }
+  }
+
+  /**
+   * Remove all items from the list.
+   */
+  clear() {
+    this.#ensureStaticMode('clear');
+    this._items = [];
+  }
+
+  /**
+   * Update an existing item by key, or append if not found.
+   * @param {object} item
+   */
+  upsert(item) {
+    this.#ensureStaticMode('upsert');
+    const key = item[this._keyProperty];
+    const idx = this._items.findIndex((i) => i[this._keyProperty] === key);
+    if (idx !== -1) {
+      this._items[idx] = item;
+    } else {
+      this._items.push(item);
+    }
+  }
+
+  /**
+   * Replace all items with a new array.
+   * @param {Array} items
+   */
+  populate(items) {
+    this.#ensureStaticMode('populate');
+    this._items = Array.isArray(items) ? [...items] : [];
+  }
+
+  /**
+   * Clear and repopulate with new items.
+   * @param {Array} items
+   */
+  repopulate(items) {
+    this.#ensureStaticMode('repopulate');
+    this.populate(items);
+  }
+
+  /**
+   * Merge items from another PropertyList or array.
+   * @param {PropertyList|Array} source - Source of items to merge
+   * @param {boolean} [prune=false] - If true, clear existing items first
+   */
+  assimilate(source, prune) {
+    this.#ensureStaticMode('assimilate');
+    if (prune) {
+      this._items = [];
+    }
+    let items;
+    if (ReadOnlyPropertyList.isPropertyList(source)) {
+      items = source.all();
+    } else if (Array.isArray(source)) {
+      items = source;
+    } else {
+      items = [];
+    }
+    for (const item of items) {
+      this._items.push(item);
+    }
+  }
+
+  // ── Internal helpers ──────────────────────────────────────────────────
+
+  /**
+   * Find the index of a reference (key string or item object).
+   * @param {string|object} ref
+   * @returns {number}
+   */
+  #findIndex(ref) {
+    if (typeof ref === 'string') {
+      return this._items.findIndex((i) => i[this._keyProperty] === ref);
+    }
+    if (ref && typeof ref === 'object') {
+      return this.indexOf(ref);
+    }
+    return -1;
+  }
+}
+
+module.exports = PropertyList;

package/src/readonly-property-list.js

@@ -0,0 +1,227 @@
+/**
+ * ReadOnlyPropertyList - A read-only collection data structure.
+ *
+ * Two modes:
+ * - Static mode: items stored internally in an array (for headers, query params, etc.)
+ * - Dynamic mode: a dataSource function returns fresh items on every read (for cookies)
+ *
+ * Items are plain objects with a configurable key property (keyProperty) and value property (valueProperty).
+ *
+ * This base class provides only read/search/iteration/transform methods.
+ * See PropertyList for static-mode mutation methods.
+ * See CookieList for async cookie-jar write methods.
+ *
+ * Convention:
+ *   #field / #method  – truly private, inaccessible to subclasses
+ *   _field / _method  – protected, intended for subclass access only
+ */
+class ReadOnlyPropertyList {
+  // ── Private fields (not accessible by subclasses) ────────────────────
+  #valueProperty;
+  #dataSource;
+
+  /**
+   * @param {object} options
+   * @param {string} [options.keyProperty='key'] - The property name used as the unique key
+   * @param {string} [options.valueProperty='value'] - The property name used as the value
+   * @param {Function} [options.dataSource] - Dynamic data source function (returns array of items)
+   * @param {Array} [options.items] - Initial items for static mode
+   */
+  // Items are stored in an array (not a Map) to support positional access (idx, indexOf),
+  // ordered insertion (insert, insertAfter, prepend in PropertyList), and duplicate keys.
+  // At typical list sizes (cookies, headers) the O(n) key lookup is negligible.
+  constructor({ keyProperty = 'key', valueProperty = 'value', dataSource, items } = {}) {
+    this._keyProperty = keyProperty;
+    this.#valueProperty = valueProperty;
+    this._dynamic = typeof dataSource === 'function';
+    if (this._dynamic) {
+      this.#dataSource = dataSource;
+    } else {
+      this._items = Array.isArray(items) ? [...items] : [];
+    }
+  }
+
+  /**
+   * Returns the current list of items.
+   * In dynamic mode, calls the dataSource function.
+   * In static mode, returns the internal array.
+   */
+  #getItems() {
+    return this._dynamic ? this.#dataSource() : this._items;
+  }
+
+  // ── Retrieval ──────────────────────────────────────────────────────────
+
+  /**
+   * Get the value of an item by its key.
+   * @param {string} name
+   * @returns {*} The value property of the matching item, or undefined
+   */
+  get(name) {
+    const items = this.#getItems();
+    // Use findLast so that duplicate keys resolve to the last entry,
+    // consistent with toObject() which also gives last-wins semantics.
+    const item = items.findLast((i) => i[this._keyProperty] === name);
+    return item ? item[this.#valueProperty] : undefined;
+  }
+
+  /**
+   * Get the full item object by its key.
+   * @param {string} name
+   * @returns {object|undefined}
+   */
+  one(name) {
+    const items = this.#getItems();
+    // Use findLast so that duplicate keys resolve to the last entry,
+    // consistent with get() and toObject() which also give last-wins semantics.
+    return items.findLast((i) => i[this._keyProperty] === name);
+  }
+
+  /**
+   * Get a cloned array of all items.
+   * @returns {Array}
+   */
+  all() {
+    return [...this.#getItems()];
+  }
+
+  /**
+   * Get an item by its positional index.
+   * @param {number} index
+   * @returns {object|undefined}
+   */
+  idx(index) {
+    return this.#getItems()[index];
+  }
+
+  /**
+   * Get the number of items.
+   * @returns {number}
+   */
+  count() {
+    return this.#getItems().length;
+  }
+
+  /**
+   * Get the index of an item.
+   * Uses structural equality (matching by key and value) so it works
+   * even when the item is a copy rather than the same reference.
+   * @param {object} item
+   * @returns {number} -1 if not found
+   */
+  indexOf(item) {
+    if (!item || typeof item !== 'object') return -1;
+    const items = this.#getItems();
+    const keyProp = this._keyProperty;
+    return items.findIndex(
+      (i) => i[keyProp] === item[keyProp] && i[this.#valueProperty] === item[this.#valueProperty]
+    );
+  }
+
+  // ── Search ─────────────────────────────────────────────────────────────
+
+  /**
+   * Check if an item with the given key exists.
+   * If value is provided, also checks that the item's value matches.
+   * @param {string} name
+   * @param {*} [value]
+   * @returns {boolean}
+   */
+  has(name, value) {
+    const items = this.#getItems();
+    if (value !== undefined) {
+      return items.some((i) => i[this._keyProperty] === name && i[this.#valueProperty] === value);
+    }
+    return items.some((i) => i[this._keyProperty] === name);
+  }
+
+  /**
+   * Find the first item matching a predicate.
+   * @param {Function} predicate
+   * @returns {object|undefined}
+   */
+  find(predicate) {
+    return this.#getItems().find(predicate);
+  }
+
+  /**
+   * Filter items by a predicate.
+   * @param {Function} predicate
+   * @returns {Array}
+   */
+  filter(predicate) {
+    return this.#getItems().filter(predicate);
+  }
+
+  // ── Iteration ──────────────────────────────────────────────────────────
+
+  /**
+   * Iterate over each item.
+   * @param {Function} fn - Called with (item, index)
+   */
+  each(fn) {
+    this.#getItems().forEach(fn);
+  }
+
+  /**
+   * Map over items.
+   * @param {Function} fn
+   * @returns {Array}
+   */
+  map(fn) {
+    return this.#getItems().map(fn);
+  }
+
+  /**
+   * Reduce items.
+   * @param {Function} fn
+   * @param {*} [initialValue] - Optional initial accumulator value
+   * @returns {*}
+   */
+  reduce(fn, ...rest) {
+    return rest.length ? this.#getItems().reduce(fn, rest[0]) : this.#getItems().reduce(fn);
+  }
+
+  // ── Transformation ─────────────────────────────────────────────────────
+
+  /**
+   * Convert to a plain object { key: value }.
+   * @returns {object}
+   */
+  toObject() {
+    const result = {};
+    for (const item of this.#getItems()) {
+      result[item[this._keyProperty]] = item[this.#valueProperty];
+    }
+    return result;
+  }
+
+  /**
+   * Convert to a string "key=value; key2=value2".
+   * @returns {string}
+   */
+  toString() {
+    return this.#getItems()
+      .map((i) => `${i[this._keyProperty]}=${i[this.#valueProperty]}`)
+      .join('; ');
+  }
+
+  /**
+   * Convert to JSON (returns the same as all()).
+   * @returns {Array}
+   */
+  toJSON() {
+    return this.all();
+  }
+
+  /**
+   * Check if an object is an instance of ReadOnlyPropertyList.
+   * @param {*} obj
+   * @returns {boolean}
+   */
+  static isPropertyList(obj) {
+    return obj instanceof ReadOnlyPropertyList;
+  }
+}
+
+module.exports = ReadOnlyPropertyList;

package/src/runtime/assert-runtime.js

@@ -17,8 +17,8 @@ chai.use(function (chai, utils) {
     // Objects created inside Node's vm.createContext() have a different Object constructor,
     // so obj.constructor === Object fails for objects passed via res.setBody() from scripts.
     // Note: toString check is more permissive than constructor check — custom class instances
-    const isJson = typeof obj === 'object' && obj !== null && !Array.isArray(obj)
-      && Object.prototype.toString.call(obj) === '[object Object]';
+    const isJson = typeof obj === 'object' && obj !== null
+      && (Array.isArray(obj) || Object.prototype.toString.call(obj) === '[object Object]');
 
     this.assert(isJson, `expected ${utils.inspect(obj)} to be JSON`, `expected ${utils.inspect(obj)} not to be JSON`);
   });
@@ -263,14 +263,12 @@ class AssertRuntime {
     }
 
     const certsAndProxyConfig = request?.certsAndProxyConfig;
-    const bru = new Bru(
-      this.runtime,
+    const bru = new Bru({
+      runtime: this.runtime,
       envVariables,
       runtimeVariables,
       processEnvVars,
-      undefined, // collectionPath,
-      undefined, // historyLogger,
-      undefined, // setVisualizations,
+      historyLogger,
       secretVariables,
       collectionVariables,
       folderVariables,
@@ -278,10 +276,10 @@ class AssertRuntime {
       globalEnvironmentVariables,
       oauth2CredentialVariables,
       iterationDetails,
-      undefined,
       promptVariables,
-      certsAndProxyConfig
-    );
+      certsAndProxyConfig,
+      requestUrl: request?.url
+    });
     const req = new BrunoRequest(request, historyLogger);
     const res = createResponseParser(response);
 

package/src/runtime/script-runtime.js

@@ -1,5 +1,6 @@
 const chai = require('chai');
 const Bru = require('../bru');
+const { VISUALIZATION_CLEAR } = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
 const { cleanJson } = require('../utils');
@@ -31,7 +32,11 @@ class ScriptRuntime {
   ) {
     let visualizations = [];
     let setVisualizations = (data) => {
-      visualizations.push(data);
+      if (data.type === VISUALIZATION_CLEAR) {
+        visualizations = [];
+      } else {
+        visualizations.push(data);
+      }
     };
     const globalEnvironmentVariables = request?.globalEnvironmentVariables || {};
     const oauth2CredentialVariables = request?.oauth2CredentialVariables || {};
@@ -43,8 +48,28 @@ class ScriptRuntime {
     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 bru = new Bru({
+      runtime: this.runtime,
+      envVariables,
+      runtimeVariables,
+      processEnvVars,
+      collectionPath,
+      historyLogger,
+      setVisualizations,
+      secretVariables,
+      collectionVariables,
+      folderVariables,
+      requestVariables,
+      globalEnvironmentVariables,
+      oauth2CredentialVariables,
+      iterationDetails,
+      collectionName,
+      promptVariables,
+      certsAndProxyConfig,
+      requestUrl: request?.url,
+      onConsoleLog
+    });
+    const req = new BrunoRequest(request, historyLogger);
 
     // extend bru with result getter methods
     const { __brunoTestResults, test } = createBruTestResultMethods(bru, assertionResults, chai);
@@ -158,7 +183,11 @@ class ScriptRuntime {
   ) {
     let visualizations = [];
     let setVisualizations = (data) => {
-      visualizations.push(data);
+      if (data.type === VISUALIZATION_CLEAR) {
+        visualizations = [];
+      } else {
+        visualizations.push(data);
+      }
     };
     const globalEnvironmentVariables = request?.globalEnvironmentVariables || {};
     const oauth2CredentialVariables = request?.oauth2CredentialVariables || {};
@@ -170,8 +199,28 @@ class ScriptRuntime {
     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 bru = new Bru({
+      runtime: this.runtime,
+      envVariables,
+      runtimeVariables,
+      processEnvVars,
+      collectionPath,
+      historyLogger,
+      setVisualizations,
+      secretVariables,
+      collectionVariables,
+      folderVariables,
+      requestVariables,
+      globalEnvironmentVariables,
+      oauth2CredentialVariables,
+      iterationDetails,
+      collectionName,
+      promptVariables,
+      certsAndProxyConfig,
+      requestUrl: request?.url,
+      onConsoleLog
+    });
+    const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
 
     // extend bru with result getter methods

package/src/runtime/test-runtime.js

@@ -40,7 +40,25 @@ class TestRuntime {
     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 bru = new Bru({
+      runtime: this.runtime,
+      envVariables,
+      runtimeVariables,
+      processEnvVars,
+      collectionPath,
+      historyLogger,
+      secretVariables,
+      collectionVariables,
+      folderVariables,
+      requestVariables,
+      globalEnvironmentVariables,
+      oauth2CredentialVariables,
+      iterationDetails,
+      collectionName,
+      promptVariables,
+      certsAndProxyConfig,
+      requestUrl: request?.url
+    });
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
 

package/src/runtime/vars-runtime.js

@@ -24,7 +24,7 @@ class VarsRuntime {
     this.mode = props?.mode || 'developer';
   }
 
-  runPostResponseVars(vars, request, response, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVars = {}) {
+  runPostResponseVars(vars, request, response, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVariables = {}) {
     const requestVariables = request?.requestVariables || {};
     const globalEnvironmentVariables = request?.globalEnvironmentVariables || {};
     const oauth2CredentialVariables = request?.oauth2CredentialVariables || {};
@@ -38,7 +38,24 @@ class VarsRuntime {
 
     const promptVariables = request?.promptVariables || {};
     const certsAndProxyConfig = request?.certsAndProxyConfig;
-    const bru = new Bru(this.runtime, envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, undefined, secretVars, collectionVariables, folderVariables, requestVariables, globalEnvironmentVariables, oauth2CredentialVariables, iterationDetails, undefined, promptVariables, certsAndProxyConfig);
+    const bru = new Bru({
+      runtime: this.runtime,
+      envVariables,
+      runtimeVariables,
+      processEnvVars,
+      collectionPath,
+      historyLogger,
+      secretVariables,
+      collectionVariables,
+      folderVariables,
+      requestVariables,
+      globalEnvironmentVariables,
+      oauth2CredentialVariables,
+      iterationDetails,
+      promptVariables,
+      certsAndProxyConfig,
+      requestUrl: request?.url
+    });
     const req = new BrunoRequest(request, historyLogger);
     const res = createResponseParser(response);
 
@@ -51,7 +68,7 @@ class VarsRuntime {
     const context = {
       ...envVariables,
       ...runtimeVariables,
-      ...secretVars,
+      ...secretVariables,
       ...bruContext
     };
 

package/src/sandbox/bundle-libraries.js

@@ -2,7 +2,7 @@ const rollup = require('rollup');
 const { nodeResolve } = require('@rollup/plugin-node-resolve');
 const commonjs = require('@rollup/plugin-commonjs');
 const fs = require('fs');
-const { terser } = require('rollup-plugin-terser');
+const terser = require('@rollup/plugin-terser').default;
 
 const bundleLibraries = async () => {
   const codeScript = `

package/src/sandbox/quickjs/index.js

@@ -5,6 +5,7 @@ const addBrunoResponseShimToContext = require('./shims/bruno-response');
 const addTestShimToContext = require('./shims/test');
 const addLibraryShimsToContext = require('./shims/lib');
 const addLocalModuleLoaderShimToContext = require('./shims/local-module');
+const { getRequireCode } = require('./shims/require');
 const { newQuickJSWASMModule, memoizePromiseFactory } = require('quickjs-emscripten');
 
 // execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
@@ -104,44 +105,11 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
     await addCryptoUtilsShimToContext(vm);
 
     const bundledCode = getBundledCode?.toString() || '';
-    const moduleLoaderCode = function () {
-      return `
-        globalThis.require = (mod) => {
-          let lib = globalThis.requireObject[mod];
-          let isModuleAPath = (module) => (module?.startsWith('.') || module?.startsWith?.(bru.cwd()))
-          if (lib) {
-            return lib;
-          }
-          else if (isModuleAPath(mod)) {
-            // fetch local module
-            let localModuleCode = globalThis.__brunoLoadLocalModule(mod);
-
-            // compile local module as iife
-            (function (){
-              const initModuleExportsCode = "const module = { exports: {} };"
-              const copyModuleExportsCode = "\\n;globalThis.requireObject[mod] = module.exports;";
-              const patchedRequire = ${`
-                "\\n;" +
-                "let require = (subModule) => isModuleAPath(subModule) ? globalThis.require(path.resolve(bru.cwd(), mod, '..', subModule)) : globalThis.require(subModule)" +
-                "\\n;" 
-              `}
-              eval(initModuleExportsCode + patchedRequire + localModuleCode + copyModuleExportsCode);
-            })();
-
-            // resolve module
-            return globalThis.requireObject[mod];
-          }
-          else {
-            throw new Error("Cannot find module " + mod);
-          }
-        }
-      `;
-    };
 
     vm.evalCode(
       `
         (${bundledCode})()
-        ${moduleLoaderCode()}
+        ${getRequireCode()}
       `
     );