@fincity/kirun-js 2.15.1 → 2.16.1

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -7,6 +7,34 @@ import { ExpressionEvaluationException } from '../exception/ExpressionEvaluation
 export abstract class TokenValueExtractor {
     public static readonly REGEX_SQUARE_BRACKETS: RegExp = /[\[\]]/;
     public static readonly REGEX_DOT: RegExp = /(?<!\.)\.(?!\.)/;
+    
+    // Cache for parsed paths to avoid repeated regex splits
+    private static pathCache: Map<string, string[]> = new Map();
+    
+    // Cache for parsed bracket segments to avoid repeated regex splits
+    private static bracketCache: Map<string, string[]> = new Map();
+    
+    protected static splitPath(token: string): string[] {
+        let parts = TokenValueExtractor.pathCache.get(token);
+        if (!parts) {
+            parts = token.split(TokenValueExtractor.REGEX_DOT);
+            TokenValueExtractor.pathCache.set(token, parts);
+        }
+        return parts;
+    }
+    
+    // Parse bracket segments with caching
+    private static parseBracketSegment(segment: string): string[] {
+        let cached = TokenValueExtractor.bracketCache.get(segment);
+        if (!cached) {
+            cached = segment
+                .split(TokenValueExtractor.REGEX_SQUARE_BRACKETS)
+                .map((e) => e.trim())
+                .filter((e) => !StringUtil.isNullOrBlank(e));
+            TokenValueExtractor.bracketCache.set(segment, cached);
+        }
+        return cached;
+    }
 
     public getValue(token: string): any {
         let prefix: string = this.getPrefix();
@@ -28,10 +56,12 @@ export abstract class TokenValueExtractor {
                     parentPart.lastIndexOf('[') + 1,
                     parentPart.length - 1,
                 );
-                const indexInt = parseInt(indexString);
+                const indexInt = Number.parseInt(indexString);
                 if (isNaN(indexInt)) return indexString;
                 return indexInt;
-            } else return parentPart.substring(parentPart.lastIndexOf('.') + 1);
+            } else {
+                return parentPart.substring(parentPart.lastIndexOf('.') + 1);
+            }
         }
 
         return this.getValueInternal(token);
