@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseLeftShiftOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_LEFT_SHIFT);
+        return t << u;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseOrOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_OR);
+        return t | u;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseRightShiftOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_RIGHT_SHIFT);
+        return t >> u;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseUnsignedRightShiftOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_UNSIGNED_RIGHT_SHIFT);
+        return t >>> u;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseXorOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_XOR);
+        return t ^ u;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalAndOperator 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);
+
+        if (tType.getT1() != SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format('Boolean value expected but found $', tType.getT2()),
+            );
+
+        if (uType.getT1() != SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format('Boolean value expected but found $', uType.getT2()),
+            );
+
+        return tType.getT2() && uType.getT2();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { Tuple2 } from '../../../../util/Tuples';
+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();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalGreaterThanEqualOperator 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);
+
+        if (tType.getT1() == SchemaType.BOOLEAN || uType.getT1() == SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Cannot compare >= with the values $ and $',
+                    tType.getT2(),
+                    uType.getT2(),
+                ),
+            );
+
+        return tType.getT2() >= uType.getT2();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalGreaterThanOperator 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);
+
+        if (tType.getT1() == SchemaType.BOOLEAN || uType.getT1() == SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Cannot compare > with the values $ and $',
+                    tType.getT2(),
+                    uType.getT2(),
+                ),
+            );
+
+        return tType.getT2() > uType.getT2();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalLessThanEqualOperator 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);
+
+        if (tType.getT1() == SchemaType.BOOLEAN || uType.getT1() == SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Cannot compare <= with the values $ and $',
+                    tType.getT2(),
+                    uType.getT2(),
+                ),
+            );
+
+        return tType.getT2() <= uType.getT2();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalLessThanOperator 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);
+
+        if (tType.getT1() == SchemaType.BOOLEAN || uType.getT1() == SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Cannot compare < with the values $ and $',
+                    tType.getT2(),
+                    uType.getT2(),
+                ),
+            );
+
+        return tType.getT2() < uType.getT2();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { Tuple2 } from '../../../../util/Tuples';
+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();
+    }
+}

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

@@ -0,0 +1,25 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { BinaryOperator } from './BinaryOperator';
+
+export class LogicalOrOperator 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);
+
+        if (tType.getT1() != SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format('Boolean value expected but found $', tType.getT2()),
+            );
+
+        if (uType.getT1() != SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format('Boolean value expected but found $', uType.getT2()),
+            );
+
+        return tType.getT2() || uType.getT2();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ObjectOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        if (!t) {
+            throw new ExecutionException('Cannot apply array operator on a null value');
+        }
+
+        if (!u) {
+            throw new ExecutionException('Cannot retrive null property value');
+        }
+
+        const x: string = typeof t;
+
+        if (!Array.isArray(t) && x != 'string' && x != 'object') {
+            throw new ExecutionException(
+                StringFormatter.format('Cannot retrieve value from a primitive value $', t),
+            );
+        }
+        return t[u];
+    }
+}

package/src/engine/runtime/expression/operators/unary/ArithmeticUnaryMinusOperator.ts

@@ -0,0 +1,13 @@
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { Operation } from '../../Operation';
+import { UnaryOperator } from './UnaryOperator';
+
+export class ArithmeticUnaryMinusOperator extends UnaryOperator {
+    public apply(t: any): any {
+        this.nullCheck(t, Operation.UNARY_MINUS);
+
+        PrimitiveUtil.findPrimitiveNumberType(t);
+
+        return -t;
+    }
+}

package/src/engine/runtime/expression/operators/unary/ArithmeticUnaryPlusOperator.ts

@@ -0,0 +1,13 @@
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { Operation } from '../../Operation';
+import { UnaryOperator } from './UnaryOperator';
+
+export class ArithmeticUnaryPlusOperator extends UnaryOperator {
+    public apply(t: any): any {
+        this.nullCheck(t, Operation.UNARY_PLUS);
+
+        PrimitiveUtil.findPrimitiveNumberType(t);
+
+        return t;
+    }
+}

package/src/engine/runtime/expression/operators/unary/BitwiseComplementOperator.ts

@@ -0,0 +1,22 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { Operation } from '../../Operation';
+import { UnaryOperator } from './UnaryOperator';
+
+export class BitwiseComplementOperator extends UnaryOperator {
+    public apply(t: any): any {
+        this.nullCheck(t, Operation.UNARY_BITWISE_COMPLEMENT);
+
+        let tType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNumberType(t);
+
+        if (tType.getT1() != SchemaType.INTEGER && tType.getT1() != SchemaType.LONG)
+            throw new ExecutionException(
+                StringFormatter.format('Unable to apply bitwise operator on $', t),
+            );
+
+        return ~t;
+    }
+}

