@openmrs/esm-expression-evaluator 11.0.1-pre.5771 → 11.0.1-pre.5776

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 5 files with swc (208.86ms)
+[0] Successfully compiled: 5 files with swc (225.5ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/extractor.js

@@ -81,58 +81,39 @@ function visitExpression(expression, context) {
     }
 }
 function visitUnaryExpression(expression, context) {
-    return visitExpression(expression.argument, context);
+    visitExpression(expression.argument, context);
 }
 function visitBinaryExpression(expression, context) {
-    const left = visitExpression(expression.left, context);
-    const right = visitExpression(expression.right, context);
-    return [
-        left,
-        right
-    ].filter(Boolean);
+    visitExpression(expression.left, context);
+    visitExpression(expression.right, context);
 }
 function visitConditionalExpression(expression, context) {
-    const consequent = visitExpression(expression.consequent, context);
-    const test = visitExpression(expression.test, context);
-    const alternate = visitExpression(expression.alternate, context);
-    return [
-        consequent,
-        test,
-        alternate
-    ].filter(Boolean);
+    visitExpression(expression.consequent, context);
+    visitExpression(expression.test, context);
+    visitExpression(expression.alternate, context);
 }
 function visitCallExpression(expression, context) {
-    const fn = visitExpression(expression.callee, context);
+    visitExpression(expression.callee, context);
     expression.arguments?.map(handleNullableExpression(context));
-    return fn;
 }
 function visitArrowFunctionExpression(expression, context) {
-    const newContext = {
-        ...context
-    };
-    newContext.isLocalExpression = true;
-    const params = expression.params?.map(handleNullableExpression(newContext)) ?? [];
-    const bodyVariables = visitExpression(expression.body, newContext) ?? [];
-    if (bodyVariables && Array.isArray(bodyVariables)) {
-        for (const v of bodyVariables){
-            if (!params.includes(v)) {
-                context.variables.add(v);
-            }
+    const boundNames = new Set(context.boundNames);
+    for (const param of expression.params ?? []){
+        if (param?.type === 'Identifier') {
+            boundNames.add(param.name);
         }
     }
+    visitExpression(expression.body, {
+        ...context,
+        boundNames
+    });
 }
 function visitMemberExpression(expression, context) {
     visitExpression(expression.object, context);
     // the `b` of `a[b]` is a variable the caller has to supply, whereas the `b` of `a.b` is a property name
     if (expression.computed) {
         visitExpression(expression.property, context);
-        return;
     }
-    const newContext = {
-        ...context
-    };
-    newContext.isLocalExpression = true;
-    visitExpression(expression.property, newContext);
 }
 function visitArrayExpression(expression, context) {
     expression.elements?.map(handleNullableExpression(context));
@@ -149,12 +130,8 @@ function visitTemplateLiteral(expression, context) {
 }
 function visitTemplateElement(expression, context) {}
 function visitIdentifier(expression, context) {
-    if (!(expression.name in context.globals)) {
-        if (!context.isLocalExpression) {
-            context.variables.add(expression.name);
-        } else {
-            return expression.name;
-        }
+    if (!(expression.name in context.globals) && !context.boundNames.has(expression.name)) {
+        context.variables.add(expression.name);
     }
 }
 function visitLiteral(expression, context) {}
@@ -166,7 +143,7 @@ function createContextInternal(globals_) {
         globals: {
             ...globals_
         },
-        isLocalExpression: false,
+        boundNames: new Set(),
         variables: new Set()
     };
     return context;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-expression-evaluator",
-  "version": "11.0.1-pre.5771",
+  "version": "11.0.1-pre.5776",
   "license": "MPL-2.0",
   "description": "Utilities for evaluating user-defined expressions",
   "type": "module",
@@ -44,7 +44,7 @@
     "url": "git+https://github.com/openmrs/openmrs-esm-core.git"
   },
   "bugs": {
-    "url": "https://github.com/openmrs/openmrs-esm-core/issues"
+    "url": "https://openmrs.atlassian.net/jira/software/c/projects/O3/boards/37"
   },
   "homepage": "https://github.com/openmrs/openmrs-esm-core#readme",
   "publishConfig": {

package/src/evaluator.test.ts

@@ -51,6 +51,15 @@ describe('OpenMRS Expression Evaluator', () => {
     expect(evaluate('a.includes("v")', { a: 'value' })).toBe(true);
     expect(evaluate('"value".includes("v")')).toBe(true);
     expect(evaluate('(3.14159).toPrecision(3)')).toBe('3.14');
+    expect(evaluate('s.toUpperCase()', { s: 'active' })).toBe('ACTIVE');
+    expect(evaluate('n.toFixed(1)', { n: 3.14159 })).toBe('3.1');
+  });
+
+  it('should read properties of strings from the string itself', () => {
+    expect(evaluate('s.length', { s: 'active' })).toBe(6);
+    expect(evaluate('"active".length')).toBe(6);
+    expect(evaluate('s.length', { s: 'active' })).toBe(evaluate('s["length"]', { s: 'active' }));
+    expect(evaluate('s[0]', { s: 'active' })).toBe('a');
   });
 
   it('should give a useful error message for properties on missing objects', () => {

package/src/extractor.test.ts

@@ -47,6 +47,26 @@ describe('OpenMRS Expression Extractor', () => {
     expect(extractVariableNames('[1, 2, 3].find(v => v === a)')).toEqual(['a']);
   });
 
+  it('extracts unbound variables from any kind of arrow function body', () => {
+    expect(extractVariableNames('a.map(x => f(b))')).toEqual(['a', 'f', 'b']);
+    expect(extractVariableNames('a.map(x => !b)')).toEqual(['a', 'b']);
+    expect(extractVariableNames('a.map(x => b.c)')).toEqual(['a', 'b']);
+    expect(extractVariableNames('a.map(x => x + b)')).toEqual(['a', 'b']);
+    expect(extractVariableNames('a.map(x => x ? b : c)')).toEqual(['a', 'b', 'c']);
+    expect(extractVariableNames('a.then(v => !isEmpty(b) ? v + 3 : v)')).toEqual(['a', 'isEmpty', 'b']);
+  });
+
+  it('excludes arrow function parameters, including from nested arrow functions', () => {
+    expect(extractVariableNames('a.map(x => x.y)')).toEqual(['a']);
+    expect(extractVariableNames('a.reduce((acc, x) => acc + x, 0)')).toEqual(['a']);
+    expect(extractVariableNames('a.map(x => x.items.filter(y => y === x || y === b))')).toEqual(['a', 'b']);
+    expect(extractVariableNames('a.map(x => f(y => y + x + z))')).toEqual(['a', 'f', 'z']);
+  });
+
+  it('only binds arrow function parameters within the arrow function body', () => {
+    expect(extractVariableNames('a.map(x => x) + x')).toEqual(['a', 'x']);
+  });
+
   it('supports real-world use-cases', () => {
     expect(extractVariableNames('!isEmpty(array)')).toEqual(['isEmpty', 'array']);
 

package/src/extractor.ts

@@ -89,42 +89,34 @@ function visitExpression(expression: jsep.Expression, context: EvaluationContext
 }
 
 function visitUnaryExpression(expression: jsep.UnaryExpression, context: EvaluationContext) {
-  return visitExpression(expression.argument, context);
+  visitExpression(expression.argument, context);
 }
 
 function visitBinaryExpression(expression: jsep.BinaryExpression, context: EvaluationContext) {
-  const left = visitExpression(expression.left, context);
-  const right = visitExpression(expression.right, context);
-  return [left, right].filter(Boolean);
+  visitExpression(expression.left, context);
+  visitExpression(expression.right, context);
 }
 
 function visitConditionalExpression(expression: jsep.ConditionalExpression, context: EvaluationContext) {
-  const consequent = visitExpression(expression.consequent, context);
-  const test = visitExpression(expression.test, context);
-  const alternate = visitExpression(expression.alternate, context);
-  return [consequent, test, alternate].filter(Boolean);
+  visitExpression(expression.consequent, context);
+  visitExpression(expression.test, context);
+  visitExpression(expression.alternate, context);
 }
 
 function visitCallExpression(expression: jsep.CallExpression, context: EvaluationContext) {
-  const fn = visitExpression(expression.callee, context);
+  visitExpression(expression.callee, context);
   expression.arguments?.map(handleNullableExpression(context));
-  return fn;
 }
 
 function visitArrowFunctionExpression(expression: ArrowExpression, context: EvaluationContext) {
-  const newContext = { ...context };
-  newContext.isLocalExpression = true;
-
-  const params = expression.params?.map(handleNullableExpression(newContext)) ?? [];
-  const bodyVariables = visitExpression(expression.body, newContext) ?? [];
-
-  if (bodyVariables && Array.isArray(bodyVariables)) {
-    for (const v of bodyVariables) {
-      if (!params.includes(v)) {
-        context.variables.add(v);
-      }
+  const boundNames = new Set(context.boundNames);
+  for (const param of expression.params ?? []) {
+    if (param?.type === 'Identifier') {
+      boundNames.add((param as jsep.Identifier).name);
     }
   }
+
+  visitExpression(expression.body, { ...context, boundNames });
 }
 
 function visitMemberExpression(expression: jsep.MemberExpression, context: EvaluationContext) {
@@ -133,12 +125,7 @@ function visitMemberExpression(expression: jsep.MemberExpression, context: Evalu
   // the `b` of `a[b]` is a variable the caller has to supply, whereas the `b` of `a.b` is a property name
   if (expression.computed) {
     visitExpression(expression.property, context);
-    return;
   }
-
-  const newContext = { ...context };
-  newContext.isLocalExpression = true;
-  visitExpression(expression.property, newContext);
 }
 
 function visitArrayExpression(expression: jsep.ArrayExpression, context: EvaluationContext) {
@@ -161,12 +148,8 @@ function visitTemplateLiteral(expression: TemplateLiteral, context: EvaluationCo
 function visitTemplateElement(expression: TemplateElement, context: EvaluationContext) {}
 
 function visitIdentifier(expression: jsep.Identifier, context: EvaluationContext) {
-  if (!(expression.name in context.globals)) {
-    if (!context.isLocalExpression) {
-      context.variables.add(expression.name);
-    } else {
-      return expression.name;
-    }
+  if (!(expression.name in context.globals) && !context.boundNames.has(expression.name)) {
+    context.variables.add(expression.name);
   }
 }
 
@@ -175,7 +158,8 @@ function visitLiteral(expression: jsep.Literal, context: EvaluationContext) {}
 // Internals
 interface EvaluationContext {
   globals: typeof globalsAsync;
-  isLocalExpression: boolean;
+  /** Parameters of the enclosing arrow functions, which the caller does not supply */
+  boundNames: Set<string>;
   variables: Set<string>;
 }
 
@@ -186,7 +170,7 @@ function createAsynchronousContext(): EvaluationContext {
 function createContextInternal(globals_: typeof globalsAsync) {
   const context = {
     globals: { ...globals_ },
-    isLocalExpression: false,
+    boundNames: new Set<string>(),
     variables: new Set<string>(),
   };