@usebruno/js 0.14.0 → 0.15.0

package/src/sandbox/bundle-libraries.js

@@ -0,0 +1,88 @@
+const rollup = require('rollup');
+const { nodeResolve } = require('@rollup/plugin-node-resolve');
+const commonjs = require('@rollup/plugin-commonjs');
+const fs = require('fs');
+const { terser } = require('rollup-plugin-terser');
+
+const bundleLibraries = async () => {
+  const codeScript = `
+    import { expect, assert } from 'chai';
+    import { Buffer } from "buffer";
+    import moment from "moment";
+    import btoa from "btoa";
+    import atob from "atob";
+    import * as CryptoJS from "crypto-js-3.1.9-1";
+    globalThis.expect = expect;
+    globalThis.assert = assert;
+    globalThis.moment = moment;
+    globalThis.btoa = btoa;
+    globalThis.atob = atob;
+    globalThis.Buffer = Buffer;
+    globalThis.CryptoJS = CryptoJS;
+    globalThis.requireObject = {
+      ...(globalThis.requireObject || {}),
+      'chai': { expect, assert },
+      'moment': moment,
+      'buffer': { Buffer },
+      'btoa': btoa,
+      'atob': atob,
+      'crypto-js': CryptoJS
+    };
+`;
+
+  const config = {
+    input: {
+      input: 'inline-code',
+      plugins: [
+        {
+          name: 'inline-code-plugin',
+          resolveId(id) {
+            if (id === 'inline-code') {
+              return id;
+            }
+            return null;
+          },
+          load(id) {
+            if (id === 'inline-code') {
+              return codeScript;
+            }
+            return null;
+          }
+        },
+        nodeResolve({
+          preferBuiltins: false,
+          browser: false
+        }),
+        commonjs(),
+        terser()
+      ]
+    },
+    output: {
+      file: './src/sandbox/bundle-browser-rollup.js',
+      format: 'iife',
+      name: 'MyBundle'
+    }
+  };
+
+  try {
+    const bundle = await rollup.rollup(config.input);
+    const { output } = await bundle.generate(config.output);
+    fs.writeFileSync(
+      './src/sandbox/bundle-browser-rollup.js',
+      `
+      const getBundledCode = () => {
+        return function(){
+          ${output?.map((o) => o.code).join('\n')}
+        }()
+      }
+      module.exports = getBundledCode;
+    `
+    );
+  } catch (error) {
+    console.error('Error while bundling:', error);
+  }
+};
+
+bundleLibraries();
+
+module.exports = bundleLibraries;

package/src/sandbox/quickjs/index.js