package/src/engine/runtime/expression/operators/unary/LogicalNotOperator.ts

@@ -0,0 +1,22 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { SchemaType } from '../../../../json/schema/type/SchemaType';
+import { PrimitiveUtil } from '../../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Tuple2 } from '../../../../util/Tuples';
+import { Operation } from '../../Operation';
+import { UnaryOperator } from './UnaryOperator';
+
+export class LogicalNotOperator extends UnaryOperator {
+    public apply(t: any): any {
+        this.nullCheck(t, Operation.UNARY_LOGICAL_NOT);
+
+        let tType: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitiveNumberType(t);
+
+        if (tType.getT1() != SchemaType.BOOLEAN)
+            throw new ExecutionException(
+                StringFormatter.format('Unable to apply bitwise operator on $', t),
+            );
+
+        return !t;
+    }
+}

package/src/engine/runtime/expression/operators/unary/UnaryOperator.ts

@@ -0,0 +1,15 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { isNullValue } from '../../../../util/NullCheck';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Operation } from '../../Operation';
+
+export abstract class UnaryOperator {
+    public abstract apply(t: any): any;
+
+    public nullCheck(e1: any, op: Operation): void {
+        if (isNullValue(e1))
+            throw new ExecutionException(
+                StringFormatter.format('$ cannot be applied to a null value', op.getOperatorName()),
+            );
+    }
+}

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

@@ -0,0 +1,64 @@
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { StringUtil } from '../../../util/string/StringUtil';
+import { ExpressionEvaluationException } from '../exception/ExpressionEvaluationException';
+import { TokenValueExtractor } from './TokenValueExtractor';
+
+const KEYWORDS: Map<string, any> = new Map([
+    ['true', true],
+    ['false', false],
+    ['null', undefined],
+]);
+
+export class LiteralTokenValueExtractor extends TokenValueExtractor {
+    public static readonly INSTANCE: LiteralTokenValueExtractor = new LiteralTokenValueExtractor();
+
+    protected getValueInternal(token: string): any {
+        if (StringUtil.isNullOrBlank(token)) return undefined;
+
+        token = token.trim();
+
+        if (KEYWORDS.has(token)) return KEYWORDS.get(token);
+
+        if (token.startsWith('"')) {
+            return this.processString(token);
+        }
+
+        return this.processNumbers(token);
+    }
+
+    private processNumbers(token: string): any {
+        try {
+            let ind: number = token.indexOf('.');
+            let v: number;
+            if (ind == -1) {
+                v = parseInt(token);
+            } else {
+                v = parseFloat(token);
+            }
+
+            if (isNaN(v)) throw new Error('Parse number error');
+
+            return v;
+        } catch (err: any) {
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format('Unable to parse the literal or expression $', token),
+                err,
+            );
+        }
+    }
+
+    private processString(token: string): any {
+        if (!token.endsWith('"'))
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format('String literal $ is not closed properly', token),
+            );
+
+        return token.substring(1, token.length - 1);
+    }
+
+    public getPrefix(): string {
+        return '';
+    }
+}

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

