@usebruno/js 0.50.0 → 0.52.0

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

@@ -0,0 +1,40 @@
+const { marshallToVm } = require('../../utils');
+const addGrpcMetadataListShimToContext = require('./grpc-metadata-list');
+const addGrpcMessageListShimToContext = require('./grpc-message-list');
+
+// Keep this in step with BrunoGrpcResponse.
+const addBrunoGrpcResponseShimToContext = (vm, response, grpcObject) => {
+  const responseObject = vm.newObject();
+
+  // Marshalled once, as on the request: the call is over, so no scalar can change mid-hook.
+  const scalars = ['statusCode', 'statusText', 'duration'];
+
+  for (const property of scalars) {
+    const value = marshallToVm(response?.[property], vm);
+    vm.setProp(responseObject, property, value);
+    value.dispose();
+  }
+
+  // response.metadata / .trailers / .messages — the same lists `bru.grpc.request` gets, read-only here
+  const listEvalCode = ['metadata', 'trailers'].map((property) =>
+    addGrpcMetadataListShimToContext(vm, response[property], responseObject, property, 'globalThis.bru.grpc.response')
+  );
+
+  listEvalCode.push(
+    addGrpcMessageListShimToContext(vm, response.messages, responseObject, 'globalThis.bru.grpc.response')
+  );
+
+  // response.message — present only in `afterMessageReceive`
+  if (response.message) {
+    const message = marshallToVm(response.message, vm);
+    vm.setProp(responseObject, 'message', message);
+    message.dispose();
+  }
+
+  vm.setProp(grpcObject, 'response', responseObject);
+  responseObject.dispose();
+
+  return { evalCode: listEvalCode };
+};
+
+module.exports = addBrunoGrpcResponseShimToContext;

package/src/sandbox/quickjs/shims/grpc/grpc-message-list.js

@@ -0,0 +1,29 @@
+const { createPropertyListBridge } = require('../../utils/property-list-bridge');
+
+/**
+ * Bridges a GrpcMessageList — `bru.grpc.request.messages`, `bru.grpc.response.messages`
+ * — onto a VM object. Keep in sync with GrpcMessageList
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} list - The native GrpcMessageList
+ * @param {Object} targetObject - VM object handle the list is attached to
+ * @param {string} objectPath - Path to `targetObject` in the VM, e.g. `globalThis.bru.grpc.request`
+ * @returns {string} Code the caller must eval once `objectPath` resolves
+ */
+const addGrpcMessageListShimToContext = (vm, list, targetObject, objectPath) => {
+  const listObject = vm.newObject();
+
+  const { evalCode } = createPropertyListBridge(vm, list, listObject, {
+    globalPath: `${objectPath}.messages`,
+    syncReadMethods: ['count'],
+    syncReadObjectMethods: ['get', 'all', 'toJSON'],
+    withIterators: true
+  });
+
+  vm.setProp(targetObject, 'messages', listObject);
+  listObject.dispose();
+
+  return evalCode;
+};
+
+module.exports = addGrpcMessageListShimToContext;

package/src/sandbox/quickjs/shims/grpc/grpc-metadata-list.js

@@ -0,0 +1,31 @@
+const { createPropertyListBridge } = require('../../utils/property-list-bridge');
+
+/**
+ * Bridges a GrpcMetadataList — `bru.grpc.request.metadata`, `bru.grpc.response.metadata`,
+ * `bru.grpc.response.trailers` — onto a VM object. Keep in sync with GrpcMetadataList
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} list - The native GrpcMetadataList
+ * @param {Object} targetObject - VM object handle the list is attached to
+ * @param {string} property - Property name on `targetObject`
+ * @param {string} objectPath - Path to `targetObject` in the VM, e.g. `globalThis.bru.grpc.request`
+ * @returns {string} Code the caller must eval once `objectPath` resolves
+ */
+const addGrpcMetadataListShimToContext = (vm, list, targetObject, property, objectPath) => {
+  const listObject = vm.newObject();
+
+  const { evalCode } = createPropertyListBridge(vm, list, listObject, {
+    globalPath: `${objectPath}.${property}`,
+    syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+    syncReadObjectMethods: ['one', 'all', 'toJSON'],
+    syncWriteMethods: ['upsert', 'add', 'remove', 'clear'],
+    withIterators: true
+  });
+
+  vm.setProp(targetObject, property, listObject);
+  listObject.dispose();
+
+  return evalCode;
+};
+
+module.exports = addGrpcMetadataListShimToContext;

