@usebruno/js 0.32.0 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -12,10 +12,11 @@
   },
   "scripts": {
     "test": "node --experimental-vm-modules $(npx which jest) --testPathIgnorePatterns test.js",
-    "sandbox:bundle-libraries": "node ./src/sandbox/bundle-libraries.js"
+    "sandbox:bundle-libraries": "node ./src/sandbox/bundle-libraries.js",
+    "prepack": "npm run test"
   },
   "dependencies": {
-    "@usebruno/common": "0.7.0",
+    "@usebruno/common": "0.8.0",
     "@usebruno/crypto-js": "^3.1.9",
     "@usebruno/query": "0.1.0",
     "ajv": "^8.12.0",

package/src/bru.js

@@ -1,6 +1,7 @@
 const { cloneDeep } = require('lodash');
 const { uuid } = require('./utils');
 const { interpolate: _interpolate } = require('@usebruno/common');
+const { sendRequest } = require('@usebruno/requests').scripting;
 
 const variableNameRegex = /^[\w-.]*$/;
 
@@ -19,6 +20,7 @@ class Bru {
     this.historyLogger = historyLogger;
     this.setVisualizations = setVisualizations;
     this.collectionName = collectionName;
+    this.sendRequest = sendRequest;
     this.runner = {
       skipRequest: () => {
         this.skipRequest = true;

package/src/bruno-request.js

@@ -169,6 +169,14 @@ class BrunoRequest {
     this.timeout = timeout;
     this.req.timeout = timeout;
   }
+  
+  onFail(callback) {
+    if (typeof callback === 'function') {
+      this.req.onFailHandler = callback;
+    } else if (callback) {
+      throw new Error(`${callback} is not a function`);
+    }
+  }
 
   __safeParseJSON(str) {
     try {

package/src/runtime/test-runtime.js

@@ -128,53 +128,60 @@ class TestRuntime {
       context.bru.runRequest = runRequestByItemPathname;
     }
 
-    if (this.runtime === 'quickjs') {
-      await executeQuickJsVmAsync({
-        script: testsFile,
-        context: context
-      });
-    } else {
-      // default runtime is vm2
-      const vm = new NodeVM({
-        sandbox: context,
-        require: {
-          context: 'sandbox',
-          external: true,
-          root: [collectionPath, ...additionalContextRootsAbsolute],
-          mock: {
-            // node libs
-            path,
-            stream,
-            util,
-            url,
-            http,
-            https,
-            punycode,
-            zlib,
-            // 3rd party libs
-            ajv,
-            'ajv-formats': addFormats,
-            btoa,
-            atob,
-            lodash,
-            moment,
-            uuid,
-            nanoid,
-            axios,
-            chai,
-            'node-fetch': fetch,
-            'crypto-js': CryptoJS,
-            'xml2js': xml2js,
-            cheerio,
-            tv4,
-            ...whitelistedModules,
-            fs: allowScriptFilesystemAccess ? fs : undefined,
-            'node-vault': NodeVault
+    let scriptError = null;
+
+    try {
+      if (this.runtime === 'quickjs') {
+        await executeQuickJsVmAsync({
+          script: testsFile,
+          context: context
+        });
+      } else {
+        // default runtime is vm2
+        const vm = new NodeVM({
+          sandbox: context,
+          require: {
+            context: 'sandbox',
+            external: true,
+            root: [collectionPath, ...additionalContextRootsAbsolute],
+            mock: {
+              // node libs
+              path,
+              stream,
+              util,
+              url,
+              http,
+              https,
+              punycode,
+              zlib,
+              // 3rd party libs
+              ajv,
+              'ajv-formats': addFormats,
+              btoa,
+              atob,
+              lodash,
+              moment,
+              uuid,
+              nanoid,
+              axios,
+              chai,
+              'node-fetch': fetch,
+              'crypto-js': CryptoJS,
+              'xml2js': xml2js,
+              cheerio,
+              tv4,
+              ...whitelistedModules,
+              fs: allowScriptFilesystemAccess ? fs : undefined,
+              'node-vault': NodeVault
+            }
           }
-        }
-      });
-      const asyncVM = vm.run(`module.exports = async () => { ${testsFile}}`, path.join(collectionPath, 'vm.js'));
-      await asyncVM();
+        });
+        const asyncVM = vm.run(`module.exports = async () => { ${testsFile}}`, path.join(collectionPath, 'vm.js'));
+        await asyncVM();
+      }
+    } catch (error) {
+      scriptError = error;
+      console.error('Test script execution error:', error);
     }
 
     if (historyLogger) {
@@ -186,7 +193,7 @@ class TestRuntime {
       });
     }
 
-    return {
+    const result = {
       request,
       envVariables: cleanJson(envVariables),
       runtimeVariables: cleanJson(runtimeVariables),
@@ -194,6 +201,13 @@ class TestRuntime {
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest
     };
+
+    if (scriptError) {
+      scriptError.partialResults = result;
+      throw scriptError;
+    }
+
+    return result;
   }
 }
 

package/src/sandbox/quickjs/index.js

@@ -142,10 +142,10 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
     const { bru, req, res, test, __brunoTestResults, console: consoleFn } = externalContext;
 
+    consoleFn && addConsoleShimToContext(vm, consoleFn);
     bru && addBruShimToContext(vm, bru);
     req && addBrunoRequestShimToContext(vm, req);
     res && addBrunoResponseShimToContext(vm, res);
-    consoleFn && addConsoleShimToContext(vm, consoleFn);
     addLocalModuleLoaderShimToContext(vm, collectionPath);
     addPathShimToContext(vm);
 

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

@@ -1,4 +1,4 @@
-const { cleanJson } = require('../../../utils');
+const { cleanJson, cleanCircularJson } = require('../../../utils');
 const { marshallToVm } = require('../utils');
 
 const addBruShimToContext = (vm, bru) => {
@@ -252,8 +252,7 @@ const addBruShimToContext = (vm, bru) => {
     bru
       .runRequest(vm.dump(args))
       .then((response) => {
-        const { status, headers, data, dataBuffer, size, statusText } = response || {};
-        promise.resolve(marshallToVm(cleanJson({ status, statusText, headers, data, dataBuffer, size }), vm));
+        promise.resolve(marshallToVm(cleanCircularJson(response), vm));
       })
       .catch((err) => {
         promise.resolve(
@@ -270,6 +269,26 @@ const addBruShimToContext = (vm, bru) => {
   });
   runRequestHandle.consume((handle) => vm.setProp(bruObject, 'runRequest', handle));
 
+  let sendRequestHandle = vm.newFunction('_sendRequest', (args) => {
+    const promise = vm.newPromise();
+    bru
+      .sendRequest(vm.dump(args))
+      .then((response) => {
+        promise.resolve(marshallToVm(cleanCircularJson(response), vm));
+      })
+      .catch((err) => {
+        promise.reject(
+          marshallToVm(
+            cleanJson(err),
+            vm
+          )
+        );
+      });
+    promise.settled.then(vm.runtime.executePendingJobs);
+    return promise.handle;
+  });
+  sendRequestHandle.consume((handle) => vm.setProp(bruObject, '_sendRequest', handle));
+
   const sleep = vm.newFunction('sleep', (timer) => {
     const t = vm.getString(timer);
     const promise = vm.newPromise();
@@ -285,6 +304,29 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'runner', bruRunnerObject);
   vm.setProp(vm.global, 'bru', bruObject);
   bruObject.dispose();
+
+  vm.evalCode(`
+    globalThis.bru.sendRequest = async (requestConfig, callback) => {
+      if (!callback) return await globalThis.bru._sendRequest(requestConfig);
+      try {
+        const response = await globalThis.bru._sendRequest(requestConfig);
+        try {
+          await callback(null, response);
+        }
+        catch(error) {
+          return Promise.reject(error);
+        }
+      }
+      catch(error) {
+        try {
+          await callback(JSON.parse(JSON.stringify(error)), null);
+        }
+        catch(err) {
+          return Promise.reject(err);
+        }
+      }
+    }
+  `);
 };
 
 module.exports = addBruShimToContext;

package/src/utils.js

@@ -158,6 +158,32 @@ const appendAwaitToTestFunc = (str) => {
   return str.replace(/(?<!\.\s*)(?<!await\s)(test\()/g, 'await $1');
 };
 
+const cleanCircularJson = (data) => {
+  try {
+    // Handle circular references by keeping track of seen objects
+    const seen = new WeakSet();
+    
+    const replacer = (key, value) => {
+      // Skip non-objects and null
+      if (typeof value !== 'object' || value === null) {
+        return value;
+      }
+      
+      // Detect circular reference
+      if (seen.has(value)) {
+        return '[Circular Reference]';
+      }
+      
+      seen.add(value);
+      return value;
+    };
+
+    return JSON.parse(JSON.stringify(data, replacer));
+  } catch (e) {
+    return data;
+  }
+};
+
 module.exports = {
   evaluateJsExpression,
   evaluateJsTemplateLiteral,
@@ -165,5 +191,6 @@ module.exports = {
   internalExpressionCache,
   cleanJson,
   uuid,
-  appendAwaitToTestFunc
+  appendAwaitToTestFunc,
+  cleanCircularJson
 };