@fincity/kirun-js 1.0.5 → 1.1.2

package/src/engine/function/system/string/ReplaceAtGivenPosition.ts

@@ -18,22 +18,35 @@ export class ReplaceAtGivenPosition extends AbstractFunction {
 
     protected static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected static PARAMETER_STRING: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_STRING_NAME,Schema.ofString(ReplaceAtGivenPosition.PARAMETER_STRING_NAME));
+    protected static PARAMETER_STRING: Parameter = new Parameter(
+        ReplaceAtGivenPosition.PARAMETER_STRING_NAME,
+        Schema.ofString(ReplaceAtGivenPosition.PARAMETER_STRING_NAME),
+    );
 
-    protected static PARAMETER_AT_START: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME,Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME));
+    protected static PARAMETER_AT_START: Parameter = new Parameter(
+        ReplaceAtGivenPosition.PARAMETER_AT_START_NAME,
+        Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME),
+    );
 
-    protected static PARAMETER_AT_LENGTH: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME,Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME));
+    protected static PARAMETER_AT_LENGTH: Parameter = new Parameter(
+        ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME,
+        Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME),
+    );
 
-    protected static PARAMETER_REPLACE_STRING: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME,Schema.ofString(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME));
+    protected static PARAMETER_REPLACE_STRING: Parameter = new Parameter(
+        ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME,
+        Schema.ofString(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME),
+    );
 
