Let expressions learns to use custom registered functions (#32)

* fixed vulnerabilities

* clarified intent for usage of a type

* removed compiler warning

* Let expressions learned to use custom registered functions (#29)

Author: springcomp

package-lock.json

@@ -61,6 +61,7 @@ export interface FunctionTable {
 
 export class Runtime {
   _interpreter: TreeInterpreter;
+  _functionTable: FunctionTable;
   TYPE_NAME_TABLE: { [InputArgument: number]: string } = {
     [InputArgument.TYPE_NUMBER]: 'number',
     [InputArgument.TYPE_ANY]: 'any',
@@ -78,24 +79,25 @@ export class Runtime {
 
   constructor(interpreter: TreeInterpreter) {
     this._interpreter = interpreter;
+    this._functionTable = this.functionTable
   }
 
   registerFunction(
     name: string,
     customFunction: RuntimeFunction<(JSONValue | ExpressionNode)[], JSONValue>,
     signature: InputSignature[],
   ): void {
-    if (name in this.functionTable) {
+    if (name in this._functionTable) {
       throw new Error(`Function already defined: ${name}()`);
     }
-    this.functionTable[name] = {
+    this._functionTable[name] = {
       _func: customFunction.bind(this),
       _signature: signature,
     };
   }
 
   callFunction(name: string, resolvedArgs: (JSONValue | ExpressionNode)[]): JSONValue {
-    const functionEntry = this.functionTable[name];
+    const functionEntry = this._functionTable[name];
     if (functionEntry === undefined) {
       throw new Error(`Unknown function: ${name}()`);
     }
@@ -114,7 +116,7 @@ export class Runtime {
   private validateArgs(name: string, args: (JSONValue | ExpressionNode)[], signature: InputSignature[]): void {
     let pluralized: boolean;
     this.validateInputSignatures(name, signature);
-    const numberOfRequiredArgs = signature.filter(argSignature => !argSignature.optional ?? false).length;
+    const numberOfRequiredArgs = signature.filter(argSignature => !(argSignature.optional ?? false)).length;
     const lastArgIsVariadic = signature[signature.length - 1]?.variadic ?? false;
     const tooFewArgs = args.length < numberOfRequiredArgs;
     const tooManyArgs = args.length > signature.length;

src/Runtime.ts

@@ -19,6 +19,7 @@ export class TreeInterpreter {
 
   withScope(scope: ScopeEntry): TreeInterpreter {
     const interpreter = new TreeInterpreter();
+    interpreter.runtime._functionTable = this.runtime._functionTable;
     interpreter._rootValue = this._rootValue;
     interpreter._scope = this._scope.withScope(scope);
     return interpreter;
@@ -36,7 +37,7 @@ export class TreeInterpreter {
         const identifier = node.name;
         let result: JSONValue = null;
         if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-          result = value[identifier] ?? null;
+          result = (value as JSONObject)[identifier] ?? null;
         }
         return result;
       case 'LetExpression': {

src/TreeInterpreter.ts

@@ -1,4 +1,4 @@
-import { search } from '../src';
+import { search, registerFunction, TYPE_NUMBER } from '../src';
 import { expectError } from './error.utils';
 
 describe('Evaluates functions', () => {
@@ -125,3 +125,17 @@ describe('Type-checks function arguments', () => {
     }, 'invalid-value');
   });
 });
+
+describe('custom functions', () => {
+  it('must be in scope for let expression', () => {
+    registerFunction(
+      'plusplus', // FUNCTION NAME
+      (resolvedArgs) => {   // CUSTOM FUNCTION
+        const [num] = resolvedArgs;
+        return num + 1;
+      },
+      [{ types: [TYPE_NUMBER] }] //SIGNATURE
+    );
+    expect(search({index: 0}, 'let $n = index in plusplus($n)')).toEqual(1);
+  });
+});