@@ -0,0 +1,193 @@
+const addBruShimToContext = require('./shims/bru');
+const addBrunoRequestShimToContext = require('./shims/bruno-request');
+const addConsoleShimToContext = require('./shims/console');
+const addBrunoResponseShimToContext = require('./shims/bruno-response');
+const addTestShimToContext = require('./shims/test');
+const addLibraryShimsToContext = require('./shims/lib');
+const addLocalModuleLoaderShimToContext = require('./shims/local-module');
+const { newQuickJSWASMModule, memoizePromiseFactory } = require('quickjs-emscripten');
+
+// execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
+const getBundledCode = require('../bundle-browser-rollup');
+const addPathShimToContext = require('./shims/lib/path');
+const { marshallToVm } = require('./utils');
+
+let QuickJSSyncContext;
+const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
+const getContext = (opts) => loader().then((mod) => (QuickJSSyncContext = mod.newContext(opts)));
+getContext();
+
+const toNumber = (value) => {
+  const num = Number(value);
+  return Number.isInteger(num) ? parseInt(value, 10) : parseFloat(value);
+};
+
+const removeQuotes = (str) => {
+  if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+    return str.slice(1, -1);
+  }
+  return str;
+};
+
+const executeQuickJsVm = ({ script: externalScript, context: externalContext, scriptType = 'template-literal' }) => {
+  if (!externalScript?.length || typeof externalScript !== 'string') {
+    return externalScript;
+  }
+  externalScript = externalScript?.trim();
+
+  if (!isNaN(Number(externalScript))) {
+    return Number(externalScript);
+  }
+
+  if (externalScript === 'true') return true;
+  if (externalScript === 'false') return false;
+  if (externalScript === 'null') return null;
+  if (externalScript === 'undefined') return undefined;
+
+  externalScript = removeQuotes(externalScript);
+
+  const vm = QuickJSSyncContext;
+
+  try {
+    const { bru, req, res, ...variables } = externalContext;
+
+    bru && addBruShimToContext(vm, bru);
+    req && addBrunoRequestShimToContext(vm, req);
+    res && addBrunoResponseShimToContext(vm, res);
+
+    Object.entries(variables)?.forEach(([key, value]) => {
+      vm.setProp(vm.global, key, marshallToVm(value, vm));
+    });
+
+    const templateLiteralText = `\`${externalScript}\``;
+    const jsExpressionText = `${externalScript}`;
+
+    let scriptText = scriptType === 'template-literal' ? templateLiteralText : jsExpressionText;
+
+    const result = vm.evalCode(scriptText);
+    if (result.error) {
+      let e = vm.dump(result.error);
+      result.error.dispose();
+      return e;
+    } else {
+      let v = vm.dump(result.value);
+      result.value.dispose();
+      return v;
+    }
+  } catch (error) {
+    console.error('Error executing the script!', error);
+  }
+};
+
+const executeQuickJsVmAsync = async ({ script: externalScript, context: externalContext, collectionPath }) => {
+  if (!externalScript?.length || typeof externalScript !== 'string') {
+    return externalScript;
+  }
+  externalScript = externalScript?.trim();
+
+  if (!isNaN(Number(externalScript))) {
+    return toNumber(externalScript);
+  }
+
+  if (externalScript === 'true') return true;
+  if (externalScript === 'false') return false;
+  if (externalScript === 'null') return null;
+  if (externalScript === 'undefined') return undefined;
+
+  externalScript = removeQuotes(externalScript);
+
+  try {
+    const module = await newQuickJSWASMModule();
+    const vm = module.newContext();
+
+    const bundledCode = getBundledCode?.toString() || '';
+    const moduleLoaderCode = function () {
+      return `
+        globalThis.require = (mod) => {
+          let lib = globalThis.requireObject[mod];
+          let isModuleAPath = (module) => (module?.startsWith('.') || 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);
+          }
+        }
+      `;
+    };
+
+    vm.evalCode(
+      `
+        (${bundledCode})()
+        ${moduleLoaderCode()}
+      `
+    );
+
+    const { bru, req, res, test, __brunoTestResults, console: consoleFn } = externalContext;
+
+    bru && addBruShimToContext(vm, bru);
+    req && addBrunoRequestShimToContext(vm, req);
+    res && addBrunoResponseShimToContext(vm, res);
+    consoleFn && addConsoleShimToContext(vm, consoleFn);
+    addLocalModuleLoaderShimToContext(vm, collectionPath);
+    addPathShimToContext(vm);
+
+    await addLibraryShimsToContext(vm);
+
+    test && __brunoTestResults && addTestShimToContext(vm, __brunoTestResults);
+
+    const script = `
+      (async () => {
+        const setTimeout = async(fn, timer) => {
+          v = await bru.sleep(timer);
+          fn.apply();
+        }
+        await bru.sleep(0);
+        try {
+          ${externalScript}
+        }
+        catch(error) {
+          console?.debug?.('quick-js:execution-end:with-error', error?.message);
+          throw new Error(error?.message);
+        }
+        return 'done';
+      })()
+    `;
+
+    const result = vm.evalCode(script);
+    const promiseHandle = vm.unwrapResult(result);
+    const resolvedResult = await vm.resolvePromise(promiseHandle);
+    promiseHandle.dispose();
+    const resolvedHandle = vm.unwrapResult(resolvedResult);
+    resolvedHandle.dispose();
+    // vm.dispose();
+    return;
+  } catch (error) {
+    console.error('Error executing the script!', error);
+    throw new Error(error);
+  }
+};
+
+module.exports = {
+  executeQuickJsVm,
+  executeQuickJsVmAsync
+};

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