-    protected static EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([
-                [
-                    ReplaceAtGivenPosition.EVENT_RESULT_NAME,
-                    Schema.ofString(ReplaceAtGivenPosition.EVENT_RESULT_NAME),
-                ],
-            ]),
-        );
+    protected static EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([
+            [
+                ReplaceAtGivenPosition.EVENT_RESULT_NAME,
+                Schema.ofString(ReplaceAtGivenPosition.EVENT_RESULT_NAME),
+            ],
+        ]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('ReplaceAtGivenPosition')
         .setNamespace(Namespaces.STRING)
@@ -70,7 +83,7 @@ export class ReplaceAtGivenPosition extends AbstractFunction {
         return this.signature;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context
             ?.getArguments()
             ?.get(ReplaceAtGivenPosition.PARAMETER_STRING_NAME);

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

@@ -20,8 +20,9 @@ export class Reverse extends AbstractFunction {
             new Map([
                 [
                     this.VALUE,
-                   new Parameter(this.VALUE,Schema.ofString(this.VALUE))
-                        .setVariableArgument(true),
+                    new Parameter(this.VALUE, Schema.ofString(this.VALUE)).setVariableArgument(
+                        true,
+                    ),
                 ],
             ]),
         )
@@ -48,7 +49,7 @@ export class Reverse extends AbstractFunction {
         return this.SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let acutalString: string = context.getArguments()?.get(this.VALUE);
         let stringLength: number = acutalString.length - 1;
         let reversedString: string = '';

package/src/engine/function/system/string/Split.ts

@@ -14,11 +14,20 @@ export class Split extends AbstractFunction {
     protected readonly PARAMETER_SPLIT_STRING_NAME: string = 'searchString';
     protected readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected readonly PARAMETER_STRING: Parameter =new Parameter(this.PARAMETER_STRING_NAME,Schema.ofString(this.PARAMETER_STRING_NAME));
+    protected readonly PARAMETER_STRING: Parameter = new Parameter(
+        this.PARAMETER_STRING_NAME,
+        Schema.ofString(this.PARAMETER_STRING_NAME),
+    );
 
-    protected readonly PARAMETER_SPLIT_STRING: Parameter =new Parameter(this.PARAMETER_SPLIT_STRING_NAME,Schema.ofString(this.PARAMETER_SPLIT_STRING_NAME));
+    protected readonly PARAMETER_SPLIT_STRING: Parameter = new Parameter(
+        this.PARAMETER_SPLIT_STRING_NAME,
+        Schema.ofString(this.PARAMETER_SPLIT_STRING_NAME),
+    );
 
-    protected readonly EVENT_ARRAY: Event =new Event(Event.OUTPUT,MapUtil.of(this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)));
+    protected readonly EVENT_ARRAY: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)),
+    );
 
     public getSignature(): FunctionSignature {
         return new FunctionSignature('Split')
@@ -42,7 +51,7 @@ export class Split extends AbstractFunction {
         super();
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let s1: string = context.getArguments()?.get(this.PARAMETER_STRING_NAME);
         let s2: string = context.getArguments()?.get(this.PARAMETER_SPLIT_STRING_NAME);
 

package/src/engine/function/system/string/ToString.ts

@@ -13,11 +13,15 @@ export class ToString extends AbstractFunction {
 
     protected readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected readonly PARAMETER_INPUT_ANYTYPE: Parameter =new Parameter(this.PARAMETER_INPUT_ANYTYPE_NAME,Schema.ofAny(this.PARAMETER_INPUT_ANYTYPE_NAME));
+    protected readonly PARAMETER_INPUT_ANYTYPE: Parameter = new Parameter(
+        this.PARAMETER_INPUT_ANYTYPE_NAME,
+        Schema.ofAny(this.PARAMETER_INPUT_ANYTYPE_NAME),
+    );
 
-    protected readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
-        );
+    protected readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
+    );
 
     public getSignature(): FunctionSignature {
         return new FunctionSignature('ToString')
@@ -34,7 +38,7 @@ export class ToString extends AbstractFunction {
         super();
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let input: any = context.getArguments()?.get(this.PARAMETER_INPUT_ANYTYPE_NAME);
         let output: string = input + '';
 

package/src/engine/function/system/string/TrimTo.ts

@@ -15,13 +15,20 @@ export class TrimTo extends AbstractFunction {
 
     public static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected static readonly PARAMETER_STRING: Parameter =new Parameter(TrimTo.PARAMETER_STRING_NAME,Schema.ofString(TrimTo.PARAMETER_STRING_NAME));
+    protected static readonly PARAMETER_STRING: Parameter = new Parameter(
+        TrimTo.PARAMETER_STRING_NAME,
+        Schema.ofString(TrimTo.PARAMETER_STRING_NAME),
+    );
 
-    protected static readonly PARAMETER_LENGTH: Parameter =new Parameter(TrimTo.PARAMETER_LENGTH_NAME,Schema.ofInteger(TrimTo.PARAMETER_LENGTH_NAME));
+    protected static readonly PARAMETER_LENGTH: Parameter = new Parameter(
+        TrimTo.PARAMETER_LENGTH_NAME,
+        Schema.ofInteger(TrimTo.PARAMETER_LENGTH_NAME),
+    );
 
-    protected static readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([[TrimTo.EVENT_RESULT_NAME, Schema.ofString(TrimTo.EVENT_RESULT_NAME)]]),
-        );
+    protected static readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([[TrimTo.EVENT_RESULT_NAME, Schema.ofString(TrimTo.EVENT_RESULT_NAME)]]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('TrimTo')
         .setNamespace(Namespaces.STRING)
@@ -41,7 +48,7 @@ export class TrimTo extends AbstractFunction {
         super();
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context.getArguments()?.get(TrimTo.PARAMETER_STRING_NAME);
         let length: number = context.getArguments()?.get(TrimTo.PARAMETER_LENGTH_NAME);
 

package/src/engine/json/schema/Schema.ts

@@ -7,6 +7,7 @@ import { TypeUtil } from './type/TypeUtil';
 import { Type } from './type/Type';
 import { isNullValue } from '../../util/NullCheck';
 import { SingleType } from './type/SingleType';
+import { SchemaReferenceException } from './validator/exception/SchemaReferenceException';
 
 const ADDITIONAL_PROPERTY: string = 'additionalProperty';
 const ENUMS: string = 'enums';

package/src/engine/model/Event.ts

@@ -2,6 +2,7 @@ import { AdditionalPropertiesType } from '../json/schema/object/AdditionalProper
 import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
+import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
 import { Namespaces } from '../namespaces/Namespaces';
 
 export class Event {
@@ -59,4 +60,18 @@ export class Event {
     ): [string, Event] {
         return [eventName, new Event(eventName, parameters)];
     }
+
+    public static from(json: any): Event {
+        return new Event(
+            json.name,
+            new Map(
+                Object.entries(json.parameters ?? {}).map((e: any) => {
+                    const eventSchema = Schema.from(e[1]);
+                    if (!eventSchema)
+                        throw new SchemaReferenceException('', 'Event expects a schema');
+                    return [e[0], eventSchema];
+                }),
+            ),
+        );
+    }
 }

package/src/engine/model/FunctionDefinition.ts

@@ -7,39 +7,38 @@ import { Parameter } from './Parameter';
 import { Statement } from './Statement';
 import { StatementGroup } from './StatementGroup';
 
+const SCHEMA_NAME1: string = 'FunctionDefinition';
+const IN_SCHEMA = new Schema()
+    .setNamespace(Namespaces.SYSTEM)
+    .setName(SCHEMA_NAME1)
+    .setProperties(
+        new Map([
+            ['name', Schema.ofString('name')],
+            ['namespace', Schema.ofString('namespace')],
+            ['parameters', Schema.ofArray('parameters', Parameter.SCHEMA)],
+            [
+                'events',
+                Schema.ofObject('events').setAdditionalProperties(
+                    new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                ),
+            ],
+            [
+                'steps',
+                Schema.ofObject('steps').setAdditionalProperties(
+                    new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
+                ),
+            ],
+        ]),
+    );
+
+IN_SCHEMA.getProperties()?.set('parts', Schema.ofArray('parts', IN_SCHEMA));
+
 export class FunctionDefinition extends FunctionSignature {
-    private static readonly SCHEMA_NAME1: string = 'FunctionDefinition';
-    public static readonly SCHEMA: Schema = new Schema()
-        .setNamespace(Namespaces.SYSTEM)
-        .setName(FunctionDefinition.SCHEMA_NAME1)
-        .setProperties(
-            new Map([
-                ['name', Schema.ofString('name')],
-                ['namespace', Schema.ofString('namespace')],
-                ['parameters', Schema.ofArray('parameters', Parameter.SCHEMA)],
-                [
-                    'events',
-                    Schema.ofObject('events').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
-                    ),
-                ],
-                [
-                    'parts',
-                    Schema.ofObject('parts').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(FunctionSignature.SCHEMA),
-                    ),
-                ],
-                [
-                    'steps',
-                    Schema.ofObject('steps').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
-                    ),
-                ],
-            ]),
-        );
+    public static readonly SCHEMA: Schema = IN_SCHEMA;
     private version: number = 1;
     private steps?: Map<string, Statement>;
     private stepGroups?: Map<string, StatementGroup>;
+    private parts?: FunctionDefinition[];
 
     constructor(name: string) {
         super(name);
@@ -66,4 +65,52 @@ export class FunctionDefinition extends FunctionSignature {
         this.stepGroups = stepGroups;
         return this;
     }
+
+    public getParts(): FunctionDefinition[] | undefined {
+        return this.parts;
+    }
+
+    public setParts(parts: FunctionDefinition[]): FunctionDefinition {
+        this.parts = parts;
+        return this;
+    }
+
+    public static from(json: any): FunctionDefinition {
+        if (!json) return new FunctionDefinition('unknown');
+        return new FunctionDefinition(json.name)
+            .setSteps(
+                new Map(
+                    Object.values(json.steps ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.statementName, Statement.from(e)]),
+                ),
+            )
+            .setStepGroups(
+                new Map(
+                    Object.values(json.stepGroups ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.statementGroupName, StatementGroup.from(e)]),
+                ),
+            )
+            .setParts(
+                Array.from(json.parts ?? [])
+                    .filter((e) => !!e)
+                    .map((e: any) => FunctionDefinition.from(e)),
+            )
+            .setVersion(json.version ?? 1)
+            .setEvents(
+                new Map(
+                    Object.values(json.events ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.name, Event.from(e)]),
+                ),
+            )
+            .setParameters(
+                new Map(
+                    Object.values(json.parameters ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.parameterName, Parameter.from(e)]),
+                ),
+            ) as FunctionDefinition;
+    }
 }

