@usebruno/js 0.47.0 → 0.48.0

package/src/sandbox/bundle-libraries.js

@@ -1,6 +1,7 @@
 const rollup = require('rollup');
 const { nodeResolve } = require('@rollup/plugin-node-resolve');
 const commonjs = require('@rollup/plugin-commonjs');
+const json = require('@rollup/plugin-json');
 const fs = require('fs');
 const terser = require('@rollup/plugin-terser').default;
 
@@ -13,6 +14,8 @@ const bundleLibraries = async () => {
     import atob from "atob";
     import * as cryptoJs from 'crypto-js';
     import tv4 from "tv4";
+    import Ajv from "ajv";
+    import addFormats from "ajv-formats";
     globalThis.expect = expect;
     globalThis.assert = assert;
     globalThis.moment = moment;
@@ -20,6 +23,8 @@ const bundleLibraries = async () => {
     globalThis.atob = atob;
     globalThis.Buffer = Buffer;
     globalThis.tv4 = tv4;
+    globalThis.Ajv = Ajv;
+    globalThis.addFormats = addFormats;
     globalThis.requireObject = {
       ...(globalThis.requireObject || {}),
       'chai': { expect, assert },
@@ -28,7 +33,9 @@ const bundleLibraries = async () => {
       'btoa': btoa,
       'atob': atob,
       'crypto-js': cryptoJs,
-      'tv4': tv4
+      'tv4': tv4,
+      'ajv': Ajv,
+      'ajv-formats': addFormats
     };
 `;
 
@@ -56,6 +63,7 @@ const bundleLibraries = async () => {
           browser: false
         }),
         commonjs(),
+        json(),
         terser()
       ]
     },

package/src/sandbox/quickjs/index.js

@@ -15,10 +15,9 @@ const { marshallToVm } = require('./utils');
 const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
 const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
-let QuickJSSyncContext;
+let QuickJSModule;
 const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
-const getContext = (opts) => loader().then((mod) => (QuickJSSyncContext = mod.newContext(opts)));
-getContext();
+loader().then((mod) => (QuickJSModule = mod));
 
 const toNumber = (value) => {
   const num = Number(value);
@@ -58,9 +57,8 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
     externalScript = removeQuotes(externalScript);
   }
 
-  const vm = QuickJSSyncContext;
-
   try {
+    const vm = QuickJSModule.newContext();
     const { bru, req, res, ...variables } = externalContext;
 
     bru && addBruShimToContext(vm, bru);
@@ -98,7 +96,7 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
   externalScript = externalScript?.trim();
 
   try {
-    const module = await newQuickJSWASMModule();
+    const module = await loader();
     const vm = module.newContext();
 
     // add crypto utilities required by the crypto-js library in bundledCode
@@ -144,5 +142,6 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
 module.exports = {
   executeQuickJsVm,
-  executeQuickJsVmAsync
+  executeQuickJsVmAsync,
+  loader
 };

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

@@ -1,11 +1,11 @@
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 const addBrunoRequestShimToContext = (vm, req) => {
   const reqObject = vm.newObject();
 
   const url = marshallToVm(req.getUrl(), vm);
   const method = marshallToVm(req.getMethod(), vm);
-  const headers = marshallToVm(req.getHeaders(), vm);
   const body = marshallToVm(req.getBody(), vm);
   const timeout = marshallToVm(req.getTimeout(), vm);
   const name = marshallToVm(req.getName(), vm);
@@ -14,7 +14,6 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   vm.setProp(reqObject, 'url', url);
   vm.setProp(reqObject, 'method', method);
-  vm.setProp(reqObject, 'headers', headers);
   vm.setProp(reqObject, 'body', body);
   vm.setProp(reqObject, 'timeout', timeout);
   vm.setProp(reqObject, 'name', name);
@@ -23,13 +22,29 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   url.dispose();
   method.dispose();
-  headers.dispose();
   body.dispose();
   timeout.dispose();
   name.dispose();
   pathParams.dispose();
   tags.dispose();
 
+  // req.headers — plain headers object for backward-compatible bracket access
+  const headersVal = marshallToVm(req.getHeaders(), vm);
+  vm.setProp(reqObject, 'headers', headersVal);
+  headersVal.dispose();
+
+  // req.headerList — PropertyList bridge for structured header operations
+  const headerListObj = vm.newObject();
+  const { evalCode: headersEvalCode } = createPropertyListBridge(vm, req.headerList, headerListObj, {
+    globalPath: 'globalThis.req.headerList',
+    syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+    syncReadObjectMethods: ['one', 'all', 'toJSON'],
+    syncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'populate', 'repopulate', 'assimilate'],
+    withIterators: true
+  });
+  vm.setProp(reqObject, 'headerList', headerListObj);
+  headerListObj.dispose();
+
   let getUrl = vm.newFunction('getUrl', function () {
     return marshallToVm(req.getUrl(), vm);
   });
@@ -177,6 +192,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   vm.setProp(vm.global, 'req', reqObject);
   reqObject.dispose();
+
+  // Evaluate iterator code after req is on global (iterators reference globalThis.req.headerList)
+  // Wrapped in a block to avoid const redeclaration conflicts with other evalCode blocks
+  if (headersEvalCode) {
+    vm.evalCode(`{ ${headersEvalCode} }`);
+  }
 };
 
 module.exports = addBrunoRequestShimToContext;

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

@@ -1,4 +1,5 @@
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 // Marshal a QuickJS query argument to a host-compatible value.
 // Function handles are wrapped as native callbacks; other values are dumped as-is.
@@ -34,25 +35,43 @@ const addBrunoResponseShimToContext = (vm, res) => {
 
   const status = marshallToVm(res?.status, vm);
   const statusText = marshallToVm(res?.statusText, vm);
-  const headers = marshallToVm(res?.headers, vm);
   const body = marshallToVm(res?.body, vm);
   const responseTime = marshallToVm(res?.responseTime, vm);
   const url = marshallToVm(res?.url, vm);
 
   vm.setProp(resFn, 'status', status);
   vm.setProp(resFn, 'statusText', statusText);
-  vm.setProp(resFn, 'headers', headers);
   vm.setProp(resFn, 'body', body);
   vm.setProp(resFn, 'responseTime', responseTime);
   vm.setProp(resFn, 'url', url);
 
   status.dispose();
-  headers.dispose();
   body.dispose();
   responseTime.dispose();
   url.dispose();
   statusText.dispose();
 
+  // res.headers — plain headers object for backward-compatible bracket access
+  const headersVal = marshallToVm(res?.headers || {}, vm);
+  vm.setProp(resFn, 'headers', headersVal);
+  headersVal.dispose();
+
+  // res.headerList — read-only PropertyList bridge for structured header operations
+  let resHeadersEvalCode = '';
+  if (res?.headerList) {
+    const headerListObj = vm.newObject();
+    const bridge = createPropertyListBridge(vm, res.headerList, headerListObj, {
+      globalPath: 'globalThis.res.headerList',
+      syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+      syncReadObjectMethods: ['one', 'all', 'toJSON'],
+      syncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'populate', 'repopulate', 'assimilate'],
+      withIterators: true
+    });
+    resHeadersEvalCode = bridge.evalCode;
+    vm.setProp(resFn, 'headerList', headerListObj);
+    headerListObj.dispose();
+  }
+
   let getStatusText = vm.newFunction('getStatusText', function () {
     return marshallToVm(res.getStatusText(), vm);
   });
@@ -109,6 +128,12 @@ const addBrunoResponseShimToContext = (vm, res) => {
 
   vm.setProp(vm.global, 'res', resFn);
   resFn.dispose();
+
+  // Evaluate iterator code after res is on global (iterators reference globalThis.res.headerList)
+  // Wrapped in a block to avoid const redeclaration conflicts with req.headerList's evalCode
+  if (resHeadersEvalCode) {
+    vm.evalCode(`{ ${resHeadersEvalCode} }`);
+  }
 };
 
 module.exports = addBrunoResponseShimToContext;

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

@@ -79,6 +79,179 @@ const addBruShimToContext = (vm, __brunoTestResults) => {
       })();
     `
   );
+  // Register custom chai assertion for jsonSchema (expect(...).to.have.jsonSchema(schema, options))
+  vm.evalCode(
+    `
+      (function() {
+        var Ajv = require('ajv');
+        var addFormats = require('ajv-formats');
+        var defaultAjv = new Ajv({ allErrors: true });
+        addFormats(defaultAjv);
+        var SUPPORTED_SCHEMA_VERSIONS = [
+          'http://json-schema.org/draft-07/schema#',
+          'http://json-schema.org/draft-07/schema'
+        ];
+        var proto = Object.getPrototypeOf(expect(null));
+        proto.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 + '".'
+            );
+          }
+          var ajv;
+          if (ajvOptions) {
+            ajv = new Ajv(Object.assign({ allErrors: true }, ajvOptions));
+            addFormats(ajv);
+          } else {
+            ajv = defaultAjv;
+          }
+          var validate;
+          try {
+            validate = ajv.compile(schema);
+          } catch (e) {
+            this.assert(false, 'JSON schema compile error: ' + e.message, 'JSON schema compile error: ' + e.message);
+          }
+          var data = this._obj;
+          var isValid = validate(data);
+
+          var dataStr;
+          try { dataStr = JSON.stringify(data); } catch (e) { dataStr = '[unserializable value]'; }
+          this.assert(
+            isValid,
+            'expected ' + dataStr + ' to match JSON schema, validation errors: ' + (validate.errors ? JSON.stringify(validate.errors) : 'none'),
+            'expected ' + dataStr + ' to not match JSON schema'
+          );
+          return this;
+        };
+      })();
+    `
+  );
+  // Register custom chai assertion for jsonBody (Postman parity)
+  vm.evalCode(
+    `
+      (function() {
+        var proto = Object.getPrototypeOf(expect(null));
+
+        // 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) {
+          var keys = [];
+          var i = 0;
+          while (i < path.length) {
+            if (path[i] === '.') {
+              i++;
+            } else if (path[i] === '[') {
+              i++;
+              if (i < path.length && (path[i] === "'" || path[i] === '"')) {
+                var quote = path[i];
+                i++;
+                var key = '';
+                while (i < path.length && path[i] !== quote) {
+                  if (path[i] === '\\\\' && i + 1 < path.length && path[i + 1] === quote) {
+                    key += quote;
+                    i += 2;
+                  } else {
+                    key += path[i];
+                    i++;
+                  }
+                }
+                i++; // skip closing quote
+                i++; // skip ']'
+                keys.push(key);
+              } else {
+                var key = '';
+                while (i < path.length && path[i] !== ']') {
+                  key += path[i];
+                  i++;
+                }
+                i++; // skip ']'
+                keys.push(key);
+              }
+            } else {
+              var key = '';
+              while (i < path.length && path[i] !== '.' && path[i] !== '[') {
+                key += path[i];
+                i++;
+              }
+              keys.push(key);
+            }
+          }
+          return keys;
+        }
+
+        function getNestedValue(obj, path) {
+          var keys = parsePath(path);
+          var current = obj;
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            if (current === null || current === undefined || !Object.prototype.hasOwnProperty.call(Object(current), key)) {
+              return { found: false };
+            }
+            current = current[key];
+          }
+          return { found: true, value: current };
+        }
+
+        function deepEqual(a, b) {
+          if (a === b) return true;
+          if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+          if (Array.isArray(a) !== Array.isArray(b)) return false;
+          var keysA = Object.keys(a);
+          var keysB = Object.keys(b);
+          if (keysA.length !== keysB.length) return false;
+          for (var i = 0; i < keysA.length; i++) {
+            if (!Object.prototype.hasOwnProperty.call(b, keysA[i]) || !deepEqual(a[keysA[i]], b[keysA[i]])) return false;
+          }
+          return true;
+        }
+
+        proto.jsonBody = function() {
+          var obj = this._obj;
+          var args = Array.prototype.slice.call(arguments);
+
+          if (args.length === 0) {
+            this.assert(
+              typeof obj === 'object' && obj !== null,
+              'expected value to be a JSON body (object or array)',
+              'expected value not to be a JSON body'
+            );
+          } else if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+            this.assert(
+              deepEqual(obj, args[0]),
+              'expected body to deeply equal given object',
+              'expected body to not deeply equal given object'
+            );
+          } else if (args.length === 1) {
+            var 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 {
+            var result = getNestedValue(obj, String(args[0]));
+            this.assert(
+              result.found && deepEqual(result.value, args[1]),
+              "expected body to have nested property '" + args[0] + "' equal to given value",
+              "expected body to not have nested property '" + args[0] + "' equal to given value"
+            );
+          }
+          return this;
+        };
+      })();
+    `
+  );
 };
 
 module.exports = addBruShimToContext;

package/src/sandbox/quickjs/utils/property-list-bridge.js

@@ -81,6 +81,7 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
     globalPath,
     syncReadMethods = [],
     syncReadObjectMethods = [],
+    syncWriteMethods = [],
     asyncWriteMethods = [],
     withIterators = false
   } = options;
