@usebruno/js 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -16,7 +16,7 @@
     "prepack": "npm run test"
   },
   "dependencies": {
-    "@usebruno/common": "0.8.0",
+    "@usebruno/common": "0.10.0",
     "@usebruno/crypto-js": "^3.1.9",
     "@usebruno/query": "0.1.0",
     "ajv": "^8.12.0",

package/src/bru.js

@@ -2,6 +2,7 @@ const { cloneDeep } = require('lodash');
 const { uuid } = require('./utils');
 const { interpolate: _interpolate } = require('@usebruno/common');
 const { sendRequest } = require('@usebruno/requests').scripting;
+const { jar: createCookieJar } = require('@usebruno/common').cookies;
 
 const variableNameRegex = /^[\w-.]*$/;
 
@@ -21,6 +22,50 @@ class Bru {
     this.setVisualizations = setVisualizations;
     this.collectionName = collectionName;
     this.sendRequest = sendRequest;
+
+    this.cookies = {
+      jar: () => {
+        const cookieJar = createCookieJar();
+                
+        return {
+          getCookie: (url, cookieName, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.getCookie(interpolatedUrl, cookieName, callback);
+          },
+
+          getCookies: (url, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.getCookies(interpolatedUrl, callback);
+          },
+
+          setCookie: (url, nameOrCookieObj, valueOrCallback, maybeCallback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.setCookie(interpolatedUrl, nameOrCookieObj, valueOrCallback, maybeCallback);
+          },
+
+          setCookies: (url, cookiesArray, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.setCookies(interpolatedUrl, cookiesArray, callback);
+          },
+
+          // Clear entire cookie jar
+          clear: (callback) => {
+            return cookieJar.clear(callback);
+          },
+
+          // Delete cookies for a specific URL/domain
+          deleteCookies: (url, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.deleteCookies(interpolatedUrl, callback);
+          },
+
+          deleteCookie: (url, cookieName, callback) => {
+            const interpolatedUrl = this.interpolate(url);
+            return cookieJar.deleteCookie(interpolatedUrl, cookieName, callback);
+          }
+        };
+      }
+    };
     this.runner = {
       skipRequest: () => {
         this.skipRequest = true;

package/src/bruno-response.js

@@ -9,6 +9,7 @@ class BrunoResponse {
     this.headers = res ? res.headers : null;
     this.body = res ? res.data : null;
     this.responseTime = res ? res.responseTime : null;
+    this.url = res?.request ? res.request.protocol + '//' + res.request.host + res.request.path : null;
 
     // Make the instance callable
     const callable = (...args) => get(this.body, ...args);
@@ -42,6 +43,10 @@ class BrunoResponse {
     return this.res ? this.res.responseTime : null;
   }
 
+  getUrl() {
+    return this.res ? this.url : null;
+  }
+
   setBody(data) {
     if (!this.res) {
       return;
@@ -51,6 +56,50 @@ class BrunoResponse {
     this.res.data = clonedData;
     this.body = clonedData;
   }
+
+  // TODO: Refactor: dataBuffer size calculation should be handled in a shared utility so it can be passed and reused across the application
+  getSize() {
+    if (!this.res) {
+      return { header: 0, body: 0, total: 0 };
+    }
+
+    const { data, dataBuffer, headers } = this.res;
+    let bodySize = 0;
+    
+    // Use raw received bytes
+    if (Buffer.isBuffer(dataBuffer)) {
+      bodySize = dataBuffer.length;
+    } else {
+      // Use server-reported Content-Length
+      const contentLength = headers && (headers['content-length'] || headers['Content-Length']);
+      if (contentLength && !isNaN(contentLength)) {
+        bodySize = parseInt(contentLength, 10);
+      } else if (data != null) {
+        // Manual calculation
+        const raw = typeof data === 'string' ? data : JSON.stringify(data);
+        bodySize = Buffer.byteLength(raw);
+      }
+    }
+
+    const headerLines = [
+      `HTTP/1.1 ${this.res.status} ${this.res.statusText}`,
+      ...Object.entries(this.res.headers || {}).flatMap(([key, value]) =>
+        Array.isArray(value)
+          ? value.map((v) => `${key}: ${v}`)
+          : [`${key}: ${value}`]
+      ),
+      '',
+      ''
+    ];
+    const headerSize = Buffer.byteLength(headerLines.join('\r\n'));
+
+    return { header: headerSize, body: bodySize, total: headerSize + bodySize };
+    
+  }
+
+  getDataBuffer() {
+    return this.res ? this.res.dataBuffer : null;
+  }
 }
 
 module.exports = BrunoResponse;

package/src/runtime/script-runtime.js

@@ -12,8 +12,6 @@ const { get } = require('lodash');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
-const Test = require('../test');
-const TestResults = require('../test-results');
 const { cleanJson } = require('../utils');
 const { createBruTestResultMethods } = require('../utils/results');
 

package/src/runtime/test-runtime.js

@@ -181,7 +181,6 @@ class TestRuntime {
       }
     } catch (error) {
       scriptError = error;
-      console.error('Test script execution error:', error);
     }
 
     if (historyLogger) {

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

@@ -173,6 +173,9 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruRunnerIterationDataObject, 'stringify', runnerStringifyIterationData);
   runnerStringifyIterationData.dispose();
 
+  vm.setProp(bruRunnerObject, 'iterationData', bruRunnerIterationDataObject);
+  bruRunnerIterationDataObject.dispose();
+
   let visualize = vm.newFunction('visualize', function (type, data) {
     bru.visualize(vm.dump(type), vm.dump(data));
   });
@@ -300,8 +303,139 @@ const addBruShimToContext = (vm, bru) => {
   });
   sleep.consume((handle) => vm.setProp(bruObject, 'sleep', handle));
 
-  vm.setProp(bruRunnerObject, 'iterationData', bruRunnerIterationDataObject);
+  let bruCookiesObject = vm.newObject();
+
+  const _jarFn = vm.newFunction('_jar', () => {
+    const nativeJar = bru.cookies.jar();
+    const jarObj = vm.newObject();
+
+    const _getCookieFn = vm.newFunction('_getCookie', (url, cookieName) => {
+      const promise = vm.newPromise();
+      nativeJar.getCookie(vm.dump(url), vm.dump(cookieName), (err, cookie) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(marshallToVm(cleanCircularJson(cookie), vm));
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _getCookieFn.consume((handle) => vm.setProp(jarObj, '_getCookie', handle));
+
+    const _getCookiesFn = vm.newFunction('_getCookies', (url) => {
+      const promise = vm.newPromise();
+      nativeJar.getCookies(vm.dump(url), (err, cookies) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(marshallToVm(cleanCircularJson(cookies), vm));
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _getCookiesFn.consume((handle) => vm.setProp(jarObj, '_getCookies', handle));
+
+    const _setCookieFn = vm.newFunction('_setCookie', (url, nameOrCookieObj, value) => {
+      const promise = vm.newPromise();
+      const dumpedUrl = vm.dump(url);
+      const dumpedNameOrObj = vm.dump(nameOrCookieObj);
+      
+      // Check if the second argument is an object (cookie object case)
+      if (typeof dumpedNameOrObj === 'object' && dumpedNameOrObj !== null) {
+        // Cookie object case: setCookie(url, cookieObject, callback)
+        nativeJar.setCookie(dumpedUrl, dumpedNameOrObj, (err) => {
+          if (err) {
+            promise.reject(marshallToVm(cleanJson(err), vm));
+          } else {
+            promise.resolve(vm.undefined);
+          }
+        });
+      } else {
+        // Name/value case: setCookie(url, name, value, callback)
+        const dumpedValue = value ? vm.dump(value) : '';
+        nativeJar.setCookie(dumpedUrl, dumpedNameOrObj, dumpedValue, (err) => {
+          if (err) {
+            promise.reject(marshallToVm(cleanJson(err), vm));
+          } else {
+            promise.resolve(vm.undefined);
+          }
+        });
+      }
+      
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _setCookieFn.consume((handle) => vm.setProp(jarObj, '_setCookie', handle));
+
+    const _setCookiesFn = vm.newFunction('_setCookies', (url, cookiesArray) => {
+      const promise = vm.newPromise();
+      
+      nativeJar.setCookies(vm.dump(url), vm.dump(cookiesArray), (err) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(vm.undefined);
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _setCookiesFn.consume((handle) => vm.setProp(jarObj, '_setCookies', handle));
+
+    const _clearFn = vm.newFunction('_clear', () => {
+      const promise = vm.newPromise();
+      nativeJar.clear((err) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(vm.undefined);
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _clearFn.consume((handle) => vm.setProp(jarObj, '_clear', handle));
+
+    const _deleteCookiesFn = vm.newFunction('_deleteCookies', (url) => {
+      const promise = vm.newPromise();
+      nativeJar.deleteCookies(vm.dump(url), (err) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(vm.undefined);
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _deleteCookiesFn.consume((handle) => vm.setProp(jarObj, '_deleteCookies', handle));
+
+    const _deleteCookieFn = vm.newFunction('_deleteCookie', (url, cookieName) => {
+      const promise = vm.newPromise();
+      nativeJar.deleteCookie(vm.dump(url), vm.dump(cookieName), (err) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(vm.undefined);
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _deleteCookieFn.consume((handle) => vm.setProp(jarObj, '_deleteCookie', handle));
+
+    return jarObj;
+  });
+  _jarFn.consume((handle) => vm.setProp(bruCookiesObject, '_jar', handle));
+
+  vm.setProp(bruObject, 'cookies', bruCookiesObject);
+  bruCookiesObject.dispose();
+
   vm.setProp(bruObject, 'runner', bruRunnerObject);
+  bruRunnerObject.dispose();
+
   vm.setProp(vm.global, 'bru', bruObject);
   bruObject.dispose();
 
@@ -325,7 +459,41 @@ const addBruShimToContext = (vm, bru) => {
           return Promise.reject(err);
         }
       }
-    }
+    };
+
+    globalThis.bru.cookies.jar = () => {
+      const _jar = globalThis.bru.cookies._jar();
+
+      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); }
+        }
+      };
+
+      return {
+        getCookie: (url, name, cb) => callWithCallback(() => _jar._getCookie(url, name), cb),
+        getCookies: (url, cb) => callWithCallback(() => _jar._getCookies(url), cb),
+        setCookie: (url, nameOrCookieObj, valueOrCallback, maybeCallback) => {
+          if (typeof nameOrCookieObj === 'object' && nameOrCookieObj !== null) {
+            const callback = typeof valueOrCallback === 'function' ? valueOrCallback : undefined;
+            return callWithCallback(() => _jar._setCookie(url, nameOrCookieObj), callback);
+          } else {
+            const value = typeof valueOrCallback === 'string' ? valueOrCallback : '';
+            const callback = typeof maybeCallback === 'function' ? maybeCallback : 
+                           (typeof valueOrCallback === 'function' ? valueOrCallback : undefined);
+            return callWithCallback(() => _jar._setCookie(url, nameOrCookieObj, value), callback);
+          }
+        },
+        setCookies: (url, cookiesArray, cb) => callWithCallback(() => _jar._setCookies(url, cookiesArray), cb),
+        clear: (cb) => callWithCallback(() => _jar._clear(), cb),
+        deleteCookies: (url, cb) => callWithCallback(() => _jar._deleteCookies(url), cb),
+        deleteCookie: (url, name, cb) => callWithCallback(() => _jar._deleteCookie(url, name), cb)
+      };
+    };
   `);
 };
 

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

@@ -10,17 +10,20 @@ const addBrunoResponseShimToContext = (vm, res) => {
   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();
 
   let getStatusText = vm.newFunction('getStatusText', function () {
@@ -59,12 +62,24 @@ const addBrunoResponseShimToContext = (vm, res) => {
   vm.setProp(resFn, 'getResponseTime', getResponseTime);
   getResponseTime.dispose();
 
+  let getUrl = vm.newFunction('getUrl', function () {
+    return marshallToVm(res.getUrl(), vm);
+  });
+  vm.setProp(resFn, 'getUrl', getUrl);
+  getUrl.dispose();
+
   let setBody = vm.newFunction('setBody', function (data) {
     res.setBody(vm.dump(data));
   });
   vm.setProp(resFn, 'setBody', setBody);
   setBody.dispose();
 
+  let getSize = vm.newFunction('getSize', function () {
+    return marshallToVm(res.getSize(), vm);
+  });
+  vm.setProp(resFn, 'getSize', getSize);
+  getSize.dispose();
+
   vm.setProp(vm.global, 'res', resFn);
   resFn.dispose();
 };

package/src/utils.js

@@ -118,6 +118,7 @@ const createResponseParser = (response = {}) => {
   res.headers = response.headers;
   res.body = response.data;
   res.responseTime = response.responseTime;
+  res.url = response.request ? response.request.protocol + '//' + response.request.host + response.request.path : null;
 
   res.jq = (expr) => {
     const output = jsonQuery(expr, { data: response.data });