@@ -0,0 +1,136 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { isNullValue } from '../../../util/NullCheck';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { StringUtil } from '../../../util/string/StringUtil';
+import { ExpressionEvaluationException } from '../exception/ExpressionEvaluationException';
+
+export abstract class TokenValueExtractor {
+    private static readonly REGEX_SQUARE_BRACKETS: RegExp = /[\[\]]/;
+    public static readonly REGEX_DOT: RegExp = /\./;
+
+    public getValue(token: string): any {
+        let prefix: string = this.getPrefix();
+
+        if (!token.startsWith(prefix))
+            throw new KIRuntimeException(
+                StringFormatter.format("Token $ doesn't start with $", token, prefix),
+            );
+
+        return this.getValueInternal(token);
+    }
+
+    protected retrieveElementFrom(
+        token: string,
+        parts: string[],
+        partNumber: 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, i) =>
+                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a, i),
+                jsonElement,
+            );
+
+        return this.retrieveElementFrom(token, parts, partNumber + 1, bElement);
+    }
+
+    protected resolveForEachPartOfTokenWithBrackets(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        c: string,
+        a: any,
+        i: any,
+    ): any {
+        if (isNullValue(a)) return undefined;
+
+        if (i === 0) {
+            if (Array.isArray(a)) {
+                if (c === 'length') return a.length;
+                try {
+                    let index: number = parseInt(c);
+                    if (isNaN(index)) {
+                        throw new Error(StringFormatter.format('$ is not a number', index));
+                    }
+                    if (index >= a.length) return undefined;
+
+                    return a[index];
+                } catch (err: any) {
+                    throw new ExpressionEvaluationException(
+                        token,
+                        StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
+                        err,
+                    );
+                }
+            }
+
+            this.checkIfObject(token, parts, partNumber, a);
+            return a[c];
+        } else if (c?.startsWith('"')) {
+            if (!c.endsWith('"') || c.length == 1 || c.length == 2)
+                throw new ExpressionEvaluationException(
+                    token,
+                    StringFormatter.format('$ is missing a double quote or empty key found', token),
+                );
+
+            this.checkIfObject(token, parts, partNumber, a);
+            return a[c.substring(1, c.length - 1)];
+        }
+
+        try {
+            let index: number = parseInt(c);
+            if (isNaN(index)) {
+                throw new Error(StringFormatter.format('$ is not a number', index));
+            }
+            if (!Array.isArray(a))
+                throw new ExpressionEvaluationException(
+                    token,
+                    StringFormatter.format(
+                        'Expecting an array with index $ while processing the expression',
+                        index,
+                        token,
+                    ),
+                );
+
+            if (index >= a.length) return undefined;
+
+            return a[index];
+        } catch (err: any) {
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
+                err,
+            );
+        }
+    }
+
+    private checkIfObject(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        jsonElement: any,
+    ): void {
+        if (typeof jsonElement != 'object' || Array.isArray(jsonElement))
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format(
+                    'Unable to retrive $ from $ in the path $',
+                    parts[partNumber],
+                    jsonElement.toString(),
+                    token,
+                ),
+            );
+    }
+
+    protected abstract getValueInternal(token: string): any;
+
+    public abstract getPrefix(): string;
+}

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

@@ -0,0 +1,81 @@
+import { LinkedList } from '../../util/LinkedList';
+import { GraphVertex } from './GraphVertex';
+import { GraphVertexType } from './GraphVertexType';
+
+export class ExecutionGraph<K, T extends GraphVertexType<K>> {
+    private nodeMap: Map<K, GraphVertex<K, T>> = new Map();
+    private isSubGrph: boolean;
+
+    public constructor(isSubGrph: boolean = false) {
+        this.isSubGrph = isSubGrph;
+    }
+
+    public getVerticesData(): T[] {
+        return Array.from(this.nodeMap.values()).map((e) => e.getData());
+    }
+
+    public addVertex(data: T): GraphVertex<K, T> {
+        if (!this.nodeMap.has(data.getUniqueKey())) {
+            let t = new GraphVertex(this, data);
+            this.nodeMap.set(data.getUniqueKey(), t);
+        }
+        return this.nodeMap.get(data.getUniqueKey())!;
+    }
+
+    public getVertex(key: K): GraphVertex<K, T> | undefined {
+        return this.nodeMap.get(key);
+    }
+
+    public getVertexData(key: K): T | undefined {
+        if (this.nodeMap.has(key)) return this.nodeMap.get(key)!.getData();
+        return undefined;
+    }
+
+    public getVerticesWithNoIncomingEdges(): GraphVertex<K, T>[] {
+        return Array.from(this.nodeMap.values()).filter((e) => !e.hasIncomingEdges());
+    }
+
+    public isCyclic(): boolean {
+        let list: LinkedList<GraphVertex<K, T>> = new LinkedList(
+            this.getVerticesWithNoIncomingEdges(),
+        );
+        let visited: Set<K> = new Set();
+
+        let vertex: GraphVertex<K, T>;
+        while (!list.isEmpty()) {
+            if (visited.has(list.getFirst().getKey())) return true;
+
+            vertex = list.removeFirst();
+
+            visited.add(vertex.getKey());
+            if (vertex.hasOutgoingEdges())
+                list.addAll(
+                    Array.from(vertex.getOutVertices().values()).flatMap((e) => Array.from(e)),
+                );
+        }
+
+        return false;
+    }
+
+    public addVertices(values: T[]): void {
+        for (const value of values) this.addVertex(value);
+    }
+
+    public getNodeMap(): Map<K, GraphVertex<K, T>> {
+        return this.nodeMap;
+    }
+
+    public isSubGraph(): boolean {
+        return this.isSubGrph;
+    }
+
+    public toString(): string {
+        return (
+            'Execution Graph : \n' +
+            Array.from(this.nodeMap.values())
+
+                .map((e) => e.toString())
+                .join('\n')
+        );
+    }
+}