@usebruno/js 0.14.0 → 0.15.0

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

@@ -0,0 +1,28 @@
+const path = require('path');
+const { marshallToVm } = require('../../utils');
+
+const fns = ['resolve'];
+
+const addPathShimToContext = async (vm) => {
+  fns.forEach((fn) => {
+    let fnHandle = vm.newFunction(fn, function (...args) {
+      const nativeArgs = args.map(vm.dump);
+      return marshallToVm(path[fn](...nativeArgs), vm);
+    });
+    vm.setProp(vm.global, `__bruno__path__${fn}`, fnHandle);
+    fnHandle.dispose();
+  });
+
+  vm.evalCode(
+    `
+        globalThis.path = {};
+        ${fns?.map((fn, idx) => `globalThis.path.${fn} = __bruno__path__${fn}`).join('\n')}
+        globalThis.requireObject = {
+            ...(globalThis.requireObject || {}),
+            path: globalThis.path,
+        }
+    `
+  );
+};
+
+module.exports = addPathShimToContext;

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

@@ -0,0 +1,30 @@
+const uuid = require('uuid');
+const { marshallToVm } = require('../../utils');
+
+const fns = ['version', 'parse', 'stringify', 'v1', 'v1ToV6', 'v3', 'v4', 'v5', 'v6', 'v6ToV1', 'v7', 'validate'];
+
+const addUuidShimToContext = async (vm) => {
+  fns.forEach((fn) => {
+    let fnHandle = vm.newFunction(fn, function (...args) {
+      const nativeArgs = args.map(vm.dump);
+      return marshallToVm(uuid[fn](...nativeArgs), vm);
+    });
+    vm.setProp(vm.global, `__bruno__uuid__${fn}`, fnHandle);
+    fnHandle.dispose();
+  });
+
+  vm.evalCode(
+    `
+        globalThis.uuid = {};
+        ${['version', 'parse', 'stringify', 'v1', 'v1ToV6', 'v3', 'v4', 'v5', 'v6', 'v6ToV1', 'v7', 'validate']
+          ?.map((fn, idx) => `globalThis.uuid.${fn} = __bruno__uuid__${fn}`)
+          .join('\n')}
+        globalThis.requireObject = {
+            ...globalThis.requireObject,
+            uuid: globalThis.uuid,
+        }
+    `
+  );
+};
+
+module.exports = addUuidShimToContext;

package/src/sandbox/quickjs/shims/local-module.js

@@ -0,0 +1,35 @@
+const path = require('path');
+const fs = require('fs');
+const { marshallToVm } = require('../utils');
+
+const addLocalModuleLoaderShimToContext = (vm, collectionPath) => {
+  let loadLocalModuleHandle = vm.newFunction('loadLocalModule', function (module) {
+    const filename = vm.dump(module);
+
+    // Check if the filename has an extension
+    const hasExtension = path.extname(filename) !== '';
+    const resolvedFilename = hasExtension ? filename : `${filename}.js`;
+
+    // Resolve the file path and check if it's within the collectionPath
+    const filePath = path.resolve(collectionPath, resolvedFilename);
+    const relativePath = path.relative(collectionPath, filePath);
+
+    // Ensure the resolved file path is inside the collectionPath
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+      throw new Error('Access to files outside of the collectionPath is not allowed.');
+    }
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Cannot find module ${filename}`);
+    }
+
+    let code = fs.readFileSync(filePath).toString();
+
+    return marshallToVm(code, vm);
+  });
+
+  vm.setProp(vm.global, '__brunoLoadLocalModule', loadLocalModuleHandle);
+  loadLocalModuleHandle.dispose();
+};
+
+module.exports = addLocalModuleLoaderShimToContext;

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

@@ -0,0 +1,63 @@
+const { marshallToVm } = require('../utils');
+
+const addBruShimToContext = (vm, __brunoTestResults) => {
+  let addResult = vm.newFunction('addResult', function (v) {
+    __brunoTestResults.addResult(vm.dump(v));
+  });
+  vm.setProp(vm.global, '__bruno__addResult', addResult);
+  addResult.dispose();
+
+  let getResults = vm.newFunction('getResults', function () {
+    return marshallToVm(__brunoTestResults.getResults(), vm);
+  });
+  vm.setProp(vm.global, '__bruno__getResults', getResults);
+  getResults.dispose();
+
+  vm.evalCode(
+    `
+      globalThis.expect = require('chai').expect;
+      globalThis.assert = require('chai').assert;
+
+      globalThis.__brunoTestResults = {
+        addResult: globalThis.__bruno__addResult,
+        getResults: globalThis.__bruno__getResults,
+      }
+
+      globalThis.DummyChaiAssertionError = class DummyChaiAssertionError extends Error {
+        constructor(message, props, ssf) {
+          super(message);
+          this.name = "AssertionError";
+          Object.assign(this, props);
+        }
+      }
+
+      globalThis.Test = (__brunoTestResults) => async (description, callback) => {
+        try {
+          await callback();
+          __brunoTestResults.addResult({ description, status: "pass" });
+        } catch (error) {
+          if (error instanceof DummyChaiAssertionError) {
+            const { message, actual, expected } = error;
+            __brunoTestResults.addResult({
+              description,
+              status: "fail",
+              error: message,
+              actual,
+              expected,
+            });
+          } else {
+            globalThis.__bruno__addResult({
+              description,
+              status: "fail",
+              error: error.message || "An unexpected error occurred.",
+            });
+          }
+        }
+      };
+
+      globalThis.test = Test(__brunoTestResults);
+    `
+  );
+};
+
+module.exports = addBruShimToContext;

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

@@ -0,0 +1,33 @@
+const marshallToVm = (value, vm) => {
+  if (value === undefined) {
+    return vm.undefined;
+  }
+  if (value === null) {
+    return vm.null;
+  }
+  if (typeof value === 'string') {
+    return vm.newString(value);
+  } else if (typeof value === 'number') {
+    return vm.newNumber(value);
+  } else if (typeof value === 'boolean') {
+    return value ? vm.true : vm.false;
+  } else if (typeof value === 'object') {
+    if (Array.isArray(value)) {
+      const arr = vm.newArray();
+      for (let i = 0; i < value.length; i++) {
+        vm.setProp(arr, i, marshallToVm(value[i], vm));
+      }
+      return arr;
+    } else {
+      const obj = vm.newObject();
+      for (const key in value) {
+        vm.setProp(obj, key, marshallToVm(value[key], vm));
+      }
+      return obj;
+    }
+  }
+};
+
+module.exports = {
+  marshallToVm
+};

package/src/utils.js

@@ -150,6 +150,10 @@ const uuid = () => {
   const customNanoId = customAlphabet(urlAlphabet, 21);
 
   return customNanoId();
+}
+
+const appendAwaitToTestFunc = (str) => {
+  return str.replace(/(?<!\.\s*)(?<!await\s)(test\()/g, 'await $1');
 };
 
 module.exports = {
@@ -158,5 +162,6 @@ module.exports = {
   createResponseParser,
   internalExpressionCache,
   cleanJson,
-  uuid
+  uuid,
+  appendAwaitToTestFunc
 };