package/src/sandbox/quickjs/utils/index.js

@@ -8,7 +8,7 @@ const createManagedQuickJsContext = (module) => {
   const vm = module.newContext();
   const disposeTracked = trackQuickJsContext(vm);
   const evalCodeRetained = vm.evalCode.bind(vm);
-  const waitForPendingDeferreds = trackPendingDeferreds(vm);
+  const { waitForPendingDeferreds, disposePendingDeferreds } = trackPendingDeferreds(vm);
 
   vm.evalCode = (code, filename = 'eval.js') => {
     const result = evalCodeRetained(code, filename);
@@ -25,7 +25,7 @@ const createManagedQuickJsContext = (module) => {
   return {
     vm,
     waitForPendingDeferreds,
-    dispose: () => disposeQuickJsContext(vm, disposeTracked)
+    dispose: () => disposeQuickJsContext(vm, disposeTracked, disposePendingDeferreds)
   };
 };
 
@@ -38,27 +38,41 @@ const createManagedQuickJsContext = (module) => {
  * `QuickJSUseAfterFree`. Each `.settled` resolves once the deferred is
  * resolved/rejected, so awaiting them keeps the context alive long enough.
  *
- * The hook is installed now (at context creation) so it captures promises as
- * the script runs. Returns a function that drains the captured deferreds at
- * teardown; new deferreds can be created while we wait (a chained timer), so it
- * drains in place until none remain.
+ * The hook installs at context creation. `waitForPendingDeferreds` drains in
+ * place (waiting can chain new deferreds) with no timeout; `disposePendingDeferreds`
+ * frees unsettled resolve/reject handles, which left alive abort JS_FreeRuntime.
  */
-
 const trackPendingDeferreds = (vm) => {
-  const pendingDeferreds = [];
+  const pendingSettles = [];
+  const deferreds = [];
   const originalNewPromise = vm.newPromise.bind(vm);
   vm.newPromise = (...args) => {
     const deferred = originalNewPromise(...args);
-    pendingDeferreds.push(deferred.settled.catch(() => { }));
+    deferreds.push(deferred);
+    pendingSettles.push(deferred.settled.catch(() => { }));
     return deferred;
   };
 
-  return async () => {
-    while (pendingDeferreds.length) {
-      const batch = pendingDeferreds.splice(0);
+  const waitForPendingDeferreds = async () => {
+    while (pendingSettles.length) {
+      const batch = pendingSettles.splice(0);
       await Promise.all(batch);
     }
   };
+
+  const disposePendingDeferreds = () => {
+    while (deferreds.length) {
+      const deferred = deferreds.pop();
+      if (deferred.alive) {
+        deferred.dispose();
+      }
+    }
+  };
+
+  return {
+    waitForPendingDeferreds,
+    disposePendingDeferreds
+  };
 };
 
 /**
@@ -98,22 +112,18 @@ const trackQuickJsContext = (vm) => {
 };
 
 /**
- * Clears shim globals, drains pending QuickJS jobs, and disposes the context.
- * Pass disposeTracked from trackQuickJsContext() to free shim handles first.
+ * Drains pending QuickJS jobs, frees leftover deferreds and tracked handles,
+ * and disposes the context. Jobs are drained BEFORE the handle flush: a job
+ * can call allocating shims or start new async work, and anything it creates
+ * must still be freed or JS_FreeRuntime aborts on the leftover GC objects.
  */
-const disposeQuickJsContext = (vm, disposeTracked) => {
+const disposeQuickJsContext = (vm, disposeTracked, disposePendingDeferreds) => {
   if (!vm?.alive) {
     return;
   }
 
-  if (typeof disposeTracked === 'function') {
-    disposeTracked();
-  }
-
-  // Drain the runtime's pending job queue (resolved/rejected promise callbacks)
-  // before disposing. Executing a job can schedule more jobs (chained `.then()`s),
-  // so we keep going until `hasPendingJob()` reports the queue is empty or a job
-  // throws.
+  // Executing a job can schedule more jobs (chained `.then()`s), so keep going
+  // until `hasPendingJob()` reports the queue is empty or a job throws.
   while (vm.runtime?.hasPendingJob?.()) {
     const result = vm.runtime.executePendingJobs();
     // On error, dispose the error handle and stop draining.
@@ -122,6 +132,15 @@ const disposeQuickJsContext = (vm, disposeTracked) => {
       break;
     }
   }
+
+  if (typeof disposePendingDeferreds === 'function') {
+    disposePendingDeferreds();
+  }
+
+  if (typeof disposeTracked === 'function') {
+    disposeTracked();
+  }
+
   vm.dispose();
 };
 

package/src/utils/error-formatter.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const YAML = require('yaml');
+const { SCRIPT_TYPES } = require('@usebruno/common');
 const { NODEVM_SCRIPT_WRAPPER_OFFSET, QUICKJS_SCRIPT_WRAPPER_OFFSET } = require('./sandbox');
 
 const posixifyPath = (p) => (p ? p.replace(/\\/g, '/') : p);
@@ -11,17 +12,15 @@ const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml'];
 const isAllowedSourceFile = (filePath) =>
   typeof filePath === 'string' && ALLOWED_SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 
-const SCRIPT_TYPES = Object.freeze({
-  PRE_REQUEST: 'pre-request',
-  POST_RESPONSE: 'post-response',
-  TEST: 'test'
-});
-
 // Bruno script types → OpenCollection YAML script types
 const SCRIPT_TYPE_TO_YML = {
   [SCRIPT_TYPES.PRE_REQUEST]: 'before-request',
   [SCRIPT_TYPES.POST_RESPONSE]: 'after-response',
-  [SCRIPT_TYPES.TEST]: 'tests'
+  [SCRIPT_TYPES.TEST]: 'tests',
+  [SCRIPT_TYPES.BEFORE_CALL_START]: 'grpc:before-call-start',
+  [SCRIPT_TYPES.BEFORE_MESSAGE_SEND]: 'grpc:before-message-send',
+  [SCRIPT_TYPES.AFTER_MESSAGE_RECEIVE]: 'grpc:after-message-receive',
+  [SCRIPT_TYPES.AFTER_CALL_END]: 'grpc:after-call-end'
 };
 
 const readFile = (filePath, cache = null) => {
@@ -38,7 +37,11 @@ const readFile = (filePath, cache = null) => {
 const BLOCK_PATTERNS = {
   [SCRIPT_TYPES.PRE_REQUEST]: /^script:pre-request\s*\{/,
   [SCRIPT_TYPES.POST_RESPONSE]: /^script:post-response\s*\{/,
-  [SCRIPT_TYPES.TEST]: /^tests\s*\{/
+  [SCRIPT_TYPES.TEST]: /^tests\s*\{/,
+  [SCRIPT_TYPES.BEFORE_CALL_START]: /^script:grpc:before-call-start\s*\{/,
+  [SCRIPT_TYPES.BEFORE_MESSAGE_SEND]: /^script:grpc:before-message-send\s*\{/,
+  [SCRIPT_TYPES.AFTER_MESSAGE_RECEIVE]: /^script:grpc:after-message-receive\s*\{/,
+  [SCRIPT_TYPES.AFTER_CALL_END]: /^script:grpc:after-call-end\s*\{/
 };
 
 /** Find the 1-indexed line where a script block's content starts in a .bru file */
@@ -747,5 +750,6 @@ module.exports = {
   findYmlScriptBlockStartLine,
   findYmlScriptBlockEndLine,
   adjustStackTrace,
-  getErrorTypeName
+  getErrorTypeName,
+  posixifyPath
 };

package/src/utils/error-formatter.spec.js

@@ -11,7 +11,8 @@ const {
   parseErrorLocation,
   getSourceContextFromContent,
   adjustStackTrace,
-  buildStackFromCallSites
+  buildStackFromCallSites,
+  posixifyPath
 } = require('./error-formatter');
 const fs = require('fs');
 const path = require('path');
@@ -120,6 +121,64 @@ const COLLECTION_YML = [
   '        });'
 ].join('\n');
 
+// gRPC lifecycle hooks:
+// 11: script:grpc:before-call-start { → blockStartLine = 12
+// 16: script:grpc:after-call-end {    → blockStartLine = 17
+const GRPC_BRU = `meta {
+  name: grpc-test
+  type: grpc
+  seq: 1
+}
+
+grpc {
+  url: grpc://localhost:50051
+}
+
+script:grpc:before-call-start {
+  const token = bru.getEnvVar('token');
+  request.setHeader('authorization', token);
+}
+
+script:grpc:after-call-end {
+  const data = response.data;
+  bru.setVar('userId', data.id);
+  console.log(data);
+}
+
+script:grpc:before-message-send {
+  bru.setVar('outbound', bru.grpc.request.message.data.greeting);
+}
+
+script:grpc:after-message-receive {
+  const message = bru.grpc.response.message;
+  bru.setVar('inbound', message.data.reply);
+}`;
+
+// gRPC yml fixture: blockStartLine = 8 (before-call-start), 12 (after-call-end),
+// 16 (before-message-send), 19 (after-message-receive)
+const GRPC_YML = [
+  'info:',
+  '  name: grpc-yaml-test',
+  '  version: "1"',
+  'runtime:',
+  '  scripts:',
+  '    - type: grpc:before-call-start',
+  '      code: |-',
+  '        const token = bru.getEnvVar(\'token\');',
+  '        request.setHeader(\'authorization\', token);',
+  '    - type: grpc:after-call-end',
+  '      code: |-',
+  '        const data = response.data;',
+  '        bru.setVar(\'userId\', data.id);',
+  '    - type: grpc:before-message-send',
+  '      code: |-',
+  '        bru.setVar(\'outbound\', bru.grpc.request.message.data.greeting);',
+  '    - type: grpc:after-message-receive',
+  '      code: |-',
+  '        const message = bru.grpc.response.message;',
+  '        bru.setVar(\'inbound\', message.data.reply);'
+].join('\n');
+
 // Wrapper offsets: QuickJS = 9 (script line 1 = VM line 10), NodeVM = 2 (script line 1 = VM line 3)
 
 describe('Error Formatter', () => {
@@ -128,6 +187,8 @@ describe('Error Formatter', () => {
   let ymlFilePath;
   let bruWithCommentsPath;
   let collectionYmlPath;
+  let grpcBruPath;
+  let grpcYmlPath;
 
   beforeEach(() => {
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bruno-test-'));
@@ -135,10 +196,14 @@ describe('Error Formatter', () => {
     ymlFilePath = path.join(testDir, 'test.yml');
     bruWithCommentsPath = path.join(testDir, 'comments.bru');
     collectionYmlPath = path.join(testDir, 'opencollection.yml');
+    grpcBruPath = path.join(testDir, 'grpc.bru');
+    grpcYmlPath = path.join(testDir, 'grpc.yml');
     fs.writeFileSync(bruFilePath, MULTI_BLOCK_BRU);
     fs.writeFileSync(ymlFilePath, MULTI_BLOCK_YML);
     fs.writeFileSync(bruWithCommentsPath, BRU_WITH_COMMENTS);
     fs.writeFileSync(collectionYmlPath, COLLECTION_YML);
+    fs.writeFileSync(grpcBruPath, GRPC_BRU);
+    fs.writeFileSync(grpcYmlPath, GRPC_YML);
   });
 
   afterEach(() => {
@@ -152,6 +217,13 @@ describe('Error Formatter', () => {
       expect(findScriptBlockStartLine(bruFilePath, 'test')).toBe(25);
     });
 
+    it('should find gRPC lifecycle hook blocks in .bru files', () => {
+      expect(findScriptBlockStartLine(grpcBruPath, 'before-call-start')).toBe(12);
+      expect(findScriptBlockStartLine(grpcBruPath, 'after-call-end')).toBe(17);
+      expect(findScriptBlockStartLine(grpcBruPath, 'before-message-send')).toBe(23);
+      expect(findScriptBlockStartLine(grpcBruPath, 'after-message-receive')).toBe(27);
+    });
+
     it('should return null for missing block or non-.bru files', () => {
       const noBlockPath = path.join(testDir, 'no-block.bru');
       fs.writeFileSync(noBlockPath, 'meta {\n  name: test\n}');
@@ -167,6 +239,13 @@ describe('Error Formatter', () => {
       expect(findScriptBlockEndLine(bruFilePath, 'test')).toBe(30);
     });
 
+    it('should find last content line for gRPC lifecycle hook blocks', () => {
+      expect(findScriptBlockEndLine(grpcBruPath, 'before-call-start')).toBe(13);
+      expect(findScriptBlockEndLine(grpcBruPath, 'after-call-end')).toBe(19);
+      expect(findScriptBlockEndLine(grpcBruPath, 'before-message-send')).toBe(23);
+      expect(findScriptBlockEndLine(grpcBruPath, 'after-message-receive')).toBe(28);
+    });
+
     it('should return null for empty block', () => {
       const emptyBlockPath = path.join(testDir, 'empty.bru');
       fs.writeFileSync(emptyBlockPath, 'script:pre-request {\n}');
@@ -197,6 +276,13 @@ describe('Error Formatter', () => {
       expect(findYmlScriptBlockStartLine(collectionYmlPath, 'test')).toBe(11);
     });
 
+    it('should find gRPC lifecycle hook blocks in .yml files', () => {
+      expect(findYmlScriptBlockStartLine(grpcYmlPath, 'before-call-start')).toBe(8);
+      expect(findYmlScriptBlockStartLine(grpcYmlPath, 'after-call-end')).toBe(12);
+      expect(findYmlScriptBlockStartLine(grpcYmlPath, 'before-message-send')).toBe(16);
+      expect(findYmlScriptBlockStartLine(grpcYmlPath, 'after-message-receive')).toBe(19);
+    });
+
     it('should return null for missing block or non-.yml files', () => {
       const noRuntimePath = path.join(testDir, 'no-runtime.yml');
       fs.writeFileSync(noRuntimePath, 'info:\n  name: simple\n  version: "1"\n');
@@ -216,6 +302,13 @@ describe('Error Formatter', () => {
       expect(findYmlScriptBlockEndLine(collectionYmlPath, 'test')).toBe(13);
     });
 
+    it('should find last content line for gRPC lifecycle hook blocks', () => {
+      expect(findYmlScriptBlockEndLine(grpcYmlPath, 'before-call-start')).toBe(9);
+      expect(findYmlScriptBlockEndLine(grpcYmlPath, 'after-call-end')).toBe(13);
+      expect(findYmlScriptBlockEndLine(grpcYmlPath, 'before-message-send')).toBe(16);
+      expect(findYmlScriptBlockEndLine(grpcYmlPath, 'after-message-receive')).toBe(20);
+    });
+
     it('should return null for missing block', () => {
       const noRuntimePath = path.join(testDir, 'no-runtime.yml');
       fs.writeFileSync(noRuntimePath, 'info:\n  name: simple\n  version: "1"\n');
@@ -804,7 +897,9 @@ get {
         const result = formatErrorWithContextV2(error, 'pre-request');
 
         expect(result).not.toBeNull();
-        expect(result.filePath).toBe(bruFilePath);
+        // display paths are posixified, so the Windows path.join backslashes
+        // must be normalized before comparing
+        expect(result.filePath).toBe(posixifyPath(bruFilePath));
       });
     });
 

package/src/utils/results.js

@@ -1,7 +1,6 @@
 const TestResults = require('../test-results');
 const Test = require('../test');
 
-// Calculate summary statistics for test results
 const getResultsSummary = (results) => {
   const summary = {
     total: results.length,
@@ -20,12 +19,40 @@ const getResultsSummary = (results) => {
   return summary;
 };
 
+/**
+ * Called once per script phase - pre-request, post-response, and the Tests tab each call
+ * this separately, from their own place in runtime/script-runtime.js and
+ * runtime/test-runtime.js. Every call creates its own private `pendingTestPromises` array
+ * below, so each phase tracks and waits for only its own test() calls
+ */
 const createBruTestResultMethods = (bru, assertionResults, chai) => {
   const __brunoTestResults = new TestResults();
-  const test = Test(__brunoTestResults, chai);
+  const baseTest = Test(__brunoTestResults, chai);
+
+  const pendingTestPromises = [];
+
+  const test = (description, callback) => {
+    const promise = baseTest(description, callback);
+    pendingTestPromises.push(promise.catch(() => {}));
+    return promise;
+  };
+
+  /**
+   * Waits for every test() call registered so far to settle - including a test() called
+   * from inside another test()'s callback, after this wait has already started. Mirrors
+   * QuickJS's own waitForPendingDeferreds(). If a test() callback has its own delay (a
+   * setTimeout, a slow request), this simply waits until that delay is over
+   */
+  const waitForPendingTests = async () => {
+    while (pendingTestPromises.length) {
+      const batch = pendingTestPromises.splice(0);
+      await Promise.all(batch);
+    }
+  };
+
   setupBruTestMethods(bru, __brunoTestResults, assertionResults);
 
-  return { __brunoTestResults, test };
+  return { __brunoTestResults, test, waitForPendingTests };
 };
 
 const setupBruTestMethods = (bru, __brunoTestResults, assertionResults) => {