@usebruno/js 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "main": "src/index.js",
   "files": [
     "src",
@@ -9,7 +9,11 @@
   "peerDependencies": {
     "vm2": "^3.9.13"
   },
+  "scripts": {
+    "test": "jest --testPathIgnorePatterns test.js"
+  },
   "dependencies": {
+    "@usebruno/query": "0.1.0",
     "atob": "^2.1.2",
     "ajv": "^8.12.0",
     "btoa": "^1.2.1",
@@ -20,4 +24,4 @@
     "nanoid": "3.3.4",
     "uuid": "^9.0.0"
   }
-}
+}

package/src/runtime/assert-runtime.js

@@ -1,6 +1,5 @@
 const _ = require('lodash');
 const chai = require('chai');  
-const { nanoid } = require('nanoid');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const { evaluateJsExpression, createResponseParser } = require('../utils');
@@ -40,7 +39,7 @@ const { expect } = chai;
  * isBoolean   : is boolean
  */
 const parseAssertionOperator = (str = '') => {
-  if(!str || typeof str !== 'string' || str.length) {
+  if(!str || typeof str !== 'string' || !str.length) {
     return {
       operator: 'eq',
       value: str

package/src/utils.js

@@ -1,25 +1,85 @@
 const jsonQuery = require('json-query');
+const { get } = require("@usebruno/query");
+
+const JS_KEYWORDS = `
+  break case catch class const continue debugger default delete do
+  else export extends false finally for function if import in instanceof
+  new null return super switch this throw true try typeof var void while with
+  undefined let static yield arguments of
+`.split(/\s+/).filter(word => word.length > 0);
+
+/**
+ * Creates a function from a Javascript expression
+ * 
+ * When the function is called, the variables used in this expression are picked up from the context
+ * 
+ * ```js
+ * res.data.pets.map(pet => pet.name.toUpperCase())
+ * 
+ * function(context) {
+ *   const { res, pet } = context;
+ *   return res.data.pets.map(pet => pet.name.toUpperCase())
+ * }
+ * ```
+ */
+const compileJsExpression = (expr) => {
+  // get all dotted identifiers (foo, bar.baz, .baz)
+  const matches = expr.match(/([\w\.$]+)/g) ?? [];
+
+  // get valid js identifiers (foo, bar)
+  const vars = new Set(
+    matches
+      .filter(match => /^[a-zA-Z$_]/.test(match))   // starts with valid js identifier (foo.bar)
+      .map(match => match.split('.')[0])            // top level identifier (foo)
+      .filter(name => !JS_KEYWORDS.includes(name))  // exclude js keywords
+  );
+
+  // globals such as Math
+  const globals = [...vars].filter(name => name in globalThis);
+
+  const code = {
+    vars: [...vars].join(", "),
+    // pick global from context or globalThis
+    globals: globals
+      .map(name => ` ${name} = ${name} ?? globalThis.${name};`)
+      .join('')
+  };
+
+  const body = `let { ${code.vars} } = context; ${code.globals}; return ${expr}`;
+
+  return new Function("context", body);
+};
+
+const internalExpressionCache = new Map();
 
 const evaluateJsExpression = (expression, context) => {
-  const fn = new Function(...Object.keys(context), `return ${expression}`);
-  return fn(...Object.values(context));
+  let fn = internalExpressionCache.get(expression);
+  if (fn == null) {
+    internalExpressionCache.set(expression, fn = compileJsExpression(expression));
+  }
+  return fn(context);
 };
 
 const createResponseParser = (response = {}) => {
-  const res = (expr)  => {
-    const output = jsonQuery(expr, { data: response.data });
-    return output ? output.value : null;
-  }
+  const res = (expr, ...fns) => {
+    return get(response.data, expr, ...fns);
+  };
 
   res.status = response.status;
   res.statusText = response.statusText;
   res.headers = response.headers;
   res.body = response.data;
 
+  res.jq = (expr) => {
+    const output = jsonQuery(expr, { data: response.data });
+    return output ? output.value : null;
+  };
+
   return res;
 };
 
 module.exports = {
   evaluateJsExpression,
-  createResponseParser
+  createResponseParser,
+  internalExpressionCache
 };