package/src/engine/model/Parameter.ts

@@ -1,6 +1,7 @@
 import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
+import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
 import { Namespaces } from '../namespaces/Namespaces';
 import { ParameterType } from './ParameterType';
 
@@ -20,9 +21,11 @@ export class Parameter {
                     'variableArgument',
                     Schema.of('variableArgument', SchemaType.BOOLEAN).setDefaultValue(false),
                 ],
+                ['type', Schema.ofString('type').setEnums(['EXPRESSION', 'CONSTANT'])],
             ]),
         );
 
+    // Place holder for the expression parameter when required to represent an expression in the value.
     public static readonly EXPRESSION: Schema = new Schema()
         .setNamespace(Namespaces.SYSTEM)
         .setName('ParameterExpression')
@@ -94,4 +97,12 @@ export class Parameter {
     ): Parameter {
         return new Parameter(name, schema).setType(type).setVariableArgument(variableArgument);
     }
+
+    public static from(json: any): Parameter {
+        const paramSchema = Schema.from(json.schema);
+        if (!paramSchema) throw new SchemaReferenceException('', 'Parameter requires Schema');
+        return new Parameter(json.parameterName, paramSchema)
+            .setVariableArgument(!!json.variableArguments)
+            .setType(json.type ?? ParameterType.EXPRESSION);
+    }
 }

package/src/engine/model/ParameterReference.ts

