@fincity/kirun-js 2.16.2 → 3.0.0

package/src/engine/function/system/context/SetFunction.ts

@@ -10,11 +10,8 @@ import { FunctionSignature } from '../../../model/FunctionSignature';
 import { Parameter } from '../../../model/Parameter';
 import { Namespaces } from '../../../namespaces/Namespaces';
 import { ContextElement } from '../../../runtime/ContextElement';
-import { Expression } from '../../../runtime/expression/Expression';
 import { ExpressionEvaluator } from '../../../runtime/expression/ExpressionEvaluator';
-import { ExpressionToken } from '../../../runtime/expression/ExpressionToken';
-import { ExpressionTokenValue } from '../../../runtime/expression/ExpressionTokenValue';
-import { Operation } from '../../../runtime/expression/Operation';
+import { TokenValueExtractor } from '../../../runtime/expression/tokenextractor/TokenValueExtractor';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
 import { isNullValue } from '../../../util/NullCheck';
 import { StringFormatter } from '../../../util/string/StringFormatter';
@@ -56,110 +53,264 @@ export class SetFunction extends AbstractFunction {
 
         let value: any = context?.getArguments()?.get(VALUE);
 
-        const exp: Expression = new Expression(key);
-
-        const contextToken: ExpressionToken = exp.getTokens().peekLast();
-
-        if (
-            !contextToken.getExpression().startsWith('Context') ||
-            contextToken instanceof Expression ||
-            (contextToken instanceof ExpressionTokenValue &&
-                !(contextToken as ExpressionTokenValue)
-                    .getElement()
-                    .toString()
-                    .startsWith('Context'))
-        ) {
+        // Use TokenValueExtractor.splitPath for consistent path parsing
+        const parts = TokenValueExtractor.splitPath(key);
+        
+        if (parts.length < 1 || parts[0] !== 'Context') {
             throw new ExecutionException(
                 StringFormatter.format('The context path $ is not a valid path in context', key),
             );
         }
 
-        for (const op of exp.getOperations().toArray()) {
-            if (op == Operation.ARRAY_OPERATOR || op == Operation.OBJECT_OPERATOR) continue;
+        // Evaluate any dynamic expressions in the path (e.g., Context.a[Steps.loop.index])
+        const evaluatedParts = this.evaluateDynamicParts(parts, context);
 
-            throw new ExecutionException(
-                StringFormatter.format(
-                    'Expected a reference to the context location, but found an expression $',
-                    key,
-                ),
-            );
+        return this.modifyContextWithParts(context, key, value, evaluatedParts);
+    }
+    
+    /**
+     * Evaluate any dynamic expressions in path parts
+     * E.g., "Context.a[Steps.loop.index]" where the index is dynamic
+     */
+    private evaluateDynamicParts(parts: string[], context: FunctionExecutionParameters): string[] {
+        const result: string[] = [];
+        
+        for (const part of parts) {
+            // Check if this part contains dynamic bracket expressions
+            const evaluated = this.evaluateBracketExpressions(part, context);
+            result.push(evaluated);
         }
-
-        for (let i = 0; i < exp.getTokens().size(); i++) {
-            let ex = exp.getTokens().get(i);
-            if (ex instanceof Expression)
-                exp.getTokens().set(
-                    i,
-                    new ExpressionTokenValue(
-                        key,
-                        new ExpressionEvaluator(ex as Expression).evaluate(context.getValuesMap()),
-                    ),
-                );
+        
+        return result;
+    }
+    
+    /**
+     * Evaluate bracket expressions in a path part
+     * E.g., "arr[Steps.loop.index]" -> "arr[0]" if Steps.loop.index evaluates to 0
+     */
+    private evaluateBracketExpressions(part: string, context: FunctionExecutionParameters): string {
+        // Find bracket expressions that need evaluation
+        let result = '';
+        let i = 0;
+        
+        while (i < part.length) {
+            if (part[i] === '[') {
+                result += '[';
+                i++;
+                
+                // Find the matching ]
+                let bracketContent = '';
+                let depth = 1;
+                let inQuote = false;
+                let quoteChar = '';
+                
+                while (i < part.length && depth > 0) {
+                    const ch = part[i];
+                    
+                    if (inQuote) {
+                        if (ch === quoteChar && part[i - 1] !== '\\') {
+                            inQuote = false;
+                        }
+                        bracketContent += ch;
+                    } else {
+                        if (ch === '"' || ch === "'") {
+                            inQuote = true;
+                            quoteChar = ch;
+                            bracketContent += ch;
+                        } else if (ch === '[') {
+                            depth++;
+                            bracketContent += ch;
+                        } else if (ch === ']') {
+                            depth--;
+                            if (depth > 0) bracketContent += ch;
+                        } else {
+                            bracketContent += ch;
+                        }
+                    }
+                    i++;
+                }
+                
+                // Check if bracket content is a static value (number or quoted string)
+                if (/^-?\d+$/.test(bracketContent) || 
+                    (bracketContent.startsWith('"') && bracketContent.endsWith('"')) ||
+                    (bracketContent.startsWith("'") && bracketContent.endsWith("'"))) {
+                    result += bracketContent + ']';
+                } else {
+                    // Dynamic expression - evaluate it
+                    try {
+                        const evaluator = new ExpressionEvaluator(bracketContent);
+                        const evaluatedValue = evaluator.evaluate(context.getValuesMap());
+                        result += String(evaluatedValue) + ']';
+                    } catch (err) {
+                        // If evaluation fails, keep original
+                        result += bracketContent + ']';
+                    }
+                }
+            } else {
+                result += part[i];
+                i++;
+            }
         }
-        return this.modifyContext(context, key, value, exp);
+        
+        return result;
     }
 
-    private modifyContext(
+    private modifyContextWithParts(
         context: FunctionExecutionParameters,
         key: string,
         value: any,
-        exp: Expression,
+        parts: string[],
     ): FunctionOutput {
-        const tokens = exp.getTokens();
-        tokens.removeLast();
-        const ops = exp.getOperations();
-        ops.removeLast();
-        let ce: ContextElement | undefined = context
-            .getContext()
-            ?.get(tokens.removeLast().getExpression());
+        // parts[0] is "Context", parts[1] is the context element name
+        if (parts.length < 2) {
+            throw new KIRuntimeException(
+                StringFormatter.format("Context path '$' is too short", key),
+            );
+        }
+        
+        // Get the first segment after "Context" - this should be a context element key
+        // The segment may contain bracket notation like "a[0]" which we need to parse
+        const firstSegment = parts[1];
+        const firstSegmentParts = this.parseBracketSegments(firstSegment);
+        const contextKey = firstSegmentParts[0];
+        
+        let ce: ContextElement | undefined = context.getContext()?.get(contextKey);
 
         if (isNullValue(ce)) {
             throw new KIRuntimeException(
-                StringFormatter.format("Context doesn't have any element with name '$' ", key),
+                StringFormatter.format("Context doesn't have any element with name '$' ", contextKey),
             );
         }
 
-        if (ops.isEmpty()) {
+        // If we just have "Context.a" with no further path
+        if (parts.length === 2 && firstSegmentParts.length === 1) {
             ce!.setElement(value);
             return new FunctionOutput([EventResult.outputOf(new Map())]);
         }
 
         let el: any = ce!.getElement();
-
-        let op = ops.removeLast();
-        let token = tokens.removeLast();
-        let mem =
-            token instanceof ExpressionTokenValue
-                ? (token as ExpressionTokenValue).getElement()
-                : token.getExpression();
-
+        
+        // Initialize element if null
         if (isNullValue(el)) {
-            el = op == Operation.OBJECT_OPERATOR ? {} : [];
+            // Determine if first access is array or object
+            const nextIsArray = firstSegmentParts.length > 1 
+                ? this.isArrayIndex(firstSegmentParts[1])
+                : (parts.length > 2 ? this.isArrayAccess(parts[2]) : false);
+            el = nextIsArray ? [] : {};
             ce!.setElement(el);
         }
 
-        while (!ops.isEmpty()) {
-            if (op == Operation.OBJECT_OPERATOR) {
-                el = this.getDataFromObject(el, mem, ops.peekLast());
+        // Collect all path segments (including bracket notation within segments)
+        const allSegments: { value: string; isArray: boolean }[] = [];
+        
+        // Process remaining parts of the first segment (after context key)
+        for (let j = 1; j < firstSegmentParts.length; j++) {
+            allSegments.push({
+                value: this.stripQuotes(firstSegmentParts[j]),
+                isArray: this.isArrayIndex(firstSegmentParts[j])
+            });
+        }
+        
+        // Process remaining parts (parts[2], parts[3], etc.)
+        for (let i = 2; i < parts.length; i++) {
+            const segmentParts = this.parseBracketSegments(parts[i]);
+            for (const seg of segmentParts) {
+                allSegments.push({
+                    value: this.stripQuotes(seg),
+                    isArray: this.isArrayIndex(seg)
+                });
+            }
+        }
+        
+        // Navigate to the parent of the final element
+        for (let i = 0; i < allSegments.length - 1; i++) {
+            const segment = allSegments[i];
+            const nextSegment = allSegments[i + 1];
+            
+            if (segment.isArray) {
+                el = this.getDataFromArray(el, segment.value, nextSegment.isArray);
             } else {
-                el = this.getDataFromArray(el, mem, ops.peekLast());
+                el = this.getDataFromObject(el, segment.value, nextSegment.isArray);
             }
-
-            op = ops.removeLast();
-            token = tokens.removeLast();
-            mem =
-                token instanceof ExpressionTokenValue
-                    ? (token as ExpressionTokenValue).getElement()
-                    : token.getExpression();
         }
-
-        if (op == Operation.OBJECT_OPERATOR) this.putDataInObject(el, mem, value);
-        else this.putDataInArray(el, mem, value);
+        
+        // Set the final value
+        const lastSegment = allSegments[allSegments.length - 1];
+        if (lastSegment.isArray) {
+            this.putDataInArray(el, lastSegment.value, value);
+        } else {
+            this.putDataInObject(el, lastSegment.value, value);
+        }
 
         return new FunctionOutput([EventResult.outputOf(new Map())]);
     }
+    
+    /**
+     * Parse bracket segments from a path part
+     * E.g., "arr[0]" -> ["arr", "0"], "obj" -> ["obj"]
+     */
+    private parseBracketSegments(part: string): string[] {
+        const segments: string[] = [];
+        let start = 0;
+        let i = 0;
+        
+        while (i < part.length) {
+            if (part[i] === '[') {
+                if (i > start) {
+                    segments.push(part.substring(start, i));
+                }
+                // Find matching ]
+                let end = i + 1;
+                let inQuote = false;
+                let quoteChar = '';
+                while (end < part.length) {
+                    if (inQuote) {
+                        if (part[end] === quoteChar && part[end - 1] !== '\\') {
+                            inQuote = false;
+                        }
+                    } else {
+                        if (part[end] === '"' || part[end] === "'") {
+                            inQuote = true;
+                            quoteChar = part[end];
+                        } else if (part[end] === ']') {
+                            break;
+                        }
+                    }
+                    end++;
+                }
+                segments.push(part.substring(i + 1, end));
+                start = end + 1;
+                i = start;
+            } else {
+                i++;
+            }
+        }
+        
+        if (start < part.length) {
+            segments.push(part.substring(start));
+        }
+        
+        return segments.length > 0 ? segments : [part];
+    }
+    
+    private isArrayIndex(segment: string): boolean {
+        return /^-?\d+$/.test(segment);
+    }
+    
+    private isArrayAccess(part: string): boolean {
+        // Check if the part starts with bracket notation or is a pure number
+        return part.startsWith('[') || this.isArrayIndex(part);
+    }
+    
+    private stripQuotes(segment: string): string {
+        if ((segment.startsWith('"') && segment.endsWith('"')) ||
+            (segment.startsWith("'") && segment.endsWith("'"))) {
+            return segment.substring(1, segment.length - 1);
+        }
+        return segment;
+    }
 
-    private getDataFromArray(el: any, mem: string, nextOp: Operation): any {
+    private getDataFromArray(el: any, mem: string, nextIsArray: boolean): any {
         if (!Array.isArray(el))
             throw new KIRuntimeException(
                 StringFormatter.format('Expected an array but found $', el),
@@ -178,13 +329,13 @@ export class SetFunction extends AbstractFunction {
         let je = el[index];
 
         if (isNullValue(je)) {
-            je = nextOp == Operation.OBJECT_OPERATOR ? {} : [];
+            je = nextIsArray ? [] : {};
             el[index] = je;
         }
         return je;
     }
 
-    private getDataFromObject(el: any, mem: string, nextOp: Operation): any {
+    private getDataFromObject(el: any, mem: string, nextIsArray: boolean): any {
         if (Array.isArray(el) || typeof el !== 'object')
             throw new KIRuntimeException(
                 StringFormatter.format('Expected an object but found $', el),
@@ -193,7 +344,7 @@ export class SetFunction extends AbstractFunction {
         let je = el[mem];
 
         if (isNullValue(je)) {
-            je = nextOp == Operation.OBJECT_OPERATOR ? {} : [];
+            je = nextIsArray ? [] : {};
             el[mem] = je;
         }
         return je;