@usebruno/js 0.46.1 → 0.47.0

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

@@ -1,5 +1,6 @@
 const { cleanJson, cleanCircularJson } = require('../../../utils');
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 const addBruShimToContext = (vm, bru) => {
   const bruObject = vm.newObject();
@@ -229,11 +230,29 @@ const addBruShimToContext = (vm, bru) => {
   bruRunnerIterationDataObject.dispose();
 
   let visualize = vm.newFunction('visualize', function (type, data) {
-    bru.visualize(vm.dump(type), vm.dump(data));
+    try {
+      // Guard against missing handles: vm.dump() accesses .owner on the handle
+      // to verify its VM context. When called with no args, the handles are
+      // undefined, and vm.dump(undefined) throws a generic
+      // "Cannot read properties of undefined (reading 'owner')" instead of
+      // letting bru.visualize() throw a meaningful error message.
+      bru.visualize(
+        type ? vm.dump(type) : undefined,
+        data ? vm.dump(data) : undefined
+      );
+    } catch (err) {
+      throw vm.newError(err.message || String(err));
+    }
   });
   vm.setProp(bruObject, 'visualize', visualize);
   visualize.dispose();
 
+  let clearVisualizations = vm.newFunction('clearVisualizations', function () {
+    bru.clearVisualizations();
+  });
+  vm.setProp(bruObject, 'clearVisualizations', clearVisualizations);
+  clearVisualizations.dispose();
+
   let getSecretVar = vm.newFunction('getSecretVar', function (key) {
     return marshallToVm(bru.getSecretVar(vm.dump(key)), vm);
   });
@@ -394,6 +413,13 @@ const addBruShimToContext = (vm, bru) => {
   sleep.consume((handle) => vm.setProp(bruObject, 'sleep', handle));
 
   let bruCookiesObject = vm.newObject();
+  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
+  });
 
   const _jarFn = vm.newFunction('_jar', () => {
     const nativeJar = bru.cookies.jar();
@@ -571,6 +597,10 @@ const addBruShimToContext = (vm, bru) => {
       }
     };
 
+    {
+      ${cookiesEvalCode}
+    }
+
     globalThis.bru.cookies.jar = () => {
       const _jar = globalThis.bru.cookies._jar();
 

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

@@ -1,8 +1,35 @@
 const { marshallToVm } = require('../utils');
 
+// Marshal a QuickJS query argument to a host-compatible value.
+// Function handles are wrapped as native callbacks; other values are dumped as-is.
+// Safe because @usebruno/query's get() invokes filters synchronously,
+// so the borrowed arg handle is still valid.
+const toHostQueryArg = (vm, arg) => {
+  if (vm.typeof(arg) === 'function') {
+    return (item) => {
+      const itemHandle = marshallToVm(item, vm);
+      const result = vm.callFunction(arg, vm.undefined, itemHandle);
+      itemHandle.dispose();
+
+      if (result.error) {
+        const error = vm.dump(result.error);
+        result.error.dispose();
+        throw error;
+      }
+
+      const value = vm.dump(result.value);
+      result.value.dispose();
+      return value;
+    };
+  }
+
+  return vm.dump(arg);
+};
+
 const addBrunoResponseShimToContext = (vm, res) => {
-  let resFn = vm.newFunction('res', function (exprStr) {
-    return marshallToVm(res(vm.dump(exprStr)), vm);
+  let resFn = vm.newFunction('res', function (exprStr, ...queryArgs) {
+    const nativeArgs = queryArgs.map((arg) => toHostQueryArg(vm, arg));
+    return marshallToVm(res(vm.dump(exprStr), ...nativeArgs), vm);
   });
 
   const status = marshallToVm(res?.status, vm);

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

@@ -0,0 +1,91 @@
+const { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } = require('@jest/globals');
+const { newQuickJSWASMModule } = require('quickjs-emscripten');
+const addBrunoResponseShimToContext = require('./bruno-response');
+
+describe('bruno response shim', () => {
+  let vm, module;
+
+  beforeAll(async () => {
+    module = await newQuickJSWASMModule();
+  });
+
+  beforeEach(() => {
+    vm = module.newContext();
+  });
+
+  afterEach(() => {
+    if (vm) {
+      try {
+        vm.dispose();
+      } catch (err) {
+        console.error('Error disposing vm', err);
+      }
+      vm = null;
+    }
+  });
+
+  afterAll(() => {
+    if (module) {
+      try {
+        module.dispose();
+      } catch (err) {
+        console.error('Error disposing module', err);
+      }
+      module = null;
+    }
+  });
+
+  it('forwards response query filter callbacks in safe mode', () => {
+    const resources = [
+      { id: 'test', value: 1 },
+      { id: 'other', value: 2 }
+    ];
+    const response = Object.assign(
+      (expr, filter) => {
+        expect(expr).toBe('resources[?].id');
+        return resources.filter(filter).map((item) => item.id);
+      },
+      { status: 200, statusText: 'OK', headers: {}, body: { resources } }
+    );
+
+    addBrunoResponseShimToContext(vm, response);
+
+    const result = vm.evalCode(`
+      res('resources[?].id', r => r.id === 'test')
+    `);
+
+    const valueHandle = vm.unwrapResult(result);
+    const filtered = vm.dump(valueHandle);
+    valueHandle.dispose();
+
+    expect(filtered).toEqual(['test']);
+  });
+
+  it('still supports object predicates in safe mode', () => {
+    const resources = [
+      { id: 'test', value: 1 },
+      { id: 'other', value: 2 }
+    ];
+    const response = Object.assign(
+      (expr, predicate) => {
+        expect(expr).toBe('resources[?].id');
+        return resources.filter((item) =>
+          Object.entries(predicate).every(([key, value]) => item[key] === value)
+        ).map((item) => item.id);
+      },
+      { status: 200, statusText: 'OK', headers: {}, body: { resources } }
+    );
+
+    addBrunoResponseShimToContext(vm, response);
+
+    const result = vm.evalCode(`
+      res('resources[?].id', { id: 'other' })
+    `);
+
+    const valueHandle = vm.unwrapResult(result);
+    const filtered = vm.dump(valueHandle);
+    valueHandle.dispose();
+
+    expect(filtered).toEqual(['other']);
+  });
+});

package/src/sandbox/quickjs/shims/lib/uuid.spec.js

@@ -0,0 +1,166 @@
+const { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } = require('@jest/globals');
+const { newQuickJSWASMModule } = require('quickjs-emscripten');
+const { validate: uuidValidate, version: uuidVersion } = require('uuid');
+const addUuidShimToContext = require('./uuid');
+const { addRequireShimToContext } = require('../require');
+const { createEvalHelper } = require('../../utils/test-helpers');
+
+describe('uuid shim tests', () => {
+  let vm, module, evalAndDump;
+
+  beforeAll(async () => {
+    module = await newQuickJSWASMModule();
+  });
+
+  beforeEach(async () => {
+    vm = module.newContext();
+    evalAndDump = createEvalHelper(vm);
+    await addUuidShimToContext(vm);
+    addRequireShimToContext(vm, { enableLocalModules: false });
+  });
+
+  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;
+    }
+  });
+
+  /**
+   * Validates that a string is a valid UUID of the expected version
+   */
+  function expectUuidVersion(uuid, expectedVersion) {
+    expect(uuidValidate(uuid)).toBe(true);
+    expect(uuidVersion(uuid)).toBe(expectedVersion);
+  }
+
+  describe('uuid version functions', () => {
+    const versionTests = [
+      { fn: 'v1', version: 1 },
+      { fn: 'v4', version: 4 },
+      { fn: 'v6', version: 6, note: 'RFC 9562' },
+      { fn: 'v7', version: 7, note: 'RFC 9562' }
+    ];
+
+    it.each(versionTests)('$fn should generate valid uuid and be accessible via require', ({ fn, version }) => {
+      // Test direct access
+      const directUuid = evalAndDump(`globalThis.uuid.${fn}()`);
+      expectUuidVersion(directUuid, version);
+
+      // Test require with destructuring
+      const requireUuid = evalAndDump(`const { ${fn} } = require('uuid'); ${fn}()`);
+      expectUuidVersion(requireUuid, version);
+    });
+
+    it('v7 should be accessible with alias pattern (v7: uuidv7) - issue #7333', () => {
+      const uuid = evalAndDump(`
+        const { v7: uuidv7 } = require('uuid');
+        uuidv7();
+      `);
+      expectUuidVersion(uuid, 7);
+    });
+
+    it('v7 should generate time-ordered uuids', () => {
+      const [uuid1, uuid2] = evalAndDump(`
+        const { v7 } = require('uuid');
+        [v7(), v7()];
+      `);
+      // v7 UUIDs are lexicographically sortable by design (timestamp in most significant bits)
+      expect(uuid1 <= uuid2).toBe(true);
+    });
+  });
+
+  describe('name-based uuid functions (v3, v5)', () => {
+    const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+    it.each([
+      { fn: 'v3', version: 3 },
+      { fn: 'v5', version: 5 }
+    ])('$fn should generate valid uuid with namespace', ({ fn, version }) => {
+      const uuid = evalAndDump(`
+        const { ${fn} } = require('uuid');
+        ${fn}('example.com', '${DNS_NAMESPACE}');
+      `);
+      expectUuidVersion(uuid, version);
+    });
+  });
+
+  describe('conversion functions', () => {
+    it('should convert between v1 and v6 using v1ToV6 and v6ToV1', () => {
+      const [v1Uuid, v6FromV1, v6Uuid, v1FromV6] = evalAndDump(`
+        const { v1, v6, v1ToV6, v6ToV1 } = require('uuid');
+        const v1Uuid = v1();
+        const v6Uuid = v6();
+        [v1Uuid, v1ToV6(v1Uuid), v6Uuid, v6ToV1(v6Uuid)];
+      `);
+
+      expectUuidVersion(v1Uuid, 1);
+      expectUuidVersion(v6FromV1, 6);
+      expectUuidVersion(v6Uuid, 6);
+      expectUuidVersion(v1FromV6, 1);
+    });
+  });
+
+  describe('utility functions', () => {
+    it('should validate uuids correctly', () => {
+      const [isValid, isInvalid] = evalAndDump(`
+        const { v4, validate } = require('uuid');
+        [validate(v4()), validate('not-a-uuid')];
+      `);
+      expect(isValid).toBe(true);
+      expect(isInvalid).toBe(false);
+    });
+
+    it('should detect uuid version correctly', () => {
+      const [v4Version, v7Version] = evalAndDump(`
+        const { v4, v7, version } = require('uuid');
+        [version(v4()), version(v7())];
+      `);
+      expect(v4Version).toBe(4);
+      expect(v7Version).toBe(7);
+    });
+
+    it('should parse and stringify uuid', () => {
+      const [original, stringified, isObject, length] = evalAndDump(`
+        const { v4, parse, stringify } = require('uuid');
+        const original = v4();
+        const parsed = parse(original);
+        [original, stringify(parsed), typeof parsed === 'object', Object.keys(parsed).length];
+      `);
+      expect(original).toBe(stringified);
+      expect(isObject).toBe(true);
+      expect(length).toBe(16);
+    });
+  });
+
+  describe('issue #7333 regression test', () => {
+    it('should work with the exact pattern from the bug report', () => {
+      const [typeOfFn, id1, id2] = evalAndDump(`
+        const { v7: uuidv7 } = require('uuid');
+        const id1 = uuidv7();
+        const id2 = uuidv7();
+        [typeof uuidv7, id1, id2];
+      `);
+
+      expect(typeOfFn).toBe('function');
+      expectUuidVersion(id1, 7);
+      expectUuidVersion(id2, 7);
+      expect(id1).not.toBe(id2);
+    });
+  });
+});

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

@@ -0,0 +1,56 @@
+/**
+ * Returns JavaScript code that sets up the require() function in the QuickJS VM.
+ * This module loader looks up modules from globalThis.requireObject and optionally
+ * supports loading local modules if the necessary context (bru.cwd, __brunoLoadLocalModule) is available.
+ *
+ * @param {Object} options
+ * @param {boolean} options.enableLocalModules - Whether to enable local module loading (requires bru context)
+ * @returns {string} JavaScript code to eval in the VM
+ */
+function getRequireCode() {
+  return `
+    globalThis.require = (mod) => {
+      let lib = globalThis.requireObject[mod];
+      let isModuleAPath = (module) => (module?.startsWith('.') || (typeof bru !== 'undefined' && 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);
+      }
+    }
+  `;
+}
+
+/**
+ * Adds the require() function to a QuickJS VM context
+ * @param {Object} vm - QuickJS VM context
+ * @param {Object} options - Options passed to getRequireCode
+ */
+function addRequireShimToContext(vm) {
+  vm.evalCode(getRequireCode());
+}
+
+module.exports = {
+  getRequireCode,
+  addRequireShimToContext
+};

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;
           },