@@ -12,9 +12,9 @@ export class ParameterReference {
         .setType(TypeUtil.of(SchemaType.OBJECT))
         .setProperties(
             new Map([
-                ['references', Schema.ofString('references')],
                 ['value', Schema.ofAny('value')],
                 ['expression', Schema.ofString('expression')],
+                ['type', Schema.ofString('type').setEnums(['EXPRESSION', 'VALUE'])],
             ]),
         );
     private type: ParameterReferenceType;
@@ -54,4 +54,11 @@ export class ParameterReference {
     public static ofValue(value: any): ParameterReference {
         return new ParameterReference(ParameterReferenceType.VALUE).setValue(value);
     }
+
+    public static from(json: any): ParameterReference[] {
+        if (!json) return [];
+        return Array.from(json).map((e: any) =>
+            new ParameterReference(e.type).setValue(e.value).setExpression(e.expression),
+        );
+    }
 }

package/src/engine/model/Position.ts

@@ -37,4 +37,9 @@ export class Position {
         this.top = top;
         return this;
     }
+
+    public static from(json: any): Position {
+        if (!json) return new Position(-1, -1);
+        return new Position(json.left, json.top);
+    }
 }

package/src/engine/model/Statement.ts

@@ -98,4 +98,20 @@ export class Statement extends AbstractStatement {
     public static ofEntry(statement: Statement): [string, Statement] {
         return [statement.statementName, statement];
     }
+
+    public static from(json: any): Statement {
+        return new Statement(json.statementName, json.namespace, json.name)
+            .setParameterMap(
+                new Map<string, ParameterReference[]>(
+                    Object.entries(json.parameterMap ?? {}).map(([k, v]) => [
+                        k,
+                        ParameterReference.from(v),
+                    ]),
+                ),
+            )
+            .setDependentStatements(json.dependentStatements)
+            .setPosition(Position.from(json.position))
+            .setComment(json.comment)
+            .setDescription(json.description) as Statement;
+    }
 }

package/src/engine/model/StatementGroup.ts

@@ -34,4 +34,11 @@ export class StatementGroup extends AbstractStatement {
         this.statementGroupName = statementGroupName;
         return this;
     }
+
+    public static from(json: any): StatementGroup {
+        return new StatementGroup(json.statementGroupName)
+            .setPosition(Position.from(json.position))
+            .setComment(json.comment)
+            .setDescription(json.description) as StatementGroup;
+    }
 }

package/src/engine/runtime/KIRuntime.ts

@@ -72,9 +72,9 @@ export class KIRuntime extends AbstractFunction {
         return this.fd;
     }
 