@@ -0,0 +1,87 @@
+const { marshallToVm } = require('../utils');
+
+const addBruShimToContext = (vm, bru) => {
+  const bruObject = vm.newObject();
+
+  let cwd = vm.newFunction('cwd', function () {
+    return marshallToVm(bru.cwd(), vm);
+  });
+  vm.setProp(bruObject, 'cwd', cwd);
+  cwd.dispose();
+
+  let getEnvName = vm.newFunction('getEnvName', function () {
+    return marshallToVm(bru.getEnvName(), vm);
+  });
+  vm.setProp(bruObject, 'getEnvName', getEnvName);
+  getEnvName.dispose();
+
+  let getProcessEnv = vm.newFunction('getProcessEnv', function (key) {
+    return marshallToVm(bru.getProcessEnv(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getProcessEnv', getProcessEnv);
+  getProcessEnv.dispose();
+
+  let getEnvVar = vm.newFunction('getEnvVar', function (key) {
+    return marshallToVm(bru.getEnvVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getEnvVar', getEnvVar);
+  getEnvVar.dispose();
+
+  let setEnvVar = vm.newFunction('setEnvVar', function (key, value) {
+    bru.setEnvVar(vm.dump(key), vm.dump(value));
+  });
+  vm.setProp(bruObject, 'setEnvVar', setEnvVar);
+  setEnvVar.dispose();
+
+  let getVar = vm.newFunction('getVar', function (key) {
+    return marshallToVm(bru.getVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getVar', getVar);
+  getVar.dispose();
+
+  let setVar = vm.newFunction('setVar', function (key, value) {
+    bru.setVar(vm.dump(key), vm.dump(value));
+  });
+  vm.setProp(bruObject, 'setVar', setVar);
+  setVar.dispose();
+
+  let setNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
+    bru.setNextRequest(vm.dump(nextRequest));
+  });
+  vm.setProp(bruObject, 'setNextRequest', setNextRequest);
+  setNextRequest.dispose();
+
+  let visualize = vm.newFunction('visualize', function (type, data) {
+    bru.visualize(vm.dump(type), vm.dump(data));
+  });
+  vm.setProp(bruObject, 'visualize', visualize);
+  visualize.dispose();
+
+  let getSecretVar = vm.newFunction('getSecretVar', function (key) {
+    return marshallToVm(bru.getSecretVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getSecretVar', getSecretVar);
+  getSecretVar.dispose();
+
+  let getRequestVar = vm.newFunction('getRequestVar', function (key) {
+    return marshallToVm(bru.getRequestVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'getRequestVar', getRequestVar);
+  getRequestVar.dispose();
+
+  const sleep = vm.newFunction('sleep', (timer) => {
+    const t = vm.getString(timer);
+    const promise = vm.newPromise();
+    setTimeout(() => {
+      promise.resolve(vm.newString('slept'));
+    }, t);
+    promise.settled.then(vm.runtime.executePendingJobs);
+    return promise.handle;
+  });
+  sleep.consume((handle) => vm.setProp(bruObject, 'sleep', handle));
+
+  vm.setProp(vm.global, 'bru', bruObject);
+  bruObject.dispose();
+};
+
+module.exports = addBruShimToContext;

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

@@ -0,0 +1,112 @@
+const { marshallToVm } = require('../utils');
+
+const addBrunoRequestShimToContext = (vm, req) => {
+  const reqObject = vm.newObject();
+
+  const url = marshallToVm(req.getUrl(), vm);
+  const method = marshallToVm(req.getMethod(), vm);
+  const headers = marshallToVm(req.getHeaders(), vm);
+  const body = marshallToVm(req.getBody(), vm);
+  const timeout = marshallToVm(req.getTimeout(), vm);
+
+  vm.setProp(reqObject, 'url', url);
+  vm.setProp(reqObject, 'method', method);
+  vm.setProp(reqObject, 'headers', headers);
+  vm.setProp(reqObject, 'body', body);
+  vm.setProp(reqObject, 'timeout', timeout);
+
+  url.dispose();
+  method.dispose();
+  headers.dispose();
+  body.dispose();
+  timeout.dispose();
+
+  let getUrl = vm.newFunction('getUrl', function () {
+    return marshallToVm(req.getUrl(), vm);
+  });
+  vm.setProp(reqObject, 'getUrl', getUrl);
+  getUrl.dispose();
+
+  let setUrl = vm.newFunction('setUrl', function (url) {
+    req.setUrl(vm.dump(url));
+  });
+  vm.setProp(reqObject, 'setUrl', setUrl);
+  setUrl.dispose();
+
+  let getMethod = vm.newFunction('getMethod', function () {
+    return marshallToVm(req.getMethod(), vm);
+  });
+  vm.setProp(reqObject, 'getMethod', getMethod);
+  getMethod.dispose();
+
+  let getAuthMode = vm.newFunction('getAuthMode', function () {
+    return marshallToVm(req.getAuthMode(), vm);
+  });
+  vm.setProp(reqObject, 'getAuthMode', getAuthMode);
+  getAuthMode.dispose();
+
+  let setMethod = vm.newFunction('setMethod', function (method) {
+    req.setMethod(vm.dump(method));
+  });
+  vm.setProp(reqObject, 'setMethod', setMethod);
+  setMethod.dispose();
+
+  let getHeaders = vm.newFunction('getHeaders', function () {
+    return marshallToVm(req.getHeaders(), vm);
+  });
+  vm.setProp(reqObject, 'getHeaders', getHeaders);
+  getHeaders.dispose();
+
+  let setHeaders = vm.newFunction('setHeaders', function (headers) {
+    req.setHeaders(vm.dump(headers));
+  });
+  vm.setProp(reqObject, 'setHeaders', setHeaders);
+  setHeaders.dispose();
+
+  let getHeader = vm.newFunction('getHeader', function (name) {
+    return marshallToVm(req.getHeader(vm.dump(name)), vm);
+  });
+  vm.setProp(reqObject, 'getHeader', getHeader);
+  getHeader.dispose();
+
+  let setHeader = vm.newFunction('setHeader', function (name, value) {
+    req.setHeader(vm.dump(name), vm.dump(value));
+  });
+  vm.setProp(reqObject, 'setHeader', setHeader);
+  setHeader.dispose();
+
+  let getBody = vm.newFunction('getBody', function () {
+    return marshallToVm(req.getBody(), vm);
+  });
+  vm.setProp(reqObject, 'getBody', getBody);
+  getBody.dispose();
+
+  let setBody = vm.newFunction('setBody', function (data) {
+    req.setBody(vm.dump(data));
+  });
+  vm.setProp(reqObject, 'setBody', setBody);
+  setBody.dispose();
+
+  let setMaxRedirects = vm.newFunction('setMaxRedirects', function (maxRedirects) {
+    req.setMaxRedirects(vm.dump(maxRedirects));
+  });
+  vm.setProp(reqObject, 'setMaxRedirects', setMaxRedirects);
+  setMaxRedirects.dispose();
+
+  let getTimeout = vm.newFunction('getTimeout', function () {
+    return marshallToVm(req.getTimeout(), vm);
+  });
+  vm.setProp(reqObject, 'getTimeout', getTimeout);
+  getTimeout.dispose();
+
+  let setTimeout = vm.newFunction('setTimeout', function (timeout) {
+    req.setTimeout(vm.dump(timeout));
+  });
+  vm.setProp(reqObject, 'setTimeout', setTimeout);
+  setTimeout.dispose();
+
+  vm.setProp(vm.global, 'req', reqObject);
+  reqObject.dispose();
+};
+
+module.exports = addBrunoRequestShimToContext;

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

@@ -0,0 +1,55 @@
+const { marshallToVm } = require('../utils');
+
+const addBrunoResponseShimToContext = (vm, res) => {
+  const resObject = vm.newObject();
+
+  const status = marshallToVm(res?.status, vm);
+  const headers = marshallToVm(res?.headers, vm);
+  const body = marshallToVm(res?.body, vm);
+  const responseTime = marshallToVm(res?.responseTime, vm);
+
+  vm.setProp(resObject, 'status', status);
+  vm.setProp(resObject, 'headers', headers);
+  vm.setProp(resObject, 'body', body);
+  vm.setProp(resObject, 'responseTime', responseTime);
+
+  status.dispose();
+  headers.dispose();
+  body.dispose();
+  responseTime.dispose();
+
+  let getStatus = vm.newFunction('getStatus', function () {
+    return marshallToVm(res.getStatus(), vm);
+  });
+  vm.setProp(resObject, 'getStatus', getStatus);
+  getStatus.dispose();
+
+  let getHeader = vm.newFunction('getHeader', function (name) {
+    return marshallToVm(res.getHeader(vm.dump(name)), vm);
+  });
+  vm.setProp(resObject, 'getHeader', getHeader);
+  getHeader.dispose();
+
+  let getHeaders = vm.newFunction('getHeaders', function () {
+    return marshallToVm(res.getHeaders(), vm);
+  });
+  vm.setProp(resObject, 'getHeaders', getHeaders);
+  getHeaders.dispose();
+
+  let getBody = vm.newFunction('getBody', function () {
+    return marshallToVm(res.getBody(), vm);
+  });
+  vm.setProp(resObject, 'getBody', getBody);
+  getBody.dispose();
+
+  let getResponseTime = vm.newFunction('getResponseTime', function () {
+    return marshallToVm(res.getResponseTime(), vm);
+  });
+  vm.setProp(resObject, 'getResponseTime', getResponseTime);
+  getResponseTime.dispose();
+
+  vm.setProp(vm.global, 'res', resObject);
+  resObject.dispose();
+};
+
+module.exports = addBrunoResponseShimToContext;

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

@@ -0,0 +1,46 @@
+const addConsoleShimToContext = (vm, console) => {
+  if (!console) return;
+
+  const consoleHandle = vm.newObject();
+
+  const logHandle = vm.newFunction('log', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    console?.log?.(...nativeArgs);
+  });
+
+  const debugHandle = vm.newFunction('debug', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    console?.debug?.(...nativeArgs);
+  });
+
+  const infoHandle = vm.newFunction('info', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    console?.info?.(...nativeArgs);
+  });
+
+  const warnHandle = vm.newFunction('warn', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    console?.warn?.(...nativeArgs);
+  });
+
+  const errorHandle = vm.newFunction('error', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    console?.error?.(...nativeArgs);
+  });
+
+  vm.setProp(consoleHandle, 'log', logHandle);
+  vm.setProp(consoleHandle, 'debug', debugHandle);
+  vm.setProp(consoleHandle, 'info', infoHandle);
+  vm.setProp(consoleHandle, 'warn', warnHandle);
+  vm.setProp(consoleHandle, 'error', errorHandle);
+
+  vm.setProp(vm.global, 'console', consoleHandle);
+  consoleHandle.dispose();
+  logHandle.dispose();
+  debugHandle.dispose();
+  infoHandle.dispose();
+  warnHandle.dispose();
+  errorHandle.dispose();
+};
+
+module.exports = addConsoleShimToContext;

package/src/sandbox/quickjs/shims/lib/axios.js

@@ -0,0 +1,72 @@
+const axios = require('axios');
+const { cleanJson } = require('../../../../utils');
+const { marshallToVm } = require('../../utils');
+
+const methods = ['get', 'post', 'put', 'patch', 'delete'];
+
+const addAxiosShimToContext = async (vm) => {
+  methods?.forEach((method) => {
+    const axiosHandle = vm.newFunction(method, (...args) => {
+      const nativeArgs = args.map(vm.dump);
+      const promise = vm.newPromise();
+      axios[method](...nativeArgs)
+        .then((response) => {
+          const { status, headers, data } = response || {};
+          promise.resolve(marshallToVm(cleanJson({ status, headers, data }), vm));
+        })
+        .catch((err) => {
+          promise.resolve(
+            marshallToVm(
+              cleanJson({
+                message: err.message
+              }),
+              vm
+            )
+          );
+        });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    axiosHandle.consume((handle) => vm.setProp(vm.global, `__bruno__axios__${method}`, handle));
+  });
+
+  const axiosHandle = vm.newFunction('axios', (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    const promise = vm.newPromise();
+    axios(...nativeArgs)
+      .then((response) => {
+        const { status, headers, data } = response || {};
+        promise.resolve(marshallToVm(cleanJson({ status, headers, data }), vm));
+      })
+      .catch((err) => {
+        promise.resolve(
+          marshallToVm(
+            cleanJson({
+              message: err.message
+            }),
+            vm
+          )
+        );
+      });
+    promise.settled.then(vm.runtime.executePendingJobs);
+    return promise.handle;
+  });
+  axiosHandle.consume((handle) => vm.setProp(vm.global, `__bruno__axios`, handle));
+
+  vm.evalCode(
+    `
+        globalThis.axios = __bruno__axios;
+        ${methods
+          ?.map((method) => {
+            return `globalThis.axios.${method} = __bruno__axios__${method};`;
+          })
+          ?.join('\n')}
+        globalThis.requireObject = {
+          ...globalThis.requireObject,
+          axios: globalThis.axios,
+        }
+    `
+  );
+};
+
+module.exports = addAxiosShimToContext;

package/src/sandbox/quickjs/shims/lib/index.js

@@ -0,0 +1,13 @@
+const addAxiosShimToContext = require('./axios');
+const addNanoidShimToContext = require('./nanoid');
+const addPathShimToContext = require('./path');
+const addUuidShimToContext = require('./uuid');
+
+const addLibraryShimsToContext = async (vm) => {
+  await addNanoidShimToContext(vm);
+  await addAxiosShimToContext(vm);
+  await addUuidShimToContext(vm);
+  await addPathShimToContext(vm);
+};
+
+module.exports = addLibraryShimsToContext;

package/src/sandbox/quickjs/shims/lib/nanoid.js

@@ -0,0 +1,24 @@
+const { nanoid } = require('nanoid');
+const { marshallToVm } = require('../../utils');
+
+const addNanoidShimToContext = async (vm) => {
+  let _nanoid = vm.newFunction('nanoid', function () {
+    let v = nanoid();
+    return marshallToVm(v, vm);
+  });
+  vm.setProp(vm.global, '__bruno__nanoid', _nanoid);
+  _nanoid.dispose();
+
+  vm.evalCode(
+    `
+      globalThis.nanoid = {};
+      globalThis.nanoid.nanoid = globalThis.__bruno__nanoid;
+      globalThis.requireObject = {
+          ...globalThis.requireObject,
+          'nanoid': globalThis.nanoid
+      }
+    `
+  );
+};
+
+module.exports = addNanoidShimToContext;