@@ -103,6 +104,16 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
     fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
   }
 
+  // Sync write methods — void return, just call and discard
+  for (const methodName of syncWriteMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      nativeList[methodName](...args);
+      return vm.undefined;
+    });
+    fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
+  }
+
   // Async write methods — two-phase setup:
   // Phase 1 (native): Register `_prefixed` bridge functions (e.g. `_add`, `_remove`) via
   // createAsyncBridge. These are QuickJS promise-based wrappers that call the native method's
@@ -149,11 +160,25 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
   // operation inside the VM where the callback lives. Requires `all` in `syncReadObjectMethods`.
   if (withIterators) {
     evalCode += `const _allNative = ${globalPath}.all;
-    ${globalPath}.each = (fn) => { _allNative().forEach(fn); };
-    ${globalPath}.filter = (fn) => _allNative().filter(fn);
-    ${globalPath}.find = (fn) => _allNative().find(fn);
-    ${globalPath}.map = (fn) => _allNative().map(fn);
-    ${globalPath}.reduce = (fn, ...rest) => rest.length ? _allNative().reduce(fn, rest[0]) : _allNative().reduce(fn);\n`;
+    ${globalPath}.each = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; _allNative().forEach(b); };
+    ${globalPath}.filter = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().filter(b); };
+    ${globalPath}.find = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().find(b); };
+    ${globalPath}.map = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().map(b); };
+    ${globalPath}.reduce = (fn, ...rest) => { const ctx = rest.length > 1 ? rest[1] : undefined; const b = ctx !== undefined ? fn.bind(ctx) : fn; return rest.length > 0 ? _allNative().reduce(b, rest[0]) : _allNative().reduce(b); };\n`;
+  }
+
+  // Override `remove` when it's a syncWriteMethod so function predicates work in-VM.
+  // The native bridge can't serialize function handles (vm.dump fails on functions).
+  // Instead: pull items via all(), run the predicate in-VM, call native remove(key) per match.
+  if (withIterators && syncWriteMethods.includes('remove')) {
+    evalCode += `const _removeNative = ${globalPath}.remove;
+    ${globalPath}.remove = (predicate) => {
+      if (typeof predicate === 'function') {
+        _allNative().filter(predicate).forEach(item => _removeNative(item.key));
+      } else {
+        _removeNative(predicate);
+      }
+    };\n`;
   }
 
   return { evalCode };