@fincity/kirun-js 1.1.7 → 1.3.1

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -8,6 +8,7 @@ import { Expression } from './Expression';
 import { ExpressionToken } from './ExpressionToken';
 import { ExpressionTokenValue } from './ExpressionTokenValue';
 import { Operation } from './Operation';
+import { LogicalNullishCoalescingOperator } from './operators/binary/LogicalNullishCoalescingOperator';
 import { ArithmeticAdditionOperator } from './operators/binary/ArithmeticAdditionOperator';
 import { ArithmeticDivisionOperator } from './operators/binary/ArithmeticDivisionOperator';
 import { ArithmeticIntegerDivisionOperator } from './operators/binary/ArithmeticInetgerDivisionOperator';
@@ -38,6 +39,7 @@ import { LogicalNotOperator } from './operators/unary/LogicalNotOperator';
 import { UnaryOperator } from './operators/unary/UnaryOperator';
 import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
 import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
+import { Tuple2 } from '../../util/Tuples';
 
 export class ExpressionEvaluator {
     private static readonly UNARY_OPERATORS_MAP: Map<Operation, UnaryOperator> = new Map([
@@ -70,6 +72,7 @@ export class ExpressionEvaluator {
         [Operation.LESS_THAN_EQUAL, new LogicalLessThanEqualOperator()],
         [Operation.OR, new LogicalOrOperator()],
         [Operation.NOT_EQUAL, new LogicalNotEqualOperator()],
+        [Operation.NULLISH_COALESCING_OPERATOR, new LogicalNullishCoalescingOperator()],
 
         [Operation.ARRAY_OPERATOR, new ArrayOperator()],
         [Operation.OBJECT_OPERATOR, new ObjectOperator()],
@@ -92,10 +95,79 @@ export class ExpressionEvaluator {
     }
 
     public evaluate(valuesMap: Map<string, TokenValueExtractor>): any {
-        if (!this.exp) this.exp = new Expression(this.expression);
+        const tuple: Tuple2<string, Expression> = this.processNestingExpression(
+            this.expression,
+            valuesMap,
+        );
+        this.expression = tuple.getT1();
+        this.exp = tuple.getT2();
+
         return this.evaluateExpression(this.exp, valuesMap);
     }
 
+    private processNestingExpression(
+        expression: string,
+        valuesMap: Map<string, TokenValueExtractor>,
+    ): Tuple2<string, Expression> {
+        let start = 0;
+        let i = 0;
+
+        const tuples: LinkedList<Tuple2<number, number>> = new LinkedList();
+
+        while (i < expression.length - 1) {
+            if (expression.charAt(i) == '{' && expression.charAt(i + 1) == '{') {
+                if (start == 0) tuples.push(new Tuple2(i + 2, -1));
+
+                start++;
+                i++;
+            } else if (expression.charAt(i) == '}' && expression.charAt(i + 1) == '}') {
+                start--;
+
+                if (start < 0)
+                    throw new ExpressionEvaluationException(
+                        expression,
+                        'Expecting {{ nesting path operator to be started before closing',
+                    );
+
+                if (start == 0) {
+                    tuples.push(tuples.pop().setT2(i));
+                }
+                i++;
+            }
+            i++;
+        }
+
+        let newExpression = this.replaceNestingExpression(expression, valuesMap, tuples);
+
+        return new Tuple2(newExpression, new Expression(newExpression));
+    }
+
+    private replaceNestingExpression(
+        expression: string,
+        valuesMap: Map<string, TokenValueExtractor>,
+        tuples: LinkedList<Tuple2<number, number>>,
+    ): string {
+        let newExpression = expression;
+
+        for (var tuple of tuples.toArray()) {
+            if (tuple.getT2() == -1)
+                throw new ExpressionEvaluationException(
+                    expression,
+                    'Expecting }} nesting path operator to be closed',
+                );
+
+            let expStr: string = new ExpressionEvaluator(
+                newExpression.substring(tuple.getT1(), tuple.getT2()),
+            ).evaluate(valuesMap);
+
+            newExpression =
+                newExpression.substring(0, tuple.getT1() - 2) +
+                expStr +
+                newExpression.substring(tuple.getT2() + 2);
+        }
+        return newExpression;
+    }
+
     public getExpression(): Expression {
         if (!this.exp) this.exp = new Expression(this.expression);
 
@@ -161,8 +233,7 @@ export class ExpressionEvaluator {
         const objTokens: LinkedList<ExpressionToken> = new LinkedList();
         const objOperations: LinkedList<Operation> = new LinkedList();
 
-        if (!operator || !token)
-            return;
+        if (!operator || !token) return;
 
         do {
             objOperations.push(operator);
@@ -173,8 +244,7 @@ export class ExpressionEvaluator {
                         this.evaluateExpression(token as Expression, valuesMap),
                     ),
                 );
-            else if (token)
-                objTokens.push(token);
+            else if (token) objTokens.push(token);
             token = tokens.isEmpty() ? undefined : tokens.pop();
             operator = ops.isEmpty() ? undefined : ops.pop();
         } while (operator == Operation.OBJECT_OPERATOR || operator == Operation.ARRAY_OPERATOR);
@@ -229,7 +299,13 @@ export class ExpressionEvaluator {
         let typv1: string = typeof v1;
         let typv2: string = typeof v2;
 
-        if (typv1 === 'object' || typv2 === 'object' || Array.isArray(v1) || Array.isArray(v2))
+        let op: BinaryOperator | undefined = ExpressionEvaluator.BINARY_OPERATORS_MAP.get(operator);
+
+        if (
+            (typv1 === 'object' || typv2 === 'object') &&
+            operator !== Operation.EQUAL &&
+            operator !== Operation.NOT_EQUAL
+        )
             throw new ExpressionEvaluationException(
                 this.expression,
                 StringFormatter.format(
@@ -240,8 +316,6 @@ export class ExpressionEvaluator {
                 ),
             );
 
-        let op: BinaryOperator | undefined = ExpressionEvaluator.BINARY_OPERATORS_MAP.get(operator);
-
         if (!op)
             throw new ExpressionEvaluationException(
                 this.expression,

package/src/engine/runtime/expression/Operation.ts

@@ -32,6 +32,8 @@ export class Operation {
     public static readonly ARRAY_OPERATOR: Operation = new Operation('[');
     public static readonly OBJECT_OPERATOR: Operation = new Operation('.');
 
+    public static readonly NULLISH_COALESCING_OPERATOR: Operation = new Operation('??');
+
     private static readonly VALUE_OF: Map<string, Operation> = new Map([
         ['MULTIPLICATION', Operation.MULTIPLICATION],
         ['DIVISION', Operation.DIVISION],
@@ -61,6 +63,7 @@ export class Operation {
         ['UNARY_BITWISE_COMPLEMENT', Operation.UNARY_BITWISE_COMPLEMENT],
         ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
         ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
+        ['NULLISH_COALESCING_OPERATOR', Operation.NULLISH_COALESCING_OPERATOR],
     ]);
 
     public static readonly UNARY_OPERATORS: Set<Operation> = new Set([
@@ -93,6 +96,7 @@ export class Operation {
         Operation.GREATER_THAN_EQUAL,
         Operation.EQUAL,
         Operation.NOT_EQUAL,
+        Operation.NULLISH_COALESCING_OPERATOR,
     ]);
 
     public static readonly BITWISE_OPERATORS: Set<Operation> = new Set([
@@ -132,6 +136,7 @@ export class Operation {
         [Operation.BITWISE_OR, 9],
         [Operation.AND, 10],
         [Operation.OR, 11],
+        [Operation.NULLISH_COALESCING_OPERATOR, 11],
     ]);
 
     public static readonly OPERATORS: Set<string> = new Set(

package/src/engine/runtime/expression/operators/binary/LogicalEqualOperator.ts

@@ -1,13 +1,8 @@
-import { SchemaType } from '../../../../json/schema/type/SchemaType';
-import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
-import { Tuple2 } from '../../../../util/Tuples';
+import { deepEqual } from '../../../../util/deepEqual';
 import { BinaryOperator } from './BinaryOperator';
 
 export class LogicalEqualOperator extends BinaryOperator {
     public apply(t: any, u: any): any {
-        const tType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNullAsBoolean(t);
-        const uType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNullAsBoolean(u);
-
-        return tType.getT2() == uType.getT2();
+        return deepEqual(t, u);
     }
 }

package/src/engine/runtime/expression/operators/binary/LogicalNotEqualOperator.ts

@@ -1,13 +1,8 @@
-import { SchemaType } from '../../../../json/schema/type/SchemaType';
-import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
-import { Tuple2 } from '../../../../util/Tuples';
+import { deepEqual } from '../../../../util/deepEqual';
 import { BinaryOperator } from './BinaryOperator';
 
 export class LogicalNotEqualOperator extends BinaryOperator {
     public apply(t: any, u: any): any {
-        const tType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNullAsBoolean(t);
-        const uType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNullAsBoolean(u);
-
-        return tType.getT2() != uType.getT2();
+        return !deepEqual(t, u);
     }
 }

package/src/engine/runtime/expression/operators/binary/LogicalNullishCoalescingOperator.ts

@@ -0,0 +1,8 @@
+import { isNullValue } from '../../../../util/NullCheck';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalNullishCoalescingOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        return isNullValue(t) ? u : t;
+    }
+}

package/src/engine/runtime/expression/operators/binary/index.ts

@@ -21,3 +21,4 @@ export * from './LogicalNotEqualOperator';
 export * from './LogicalLessThanOperator';
 export * from './LogicalOrOperator';
 export * from './ObjectOperator';
+export * from './LogicalNullishCoalescingOperator';

package/src/engine/util/MapUtil.ts

@@ -72,6 +72,16 @@ export class MapUtil {
         return map;
     }
 
+    public static ofEntriesArray<K, V>(...entry: [K, V][]): Map<K, V> {
+        const map: Map<K, V> = new Map();
+
+        for (let i = 0; i < entry.length; i++) {
+            map.set(entry[i][0], entry[i][1]);
+        }
+
+        return map;
+    }
+
     private constructor() {}
 }
 

package/src/engine/util/Tuples.ts

@@ -1,6 +1,6 @@
 export class Tuple2<F, S> {
-    private f: F;
-    private s: S;
+    protected f: F;
+    protected s: S;
 
     constructor(f: F, s: S) {
         this.f = f;
@@ -14,10 +14,20 @@ export class Tuple2<F, S> {
     public getT2(): S {
         return this.s;
     }
+
+    public setT1(f: F): Tuple2<F, S> {
+        this.f = f;
+        return this;
+    }
+
+    public setT2(s: S): Tuple2<F, S> {
+        this.s = s;
+        return this;
+    }
 }
 
 export class Tuple3<F, S, T> extends Tuple2<F, S> {
-    private t: T;
+    protected t: T;
 
     constructor(f: F, s: S, t: T) {
         super(f, s);
@@ -27,10 +37,25 @@ export class Tuple3<F, S, T> extends Tuple2<F, S> {
     public getT3(): T {
         return this.t;
     }
+
+    public setT1(f: F): Tuple3<F, S, T> {
+        this.f = f;
+        return this;
+    }
+
+    public setT2(s: S): Tuple3<F, S, T> {
+        this.s = s;
+        return this;
+    }
+
+    public setT3(t: T): Tuple3<F, S, T> {
+        this.t = t;
+        return this;
+    }
 }
 
 export class Tuple4<F, S, T, FR> extends Tuple3<F, S, T> {
-    private fr: FR;
+    protected fr: FR;
 
     constructor(f: F, s: S, t: T, fr: FR) {
         super(f, s, t);
@@ -40,4 +65,24 @@ export class Tuple4<F, S, T, FR> extends Tuple3<F, S, T> {
     public getT4(): FR {
         return this.fr;
     }
+
+    public setT1(f: F): Tuple4<F, S, T, FR> {
+        this.f = f;
+        return this;
+    }
+
+    public setT2(s: S): Tuple4<F, S, T, FR> {
+        this.s = s;
+        return this;
+    }
+
+    public setT3(t: T): Tuple4<F, S, T, FR> {
+        this.t = t;
+        return this;
+    }
+
+    public setT4(fr: FR): Tuple4<F, S, T, FR> {
+        this.fr = fr;
+        return this;
+    }
 }

package/src/engine/util/deepEqual.ts

@@ -0,0 +1,49 @@
+import { LinkedList } from './LinkedList';
+
+export function deepEqual(x: any, y: any) {
+    let xa = new LinkedList();
+    xa.push(x);
+    let yb = new LinkedList();
+    yb.push(y);
+
+    while (!xa.isEmpty() && !yb.isEmpty()) {
+        const a: any = xa.pop();
+        const b: any = yb.pop();
+
+        if (a === b) continue;
+
+        const typeOfA = typeof a;
+        const typeOfB = typeof b;
+
+        if (typeOfA === 'undefined' || typeOfB === 'undefined') {
+            if (!a && !b) continue;
+            return false;
+        }
+
+        if (typeOfA !== typeOfB) return false;
+
+        if (Array.isArray(a)) {
+            if (!Array.isArray(b) || a.length != b.length) return false;
+            for (let i = 0; i < a.length; i++) {
+                xa.push(a[i]);
+                yb.push(b[i]);
+            }
+            continue;
+        }
+
+        if (typeOfA === 'object') {
+            const entriesOfA = Object.entries(a);
+            const entriesOfB = Object.entries(b);
+            if (entriesOfA.length !== entriesOfB.length) return false;
+            for (const [k, v] of entriesOfA) {
+                xa.push(v);
+                yb.push(b[k]);
+            }
+
+            continue;
+        }
+        return false;
+    }
+
+    return true;
+}

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './engine/util/string/StringFormatter';
 export * from './engine/util/string/StringUtil';
 export * from './engine/util/Tuples';
 export * from './engine/util/ArrayUtil';
+export * from './engine/util/deepEqual';
 export * from './engine/runtime/StatementExecution';
 export * from './engine/runtime/StatementMessage';
 export * from './engine/runtime/ContextElement';