@fincity/kirun-js 1.6.17 → 1.7.0

package/src/engine/function/system/array/Fill.ts

@@ -4,6 +4,7 @@ import { FunctionOutput } from '../../../model/FunctionOutput';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../util/MapUtil';
 import { isNullValue } from '../../../util/NullCheck';
+import { duplicate } from '../../../util/duplicate';
 import { StringFormatter } from '../../../util/string/StringFormatter';
 import { AbstractArrayFunction } from './AbstractArrayFunction';
 
@@ -38,14 +39,17 @@ export class Fill extends AbstractArrayFunction {
 
         let add = srcfrom + length - source.length;
 
+        source = [...source];
         if (add > 0) {
             for (let i = 0; i < add; i++) source.push();
         }
 
         for (let i = srcfrom; i < srcfrom + length; i++) {
-            source[i] = isNullValue(element) ? element : JSON.parse(JSON.stringify(element));
+            source[i] = isNullValue(element) ? element : duplicate(element);
         }
 
-        return new FunctionOutput([EventResult.outputOf(MapUtil.of())]);
+        return new FunctionOutput([
+            EventResult.outputOf(MapUtil.of(AbstractArrayFunction.EVENT_RESULT_NAME, source)),
+        ]);
     }
 }

package/src/engine/function/system/array/Frequency.ts

@@ -39,15 +39,12 @@ export class Frequency extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), 0]])),
+                EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_NAME, 0]])),
             ]);
 
         if (start > source.length)
             throw new KIRuntimeException('Given start point is more than the size of source');
 
-        if (isNullValue(find))
-            throw new KIRuntimeException('Given find was null. Hence cannot be found in the array');
-
         let end: number = start + length;
 
         if (length == -1) end = source.length - start;
@@ -62,7 +59,7 @@ export class Frequency extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), frequency]])),
+            EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_NAME, frequency]])),
         ]);
     }
 }

package/src/engine/function/system/array/IndexOf.ts

@@ -32,7 +32,7 @@ export class IndexOf extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (len < 0 || len > source.length)
@@ -50,7 +50,7 @@ export class IndexOf extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

package/src/engine/function/system/array/IndexOfArray.ts