-    private getExecutionPlan(
+    private async getExecutionPlan(
         context: Map<string, ContextElement>,
-    ): ExecutionGraph<string, StatementExecution> {
+    ): Promise<ExecutionGraph<string, StatementExecution>> {
         let g: ExecutionGraph<string, StatementExecution> = new ExecutionGraph();
         for (let s of Array.from(this.fd.getSteps().values()))
             g.addVertex(this.prepareStatementExecution(context, s));
@@ -95,14 +95,16 @@ export class KIRuntime extends AbstractFunction {
         return g;
     }
 
-    protected internalExecute(inContext: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(
+        inContext: FunctionExecutionParameters,
+    ): Promise<FunctionOutput> {
         if (!inContext.getContext()) inContext.setContext(new Map());
 
         if (!inContext.getEvents()) inContext.setEvents(new Map());
 
         if (!inContext.getSteps()) inContext.setSteps(new Map());
 
-        let eGraph: ExecutionGraph<string, StatementExecution> = this.getExecutionPlan(
+        let eGraph: ExecutionGraph<string, StatementExecution> = await this.getExecutionPlan(
             inContext.getContext()!,
         );
 
@@ -123,13 +125,13 @@ export class KIRuntime extends AbstractFunction {
             );
         }
 
-        return this.executeGraph(eGraph, inContext);
+        return await this.executeGraph(eGraph, inContext);
     }
 
-    private executeGraph(
+    private async executeGraph(
         eGraph: ExecutionGraph<string, StatementExecution>,
         inContext: FunctionExecutionParameters,
-    ): FunctionOutput {
+    ): Promise<FunctionOutput> {
         let executionQue: LinkedList<GraphVertex<string, StatementExecution>> = new LinkedList();
         executionQue.addAll(eGraph.getVerticesWithNoIncomingEdges());
 
@@ -146,8 +148,8 @@ export class KIRuntime extends AbstractFunction {
             (!executionQue.isEmpty() || !branchQue.isEmpty()) &&
             !inContext.getEvents()?.has(Event.OUTPUT)
         ) {
-            this.processBranchQue(inContext, executionQue, branchQue);
-            this.processExecutionQue(inContext, executionQue, branchQue);
+            await this.processBranchQue(inContext, executionQue, branchQue);
+            await this.processExecutionQue(inContext, executionQue, branchQue);
 
             inContext.setCount(inContext.getCount() + 1);
 
@@ -166,7 +168,7 @@ export class KIRuntime extends AbstractFunction {
         );
     }
 
-    private processExecutionQue(
+    private async processExecutionQue(
         inContext: FunctionExecutionParameters,
         executionQue: LinkedList<GraphVertex<string, StatementExecution>>,
         branchQue: LinkedList<
@@ -177,17 +179,17 @@ export class KIRuntime extends AbstractFunction {
                 GraphVertex<string, StatementExecution>
             >
         >,
-    ): void {
+    ) {
         if (!executionQue.isEmpty()) {
             let vertex: GraphVertex<string, StatementExecution> = executionQue.pop();
 
-            if (!this.allDependenciesResolvedVertex(vertex, inContext.getSteps()!))
+            if (!(await this.allDependenciesResolvedVertex(vertex, inContext.getSteps()!)))
                 executionQue.add(vertex);
-            else this.executeVertex(vertex, inContext, branchQue, executionQue);
+            else await this.executeVertex(vertex, inContext, branchQue, executionQue);
         }
     }
 
-    private processBranchQue(
+    private async processBranchQue(
         inContext: FunctionExecutionParameters,
         executionQue: LinkedList<GraphVertex<string, StatementExecution>>,
         branchQue: LinkedList<
@@ -198,7 +200,7 @@ export class KIRuntime extends AbstractFunction {
                 GraphVertex<string, StatementExecution>
             >
         >,
-    ): void {
+    ) {
         if (branchQue.length) {
             let branch: Tuple4<
                 ExecutionGraph<string, StatementExecution>,
@@ -207,13 +209,13 @@ export class KIRuntime extends AbstractFunction {
                 GraphVertex<string, StatementExecution>
             > = branchQue.pop();
 
-            if (!this.allDependenciesResolvedTuples(branch.getT2(), inContext.getSteps()!))
+            if (!(await this.allDependenciesResolvedTuples(branch.getT2(), inContext.getSteps()!)))
                 branchQue.add(branch);
-            else this.executeBranch(inContext, executionQue, branch);
+            else await this.executeBranch(inContext, executionQue, branch);
         }
     }
 
-    private executeBranch(
+    private async executeBranch(
         inContext: FunctionExecutionParameters,
         executionQue: LinkedList<GraphVertex<string, StatementExecution>>,
         branch: Tuple4<
@@ -222,12 +224,12 @@ export class KIRuntime extends AbstractFunction {
             FunctionOutput,
             GraphVertex<string, StatementExecution>
         >,
-    ): void {
+    ) {
         let vertex: GraphVertex<string, StatementExecution> = branch.getT4();
         let nextOutput: EventResult | undefined = undefined;
 
         do {
-            this.executeGraph(branch.getT1(), inContext);
+            await this.executeGraph(branch.getT1(), inContext);
             nextOutput = branch.getT3().next();
 
             if (nextOutput) {
@@ -241,7 +243,7 @@ export class KIRuntime extends AbstractFunction {
                     ?.get(vertex.getData().getStatement().getStatementName())
                     ?.set(
                         nextOutput.getName(),
-                        this.resolveInternalExpressions(nextOutput.getResult(), inContext),
+                        await this.resolveInternalExpressions(nextOutput.getResult(), inContext),
                     );
             }
         } while (nextOutput && nextOutput.getName() != Event.OUTPUT);
@@ -251,7 +253,7 @@ export class KIRuntime extends AbstractFunction {
         }
     }
 
-    private executeVertex(
+    private async executeVertex(
         vertex: GraphVertex<string, StatementExecution>,
         inContext: FunctionExecutionParameters,
         branchQue: LinkedList<
@@ -263,7 +265,7 @@ export class KIRuntime extends AbstractFunction {
             >
         >,
         executionQue: LinkedList<GraphVertex<string, StatementExecution>>,
-    ): void {
+    ) {
         let s: Statement = vertex.getData().getStatement();
 
         let fun: Function | undefined = this.fRepo.find(s.getNamespace(), s.getName());
@@ -284,7 +286,7 @@ export class KIRuntime extends AbstractFunction {
 
         let context: Map<string, ContextElement> = inContext.getContext()!;
 
-        let result: FunctionOutput = fun.execute(
+        let result: FunctionOutput = await fun.execute(
             new FunctionExecutionParameters()
                 .setContext(context)
                 .setArguments(args)