@usebruno/js 0.46.1 → 0.48.0

package/src/sandbox/quickjs/shims/require.spec.js

@@ -0,0 +1,154 @@
+const { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } = require('@jest/globals');
+const { newQuickJSWASMModule } = require('quickjs-emscripten');
+const { addRequireShimToContext, getRequireCode } = require('./require');
+const { createEvalHelper } = require('../utils/test-helpers');
+
+describe('require shim tests', () => {
+  let vm, module, evalAndDump;
+
+  beforeAll(async () => {
+    module = await newQuickJSWASMModule();
+  });
+
+  beforeEach(() => {
+    vm = module.newContext();
+    evalAndDump = createEvalHelper(vm);
+    // Initialize empty requireObject
+    vm.evalCode('globalThis.requireObject = {}');
+  });
+
+  afterEach(() => {
+    if (vm) {
+      try {
+        vm.dispose();
+      } catch (err) {
+        // Ignore disposal errors
+      }
+      vm = null;
+    }
+  });
+
+  afterAll(() => {
+    if (module) {
+      try {
+        module.dispose();
+      } catch (err) {
+        // Ignore disposal errors
+      }
+      module = null;
+    }
+  });
+
+  describe('getRequireCode', () => {
+    it('should return a string', () => {
+      expect(typeof getRequireCode()).toBe('string');
+    });
+
+    it('should contain require function definition', () => {
+      const code = getRequireCode();
+      expect(code).toContain('globalThis.require');
+      expect(code).toContain('requireObject');
+    });
+  });
+
+  describe('addRequireShimToContext', () => {
+    it('should add require function to the VM context', () => {
+      addRequireShimToContext(vm);
+      const typeOfRequire = evalAndDump('typeof globalThis.require');
+      expect(typeOfRequire).toBe('function');
+    });
+
+    it('should return module from requireObject', () => {
+      addRequireShimToContext(vm);
+
+      // Register a mock module
+      vm.evalCode(`
+        globalThis.requireObject['test-module'] = { foo: 'bar', answer: 42 };
+      `);
+
+      const result = evalAndDump(`
+        const mod = require('test-module');
+        [mod.foo, mod.answer];
+      `);
+
+      expect(result).toEqual(['bar', 42]);
+    });
+
+    it('should support destructuring from required modules', () => {
+      addRequireShimToContext(vm, { enableLocalModules: false });
+
+      vm.evalCode(`
+        globalThis.requireObject['my-lib'] = {
+          greet: (name) => 'Hello, ' + name,
+          VERSION: '1.0.0'
+        };
+      `);
+
+      const [greeting, version] = evalAndDump(`
+        const { greet, VERSION } = require('my-lib');
+        [greet('World'), VERSION];
+      `);
+
+      expect(greeting).toBe('Hello, World');
+      expect(version).toBe('1.0.0');
+    });
+
+    it('should support aliased destructuring', () => {
+      addRequireShimToContext(vm);
+
+      vm.evalCode(`
+        globalThis.requireObject['utils'] = { v1: () => 'version-1' };
+      `);
+
+      const result = evalAndDump(`
+        const { v1: getVersion } = require('utils');
+        getVersion();
+      `);
+
+      expect(result).toBe('version-1');
+    });
+
+    it('should throw error for unknown modules', () => {
+      addRequireShimToContext(vm);
+
+      const result = vm.evalCode(`
+        try {
+          require('non-existent-module');
+          'no error';
+        } catch (e) {
+          e.message;
+        }
+      `);
+      const handle = vm.unwrapResult(result);
+      const errorMessage = vm.dump(handle);
+      handle.dispose();
+
+      expect(errorMessage).toContain('Cannot find module');
+      expect(errorMessage).toContain('non-existent-module');
+    });
+
+    it('should allow requiring the same module multiple times', () => {
+      addRequireShimToContext(vm);
+
+      vm.evalCode(`
+        globalThis.requireObject['counter'] = { count: 0 };
+      `);
+
+      const result = evalAndDump(`
+        const mod1 = require('counter');
+        const mod2 = require('counter');
+        mod1 === mod2;
+      `);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('enableLocalModules option', () => {
+    it('should include local module loading code when enabled', () => {
+      const code = getRequireCode();
+      expect(code).toContain('isModuleAPath');
+      expect(code).toContain('__brunoLoadLocalModule');
+    });
+  });
+});

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

@@ -69,8 +69,8 @@ const addBruShimToContext = (vm, __brunoTestResults) => {
         Object.defineProperty(proto, 'json', {
           get: function () {
             var obj = this._obj;
-            var isJson = typeof obj === 'object' && obj !== null && !Array.isArray(obj) &&
-              Object.prototype.toString.call(obj) === '[object Object]';
+            var isJson = typeof obj === 'object' && obj !== null &&
+              (Array.isArray(obj) || Object.prototype.toString.call(obj) === '[object Object]');
             this.assert(isJson, 'expected #{this} to be JSON', 'expected #{this} not to be JSON');
             return this;
           },
@@ -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

@@ -0,0 +1,190 @@
+const { cleanJson, cleanCircularJson } = require('../../../utils');
+const { marshallToVm } = require('../utils');
+
+/**
+ * Creates an async bridge that resolves with `undefined` (write-only).
+ * Do NOT reuse this for read methods that need to return values —
+ * those require resolving with the callback's result argument instead.
+ */
+const createAsyncBridge = (vm, targetObj, propName, nativeMethod) => {
+  const fn = vm.newFunction(propName, (...vmArgs) => {
+    const promise = vm.newPromise();
+    const args = vmArgs.map((a) => vm.dump(a));
+    nativeMethod(...args, (err) => {
+      if (err) {
+        promise.reject(marshallToVm(cleanJson(err), vm));
+      } else {
+        promise.resolve(vm.undefined);
+      }
+    });
+    promise.settled.then(vm.runtime.executePendingJobs);
+    return promise.handle;
+  });
+  fn.consume((handle) => vm.setProp(targetObj, propName, handle));
+};
+
+/**
+ * Factory that auto-wires PropertyList methods onto a QuickJS VM object.
+ *
+ * Generates:
+ * - Sync read methods: `vm.newFunction` → `marshallToVm(nativeList.method(...args), vm)`
+ * - Sync read object methods: same but wrapped with `cleanCircularJson()`
+ * - Async write methods: `_prefix` bridge pattern (native callback → QuickJS promise)
+ * - Returns `{ evalCode }` string containing `callWithCallback` helper + async wrappers + iterators
+ *
+ * @example
+ * In shims/bru.js, wiring up bru.cookies takes a single call:
+ *
+ * const { evalCode: cookiesEvalCode } = createPropertyListBridge(vm, bru.cookies, bruCookiesObject, {
+ *   globalPath: 'globalThis.bru.cookies',
+ *   syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+ *   syncReadObjectMethods: ['one', 'all', 'idx', 'toJSON'],
+ *   asyncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'delete'],
+ *   withIterators: true
+ * });
+ *
+ * Without this factory, each method would require manual boilerplate like the
+ * hand-written jar() bridge in bru.js (~100 lines), where every method needs:
+ *
+ *   const _fn = vm.newFunction('_method', (...vmArgs) => {
+ *     const promise = vm.newPromise();
+ *     nativeObj.method(vm.dump(vmArgs[0]), (err, result) => {
+ *       if (err) {
+ *         promise.reject(marshallToVm(cleanJson(err), vm));
+ *       } else {
+ *         promise.resolve(marshallToVm(cleanCircularJson(result), vm));
+ *       }
+ *     });
+ *     promise.settled.then(vm.runtime.executePendingJobs);
+ *     return promise.handle;
+ *   });
+ *   _fn.consume((handle) => vm.setProp(obj, '_method', handle));
+ *
+ * …repeated for every method, plus separate evalCode for async wrappers.
+ *
+ * To wire up a new PropertyList-backed object, add one createPropertyListBridge
+ * call instead of duplicating all that boilerplate.
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} nativeList - Native PropertyList instance
+ * @param {Object} targetObj - QuickJS object handle to attach methods to
+ * @param {Object} options
+ * @param {string} options.globalPath - Global path in QuickJS (e.g. 'globalThis.bru.cookies')
+ * @param {string[]} [options.syncReadMethods] - Methods that return primitive values
+ * @param {string[]} [options.syncReadObjectMethods] - Methods that return objects (need cleanCircularJson)
+ * @param {string[]} [options.asyncWriteMethods] - Async write methods (use _prefix bridge)
+ * @param {boolean} [options.withIterators] - Whether to add each/find/filter/map/reduce
+ * @returns {{ evalCode: string }} - JavaScript code to eval in the VM for async wrappers and iterators
+ */
+const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
+  const {
+    globalPath,
+    syncReadMethods = [],
+    syncReadObjectMethods = [],
+    syncWriteMethods = [],
+    asyncWriteMethods = [],
+    withIterators = false
+  } = options;
+
+  // Sync read methods — return primitive values
+  for (const methodName of syncReadMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      return marshallToVm(nativeList[methodName](...args), vm);
+    });
+    fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
+  }
+
+  // Sync read object methods — need cleanCircularJson
+  for (const methodName of syncReadObjectMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      return marshallToVm(cleanCircularJson(nativeList[methodName](...args)), vm);
+    });
+    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
+  // callback API and resolve with `undefined` (write-only).
+  // Phase 2 (evalCode): Generates JS code eval'd in the VM that:
+  //   1. Defines a `callWithCallback` helper supporting both `await method(args)` and
+  //      `method(args, callback)` calling styles.
+  //   2. Captures `_prefixed` direct references, then overwrites the public method name with
+  //      a wrapper that auto-detects whether the last argument is a callback.
+  for (const methodName of asyncWriteMethods) {
+    createAsyncBridge(vm, targetObj, `_${methodName}`, (...a) => nativeList[methodName](...a));
+  }
+
+  let evalCode = '';
+
+  if (asyncWriteMethods.length > 0) {
+    evalCode += `const callWithCallback = async (promiseFn, callback) => {
+      if (!callback) return await promiseFn();
+      try {
+        const result = await promiseFn();
+        try { await callback(null, result); } catch(cbErr) { return Promise.reject(cbErr); }
+      } catch(err) {
+        try { await callback(err, null); } catch(cbErr) { return Promise.reject(cbErr); }
+      }
+    };\n`;
+
+    // Capture _prefixed direct references before overwriting
+    for (const methodName of asyncWriteMethods) {
+      evalCode += `const _${methodName}Direct = ${globalPath}._${methodName};\n`;
+    }
+
+    // Generate wrapper functions: method(...args, cb?) => callWithCallback(() => _direct(...args), cb)
+    for (const methodName of asyncWriteMethods) {
+      evalCode += `${globalPath}.${methodName} = (...args) => {
+      const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined;
+      return callWithCallback(() => _${methodName}Direct(...args), cb);
+    };\n`;
+    }
+  }
+
+  // Iterators — these can't be bridged as syncReadObjectMethods because they take a callback
+  // function as an argument, and functions can't cross the native↔VM boundary (vm.dump() can't
+  // serialize them). Instead, we pull the data into the VM via `all()`, then run the array
+  // operation inside the VM where the callback lives. Requires `all` in `syncReadObjectMethods`.
+  if (withIterators) {
+    evalCode += `const _allNative = ${globalPath}.all;
+    ${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 };
+};
+
+module.exports = {
+  createPropertyListBridge,
+  createAsyncBridge
+};

package/src/sandbox/quickjs/utils/test-helpers.js

@@ -0,0 +1,31 @@
+/**
+ * Evaluates code in a QuickJS VM and returns the dumped result.
+ * Handles unwrapping and disposing of handles automatically.
+ *
+ * @param {Object} vm - QuickJS VM context
+ * @param {string} code - JavaScript code to evaluate
+ * @returns {*} The evaluated and dumped result
+ */
+function evalAndDump(vm, code) {
+  const result = vm.evalCode(code);
+  const handle = vm.unwrapResult(result);
+  const value = vm.dump(handle);
+  handle.dispose();
+  return value;
+}
+
+/**
+ * Creates a helper function bound to a specific VM instance.
+ * Useful in beforeEach to create a test-scoped helper.
+ *
+ * @param {Object} vm - QuickJS VM context
+ * @returns {Function} evalAndDump function bound to the VM
+ */
+function createEvalHelper(vm) {
+  return (code) => evalAndDump(vm, code);
+}
+
+module.exports = {
+  evalAndDump,
+  createEvalHelper
+};