@@ -33,7 +33,7 @@ export class IndexOfArray extends AbstractArrayFunction {
 
         if (source.length == 0 || secondSource.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (from < 0 || from > source.length || source.length < secondSource.length)
@@ -61,7 +61,7 @@ export class IndexOfArray extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

package/src/engine/function/system/array/Insert.ts

@@ -10,7 +10,7 @@ export class Insert extends AbstractArrayFunction {
         super(
             'Insert',
             [Insert.PARAMETER_ARRAY_SOURCE, Insert.PARAMETER_INT_OFFSET, Insert.PARAMETER_ANY],
-            Insert.EVENT_RESULT_EMPTY,
+            Insert.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -28,9 +28,13 @@ export class Insert extends AbstractArrayFunction {
         if (isNullValue(output) || isNullValue(offset) || offset > source.length)
             throw new KIRuntimeException('Please valid resouces to insert at the correct location');
 
+        source = [...source];
+
         if (source.length == 0) {
             if (offset == 0) source.push(output);
-            return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
         }
 
         source.push(output);
@@ -43,6 +47,8 @@ export class Insert extends AbstractArrayFunction {
             source[len--] = temp;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

package/src/engine/function/system/array/InsertLast.ts

@@ -0,0 +1,31 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../../../util/NullCheck';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class InsertLast extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'InsertLast',
+            [InsertLast.PARAMETER_ARRAY_SOURCE, InsertLast.PARAMETER_ANY],
+            InsertLast.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(InsertLast.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        var output = context?.getArguments()?.get(InsertLast.PARAMETER_ANY.getParameterName());
+
+        source = [...source];
+
+        source.push(output);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
+    }
+}

package/src/engine/function/system/array/LastIndexOf.ts

@@ -33,7 +33,7 @@ export class LastIndexOf extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (len < 0 || len > source.length)
@@ -43,11 +43,6 @@ export class LastIndexOf extends AbstractArrayFunction {
 
         let index: number = -1;
 
-        if (typeof find == null || typeof find == undefined)
-            throw new KIRuntimeException(
-                'Please provide the valid find object or primitive in order to verify',
-            );
-
         for (let i: number = source.length - 1; i >= len; i--) {
             if (PrimitiveUtil.compare(source[i], find) == 0) {
                 index = i;
@@ -56,7 +51,7 @@ export class LastIndexOf extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

package/src/engine/function/system/array/LastIndexOfArray.ts

@@ -33,9 +33,7 @@ export class LastIndexOfArray extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(
-                    new Map([[LastIndexOfArray.EVENT_RESULT_ARRAY.getName(), -1]]),
-                ),
+                EventResult.outputOf(new Map([[LastIndexOfArray.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (from < 0 || from > source.length || secondSource.length > source.length)
@@ -62,9 +60,7 @@ export class LastIndexOfArray extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(
-                new Map([[LastIndexOfArray.EVENT_RESULT_INTEGER.getName(), index]]),
-            ),
+            EventResult.outputOf(new Map([[LastIndexOfArray.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

package/src/engine/function/system/array/Max.ts

@@ -24,8 +24,6 @@ export class Max extends AbstractArrayFunction {
             max = y;
         }
 
-        return new FunctionOutput([
-            EventResult.outputOf(new Map([[Max.EVENT_RESULT_ANY.getName(), max]])),
-        ]);
+        return new FunctionOutput([EventResult.outputOf(new Map([[Max.EVENT_RESULT_NAME, max]]))]);
     }
 }

package/src/engine/function/system/array/Min.ts

@@ -25,8 +25,6 @@ export class Min extends AbstractArrayFunction {
                 min = source[i];
         }
 
-        return new FunctionOutput([
-            EventResult.outputOf(new Map([[Min.EVENT_RESULT_ANY.getName(), min]])),
-        ]);
+        return new FunctionOutput([EventResult.outputOf(new Map([[Min.EVENT_RESULT_NAME, min]]))]);
     }
 }

package/src/engine/function/system/array/MisMatch.ts

@@ -60,7 +60,7 @@ export class MisMatch extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[MisMatch.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[MisMatch.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

package/src/engine/function/system/array/Reverse.ts

@@ -13,7 +13,7 @@ export class Reverse extends AbstractArrayFunction {
                 Reverse.PARAMETER_INT_SOURCE_FROM,
                 Reverse.PARAMETER_INT_LENGTH,
             ],
-            Reverse.EVENT_RESULT_EMPTY,
+            Reverse.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -37,6 +37,8 @@ export class Reverse extends AbstractArrayFunction {
                 'Please provide start point between the start and end indexes or provide the length which was less than the source size ',
             );
 
+        source = [...source];
+
         let endpoint: number = st + len - 1;
         while (st <= endpoint) {
             let first: any = source[st];
@@ -45,6 +47,8 @@ export class Reverse extends AbstractArrayFunction {
             source[endpoint--] = first;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Reverse.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

package/src/engine/function/system/array/Rotate.ts

@@ -8,7 +8,7 @@ export class Rotate extends AbstractArrayFunction {
         super(
             'Rotate',
             [Rotate.PARAMETER_ARRAY_SOURCE, Rotate.PARAMETER_ROTATE_LENGTH],
-            Rotate.EVENT_RESULT_EMPTY,
+            Rotate.EVENT_RESULT_ANY,
         );
     }
 
@@ -21,7 +21,12 @@ export class Rotate extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(Rotate.PARAMETER_ROTATE_LENGTH.getParameterName());
 
-        if (source.length == 0) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
+
+        source = [...source];
 
         let size: number = source.length;
         rotLen = rotLen % size;
@@ -30,7 +35,9 @@ export class Rotate extends AbstractArrayFunction {
         this.rotate(source, rotLen, size - 1);
         this.rotate(source, 0, size - 1);
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 
     private rotate(elements: any[], start: number, end: number): void {

package/src/engine/function/system/array/Shuffle.ts

@@ -5,7 +5,7 @@ import { AbstractArrayFunction } from './AbstractArrayFunction';
 
 export class Shuffle extends AbstractArrayFunction {
     public constructor() {
-        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_EMPTY);
+        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ANY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -13,8 +13,12 @@ export class Shuffle extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(Shuffle.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        if (source.length <= 1) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        if (source.length <= 1)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
 
+        source = [...source];
         let x: number = 0;
         let size: number = source.length;
 
@@ -26,6 +30,8 @@ export class Shuffle extends AbstractArrayFunction {
             x = y;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

package/src/engine/function/system/array/Sort.ts

@@ -15,7 +15,7 @@ export class Sort extends AbstractArrayFunction {
                 Sort.PARAMETER_INT_LENGTH,
                 Sort.PARAMETER_BOOLEAN_ASCENDING,
             ],
-            Sort.EVENT_RESULT_EMPTY,
+            Sort.EVENT_RESULT_ANY,
         );
     }
 
@@ -38,9 +38,10 @@ export class Sort extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
             ]);
 
+        source = [...source];
         if (len == -1) len = source.length - start;
 
         if (start < 0 || start >= source.length || start + len > source.length)
@@ -55,7 +56,7 @@ export class Sort extends AbstractArrayFunction {
         source.splice(start, len, ...slicedArray);
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
         ]);
     }
 }

package/src/engine/function/system/array/SubArray.ts

@@ -42,7 +42,7 @@ export class SubArray extends AbstractArrayFunction {
         let slicedArray: any[] = source.slice(start, start + len);
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[SubArray.EVENT_RESULT_ARRAY.getName(), slicedArray]])),
+            EventResult.outputOf(new Map([[SubArray.EVENT_RESULT_NAME, slicedArray]])),
         ]);
     }
 }

package/src/engine/function/system/loop/Break.ts

@@ -0,0 +1,31 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const STEP_NAME = 'stepName';
+
+const SIGNATURE = new FunctionSignature('Break')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(new Map([Parameter.ofEntry(STEP_NAME, Schema.of(STEP_NAME, SchemaType.STRING))]))
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([]))]));
+
+export class Break extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let stepName: string = context.getArguments()?.get(STEP_NAME);
+
+        context.getExecutionContext().set(stepName, true);
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}

package/src/engine/function/system/loop/CountLoop.ts

@@ -34,11 +34,17 @@ export class CountLoop extends AbstractFunction {
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let count: number = context.getArguments()?.get(COUNT);
         let current = 0;
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
 
         return new FunctionOutput({
             next(): EventResult {
-                if (current >= count) {
-                    return EventResult.outputOf(new Map([[VALUE, count]]));
+                if (
+                    current >= count ||
+                    (statementName && context.getExecutionContext()?.get(statementName))
+                ) {
+                    // check for break;
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
                 }
 
                 const eve = EventResult.of(Event.ITERATION, new Map([[INDEX, current]]));

package/src/engine/function/system/loop/ForEachLoop.ts

@@ -0,0 +1,70 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const SOURCE = 'source';
+const EACH = 'each';
+const INDEX = 'index';
+const VALUE = 'value';
+
+const SIGNATURE = new FunctionSignature('ForEachLoop')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(
+        new Map([Parameter.ofEntry(SOURCE, Schema.ofArray(SOURCE, Schema.ofAny(SOURCE)))]),
+    )
+    .setEvents(
+        new Map([
+            Event.eventMapEntry(
+                Event.ITERATION,
+                new Map([
+                    [INDEX, Schema.of(INDEX, SchemaType.INTEGER)],
+                    [EACH, Schema.ofAny(EACH)],
+                ]),
+            ),
+            Event.outputEventMapEntry(new Map([[VALUE, Schema.of(VALUE, SchemaType.INTEGER)]])),
+        ]),
+    );
+
+export class ForEachLoop extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let source: any[] = context.getArguments()?.get(SOURCE);
+
+        let current = 0;
+
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
+
+        return new FunctionOutput({
+            next(): EventResult {
+                if (
+                    current >= source.length ||
+                    (statementName && context.getExecutionContext()?.get(statementName)) //check for breaks;
+                ) {
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
+                }
+
+                const eve = EventResult.of(
+                    Event.ITERATION,
+                    new Map([
+                        [INDEX, current],
+                        [EACH, source[current]],
+                    ]),
+                );
+                ++current;
+
+                return eve;
+            },
+        });
+    }
+}

package/src/engine/function/system/loop/RangeLoop.ts

@@ -100,13 +100,19 @@ export class RangeLoop extends AbstractFunction {
         const forward = step > 0;
         let current: number = from;
         let done: boolean = false;
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
 
         return new FunctionOutput({
             next(): EventResult | undefined {
                 if (done) return undefined;
 
-                if ((forward && current >= to) || (!forward && current <= to)) {
+                if (
+                    (forward && current >= to) ||
+                    (!forward && current <= to) ||
+                    (statementName && context.getExecutionContext()?.get(statementName)) //Check for break;
+                ) {
                     done = true;
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
                     return EventResult.outputOf(new Map([[VALUE, current]]));
                 }
 

package/src/engine/json/schema/validator/SchemaValidator.ts

@@ -1,4 +1,5 @@
 import { Repository } from '../../../Repository';
+import { deepEqual } from '../../../util/deepEqual';
 import { isNullValue } from '../../../util/NullCheck';
 import { StringUtil } from '../../../util/string/StringUtil';
 import { Schema } from '../Schema';
@@ -40,7 +41,7 @@ export class SchemaValidator {
             return JSON.parse(JSON.stringify(schema.getDefaultValue()));
         }
 
-        if (schema.getConstant()) {
+        if (!isNullValue(schema.getConstant())) {
             return SchemaValidator.constantValidation(parents, schema, element);
         }
 
@@ -92,7 +93,7 @@ export class SchemaValidator {
     }
 
     public static constantValidation(parents: Schema[], schema: Schema, element: any): any {
-        if (!schema.getConstant().equals(element)) {
+        if (!deepEqual(schema.getConstant(), element)) {
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
                 'Expecting a constant value : ' + element,

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -5,6 +5,7 @@ import { Get } from '../function/system/context/Get';
 import { SetFunction } from '../function/system/context/SetFunction';
 import { GenerateEvent } from '../function/system/GenerateEvent';
 import { If } from '../function/system/If';
+import { Break } from '../function/system/loop/Break';
 import { CountLoop } from '../function/system/loop/CountLoop';
 import { RangeLoop } from '../function/system/loop/RangeLoop';
 import { MathFunctionRepository } from '../function/system/math/MathFunctionRepository';
@@ -20,7 +21,10 @@ const map: Map<string, Map<string, Function>> = new Map([
         Namespaces.SYSTEM_CTX,
         new Map([mapEntry(new Create()), mapEntry(new Get()), mapEntry(new SetFunction())]),
     ],
-    [Namespaces.SYSTEM_LOOP, new Map([mapEntry(new RangeLoop()), mapEntry(new CountLoop())])],
+    [
+        Namespaces.SYSTEM_LOOP,
+        new Map([mapEntry(new RangeLoop()), mapEntry(new CountLoop()), mapEntry(new Break())]),
+    ],
     [
         Namespaces.SYSTEM,
         new Map([mapEntry(new If()), mapEntry(new GenerateEvent()), mapEntry(new Print())]),

package/src/engine/runtime/FunctionExecutionParameters.ts

@@ -5,7 +5,6 @@ import UUID from '../util/UUID';
 import { ContextElement } from './ContextElement';
 import { TokenValueExtractor } from './expression/tokenextractor/TokenValueExtractor';
 import { StatementExecution } from './StatementExecution';
-import { ArgumentsTokenValueExtractor } from './tokenextractor/ArgumentsTokenValueExtractor';
 import { ContextTokenValueExtractor } from './tokenextractor/ContextTokenValueExtractor';
 import { OutputMapTokenValueExtractor } from './tokenextractor/OutputMapTokenValueExtractor';
 
@@ -19,6 +18,7 @@ export class FunctionExecutionParameters {
     private functionRepository: Repository<Function>;
     private schemaRepository: Repository<Schema>;
     private executionId: string;
+    private executionContext: Map<string, any> = new Map();
 
     private valueExtractors: Map<string, TokenValueExtractor> = new Map();
 
@@ -121,4 +121,13 @@ export class FunctionExecutionParameters {
 
         return this;
     }
+
+    public setExecutionContext(executionContext: Map<string, any>): FunctionExecutionParameters {
+        this.executionContext = executionContext;
+        return this;
+    }
+
+    public getExecutionContext(): Map<string, any> {
+        return this.executionContext;
+    }
 }

package/src/engine/runtime/KIRuntime.ts

@@ -359,7 +359,8 @@ export class KIRuntime extends AbstractFunction {
                 .setEvents(inContext.getEvents()!)
                 .setSteps(inContext.getSteps()!)
                 .setStatementExecution(vertex.getData())
-                .setCount(inContext.getCount());
+                .setCount(inContext.getCount())
+                .setExecutionContext(inContext.getExecutionContext());
         }
 
         let result: FunctionOutput = await fun.execute(fep);