@usebruno/js 0.46.1 → 0.48.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

@@ -7,6 +7,8 @@ const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser, u
 const { interpolateString } = require('../interpolate-string');
 const { executeQuickJsVm } = require('../sandbox/quickjs');
 
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
 const { expect } = chai;
 chai.use(require('chai-string'));
 chai.use(function (chai, utils) {
@@ -17,13 +19,55 @@ 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`);
   });
 });
 
+// Custom assertion for JSON Schema validation
+const defaultAjv = new Ajv({ allErrors: true });
+addFormats(defaultAjv);
+
+const SUPPORTED_SCHEMA_VERSIONS = [
+  'http://json-schema.org/draft-07/schema#',
+  'http://json-schema.org/draft-07/schema'
+];
+
+chai.use(function (chai) {
+  chai.Assertion.addMethod('jsonSchema', function (schema, ajvOptions) {
+    if (schema && schema.$schema && !SUPPORTED_SCHEMA_VERSIONS.includes(schema.$schema)) {
+      this.assert(
+        false,
+        `Unsupported JSON Schema version: "${schema.$schema}". Bruno currently only supports Draft-07 (http://json-schema.org/draft-07/schema#). Please update your schema to be Draft-07 compatible and remove the $schema property.`,
+        `Unsupported JSON Schema version: "${schema.$schema}".`
+      );
+    }
+    let ajv;
+    if (ajvOptions) {
+      ajv = new Ajv({ allErrors: true, ...ajvOptions });
+      addFormats(ajv);
+    } else {
+      ajv = defaultAjv;
+    }
+    let validate;
+    try {
+      validate = ajv.compile(schema);
+    } catch (e) {
+      this.assert(false, 'JSON schema compile error: ' + e.message, 'JSON schema compile error: ' + e.message);
+    }
+    const data = this._obj;
+    const isValid = validate(data);
+
+    this.assert(
+      isValid,
+      'expected #{this} to match JSON schema, validation errors: ' + (validate.errors ? JSON.stringify(validate.errors) : 'none'),
+      'expected #{this} to not match JSON schema'
+    );
+  });
+});
+
 // Custom assertion for matching regex
 chai.use(function (chai, utils) {
   chai.Assertion.addMethod('match', function (regex) {
@@ -43,6 +87,118 @@ chai.use(function (chai, utils) {
   });
 });
 
+// Custom assertion for jsonBody (Postman parity)
+chai.use(function (chai, utils) {
+  // Parse a property path into an array of keys.
+  // Handles: dot notation (a.b), numeric brackets (a[0]), quoted brackets (a["b.c"], a['key']),
+  // and combinations like data[0]["a.b"].name
+  //
+  // Examples:
+  //   "a.b.c"              -> ["a", "b", "c"]
+  //   "items[0].name"      -> ["items", "0", "name"]
+  //   'data["a.b"]'        -> ["data", "a.b"]
+  //   "matrix[0][1]"       -> ["matrix", "0", "1"]
+  //   'nested["x.y"].z'    -> ["nested", "x.y", "z"]
+  //   '["say \\"hi\\""]'   -> ["say \"hi\""]
+  function parsePath(path) {
+    const keys = [];
+    let i = 0;
+    while (i < path.length) {
+      if (path[i] === '.') {
+        // Skip dot separator
+        i++;
+      } else if (path[i] === '[') {
+        i++; // skip '['
+        if (i < path.length && (path[i] === '\'' || path[i] === '"')) {
+          // Quoted key — collect until matching unescaped quote + ']'
+          const quote = path[i];
+          i++; // skip opening quote
+          let key = '';
+          while (i < path.length && path[i] !== quote) {
+            if (path[i] === '\\' && i + 1 < path.length && path[i + 1] === quote) {
+              key += quote;
+              i += 2; // skip backslash + escaped quote
+            } else {
+              key += path[i];
+              i++;
+            }
+          }
+          i++; // skip closing quote
+          i++; // skip ']'
+          keys.push(key);
+        } else {
+          // Unquoted (numeric) key — collect until ']'
+          let key = '';
+          while (i < path.length && path[i] !== ']') {
+            key += path[i];
+            i++;
+          }
+          i++; // skip ']'
+          keys.push(key);
+        }
+      } else {
+        // Bare key — collect until '.', '[', or end
+        let key = '';
+        while (i < path.length && path[i] !== '.' && path[i] !== '[') {
+          key += path[i];
+          i++;
+        }
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+
+  function getNestedValue(obj, path) {
+    const keys = parsePath(path);
+    let current = obj;
+    for (const key of keys) {
+      if (current === null || current === undefined || !Object.prototype.hasOwnProperty.call(Object(current), key)) {
+        return { found: false };
+      }
+      current = current[key];
+    }
+    return { found: true, value: current };
+  }
+
+  chai.Assertion.addMethod('jsonBody', function () {
+    const obj = this._obj;
+    const args = Array.prototype.slice.call(arguments);
+
+    if (args.length === 0) {
+      // No args: check body is valid JSON (object or array)
+      this.assert(
+        typeof obj === 'object' && obj !== null,
+        `expected ${utils.inspect(obj)} to be a JSON body (object or array)`,
+        `expected ${utils.inspect(obj)} not to be a JSON body`
+      );
+    } else if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+      // Object arg: deep equality
+      this.assert(
+        utils.eql(obj, args[0]),
+        `expected body to deeply equal ${utils.inspect(args[0])}`,
+        `expected body to not deeply equal ${utils.inspect(args[0])}`
+      );
+    } else if (args.length === 1) {
+      // String path: check nested property exists
+      const result = getNestedValue(obj, String(args[0]));
+      this.assert(
+        result.found,
+        `expected body to have nested property '${args[0]}'`,
+        `expected body to not have nested property '${args[0]}'`
+      );
+    } else {
+      // Path + value: check nested property equals value
+      const result = getNestedValue(obj, String(args[0]));
+      this.assert(
+        result.found && utils.eql(result.value, args[1]),
+        `expected body to have nested property '${args[0]}' equal to ${utils.inspect(args[1])}`,
+        `expected body to not have nested property '${args[0]}' equal to ${utils.inspect(args[1])}`
+      );
+    }
+  });
+});
+
 /**
  * Assertion operators
  *
@@ -263,14 +419,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 +432,10 @@ class AssertRuntime {
       globalEnvironmentVariables,
       oauth2CredentialVariables,
       iterationDetails,
-      undefined,
       promptVariables,
-      certsAndProxyConfig
-    );
+      certsAndProxyConfig,
+      requestUrl: request?.url
+    });
     const req = new BrunoRequest(request, historyLogger);
     const res = createResponseParser(response);