@@ -40,24 +70,76 @@ export abstract class TokenValueExtractor {
     protected retrieveElementFrom(
         token: string,
         parts: string[],
-        partNumber: number,
+        startPart: number,
         jsonElement: any,
     ): any {
-        if (isNullValue(jsonElement)) return undefined;
-
-        if (parts.length == partNumber) return jsonElement;
-
-        let bElement: any = parts[partNumber]
-            .split(TokenValueExtractor.REGEX_SQUARE_BRACKETS)
-            .map((e) => e.trim())
-            .filter((e) => !StringUtil.isNullOrBlank(e))
-            .reduce(
-                (a, c) =>
-                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a),
-                jsonElement,
-            );
-
-        return this.retrieveElementFrom(token, parts, partNumber + 1, bElement);
+        // Iterative version - avoids recursive call overhead
+        let current = jsonElement;
+        
+        for (let partNumber = startPart; partNumber < parts.length; partNumber++) {
+            if (isNullValue(current)) return undefined;
+            
+            // Use cached bracket segment parsing
+            const segments = TokenValueExtractor.parseBracketSegment(parts[partNumber]);
+            
+            for (const segment of segments) {
+                current = this.resolveSegmentFast(token, parts, partNumber, segment, current);
+                if (current === undefined) return undefined;
+            }
+        }
+        
+        return current;
+    }
+    
+    // Fast path for common cases - inline to avoid function call overhead
+    private resolveSegmentFast(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        segment: string,
+        element: any,
+    ): any {
+        if (element === null || element === undefined) return undefined;
+        
+        // Fast path: simple property access on object (most common case)
+        if (typeof element === 'object' && !Array.isArray(element)) {
+            if (segment in element) {
+                return element[segment];
+            }
+            // Check for 'length' on object
+            if (segment === 'length') {
+                return Object.keys(element).length;
+            }
+            return element[segment];
+        }
+        
+        // Fast path: array index access
+        if (Array.isArray(element)) {
+            // Check for 'length' first
+            if (segment === 'length') return element.length;
+            
+            // Only use fast path for pure integer strings (no range operators like '..')
+            // Note: parseInt('2..4', 10) incorrectly returns 2, so we need to validate first
+            if (/^-?\d+$/.test(segment)) {
+                const idx = Number.parseInt(segment, 10);
+                const actualIdx = idx < 0 ? element.length + idx : idx;
+                return actualIdx >= 0 && actualIdx < element.length ? element[actualIdx] : undefined;
+            }
+        }
+        
+        // Fast path: string access
+        if (typeof element === 'string') {
+            if (segment === 'length') return element.length;
+            // Only use fast path for pure integer strings
+            if (/^-?\d+$/.test(segment)) {
+                const idx = Number.parseInt(segment, 10);
+                const actualIdx = idx < 0 ? element.length + idx : idx;
+                return actualIdx >= 0 && actualIdx < element.length ? element[actualIdx] : undefined;
+            }
+        }
+        
+        // Fall back to full handling for edge cases (range operator, etc.)
+        return this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, segment, element);
     }
 
     protected resolveForEachPartOfTokenWithBrackets(

package/src/engine/runtime/graph/ExecutionGraph.ts

@@ -5,11 +5,20 @@ import { GraphVertexType } from './GraphVertexType';
 export class ExecutionGraph<K, T extends GraphVertexType<K>> {
     private nodeMap: Map<K, GraphVertex<K, T>> = new Map();
     private isSubGrph: boolean;
+    private edgesBuilt: boolean = false;
 
     public constructor(isSubGrph: boolean = false) {
         this.isSubGrph = isSubGrph;
     }
 
+    public areEdgesBuilt(): boolean {
+        return this.edgesBuilt;
+    }
+
+    public setEdgesBuilt(built: boolean): void {
+        this.edgesBuilt = built;
+    }
+
     public getVerticesData(): T[] {
         return Array.from(this.nodeMap.values()).map((e) => e.getData());
     }

package/src/engine/runtime/graph/GraphVertex.ts

@@ -8,6 +8,7 @@ export class GraphVertex<K, T extends GraphVertexType<K>> {
     private outVertices: Map<string, Set<GraphVertex<K, T>>> = new Map();
     private inVertices: Set<Tuple2<GraphVertex<K, T>, string>> = new Set();
     private graph: ExecutionGraph<K, T>;
+    private subGraphCache: Map<string, ExecutionGraph<K, T>> = new Map();
 
     public constructor(graph: ExecutionGraph<K, T>, data: T) {
         this.data = data;
@@ -78,6 +79,12 @@ export class GraphVertex<K, T extends GraphVertexType<K>> {
     }
 
     public getSubGraphOfType(type: string): ExecutionGraph<K, T> {
+        // Check cache first
+        const cached = this.subGraphCache.get(type);
+        if (cached) {
+            return cached;
+        }
+
         let subGraph: ExecutionGraph<K, T> = new ExecutionGraph(true);
 
         var typeVertices = new LinkedList(Array.from(this.outVertices.get(type) ?? []));
@@ -94,6 +101,8 @@ export class GraphVertex<K, T extends GraphVertexType<K>> {
                 });
         }
 
+        // Cache for reuse
+        this.subGraphCache.set(type, subGraph);
         return subGraph;
     }
 

package/src/engine/runtime/tokenextractor/ArgumentsTokenValueExtractor.ts

@@ -12,13 +12,14 @@ export class ArgumentsTokenValueExtractor extends TokenValueExtractor {
     }
 
     protected getValueInternal(token: string): any {
-        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+        let parts: string[] = TokenValueExtractor.splitPath(token);
 
         let key: string = parts[1];
         let bIndex: number = key.indexOf('[');
         let fromIndex = 2;
         if (bIndex != -1) {
             key = parts[1].substring(0, bIndex);
+            parts = [...parts]; // Copy since we're modifying
             parts[1] = parts[1].substring(bIndex);
             fromIndex = 1;
         }

package/src/engine/runtime/tokenextractor/ContextTokenValueExtractor.ts

@@ -13,13 +13,14 @@ export class ContextTokenValueExtractor extends TokenValueExtractor {
     }
 
     protected getValueInternal(token: string): any {
-        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+        let parts: string[] = TokenValueExtractor.splitPath(token);
 
         let key: string = parts[1];
         let bIndex: number = key.indexOf('[');
         let fromIndex = 2;
         if (bIndex != -1) {
             key = parts[1].substring(0, bIndex);
+            parts = [...parts]; // Copy since we're modifying
             parts[1] = parts[1].substring(bIndex);
             fromIndex = 1;
         }

package/src/engine/runtime/tokenextractor/OutputMapTokenValueExtractor.ts

@@ -11,7 +11,7 @@ export class OutputMapTokenValueExtractor extends TokenValueExtractor {
     }
 
     protected getValueInternal(token: string): any {
-        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+        let parts: string[] = TokenValueExtractor.splitPath(token);
 
         let ind: number = 1;