@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,118 @@
+import { LinkedList } from '../../util/LinkedList';
+import { Tuple2 } from '../../util/Tuples';
+import { ExecutionGraph } from './ExecutionGraph';
+import { GraphVertexType } from './GraphVertexType';
+
+export class GraphVertex<K, T extends GraphVertexType<K>> {
+    private data: T;
+    private outVertices: Map<string, Set<GraphVertex<K, T>>> = new Map();
+    private inVertices: Set<Tuple2<GraphVertex<K, T>, string>> = new Set();
+    private graph: ExecutionGraph<K, T>;
+
+    public constructor(graph: ExecutionGraph<K, T>, data: T) {
+        this.data = data;
+        this.graph = graph;
+    }
+
+    public getData(): T {
+        return this.data;
+    }
+    public setData(data: T): GraphVertex<K, T> {
+        this.data = data;
+        return this;
+    }
+    public getOutVertices(): Map<string, Set<GraphVertex<K, T>>> {
+        return this.outVertices;
+    }
+    public setOutVertices(outVertices: Map<string, Set<GraphVertex<K, T>>>): GraphVertex<K, T> {
+        this.outVertices = outVertices;
+        return this;
+    }
+    public getInVertices(): Set<Tuple2<GraphVertex<K, T>, string>> {
+        return this.inVertices;
+    }
+    public setInVertices(inVertices: Set<Tuple2<GraphVertex<K, T>, string>>): GraphVertex<K, T> {
+        this.inVertices = inVertices;
+        return this;
+    }
+    public getGraph(): ExecutionGraph<K, T> {
+        return this.graph;
+    }
+    public setGraph(graph: ExecutionGraph<K, T>): GraphVertex<K, T> {
+        this.graph = graph;
+        return this;
+    }
+
+    public getKey(): K {
+        return this.data.getUniqueKey();
+    }
+
+    // public addOutEdgeTo(type: string, data:T) :GraphVertex<K, T> {
+    // 	return this.addOutEdgeTo(type, this.graph.addVertex(data));
+    // }
+
+    // public GraphVertex<K, T> addInEdgeTo(T data, String type) {
+    // 	return this.addInEdgeTo(this.graph.addVertex(data), type);
+    // }
+
+    public addOutEdgeTo(type: string, vertex: GraphVertex<K, T>): GraphVertex<K, T> {
+        if (!this.outVertices.has(type)) this.outVertices.set(type, new Set());
+        this.outVertices.get(type)!.add(vertex);
+        vertex.inVertices.add(new Tuple2(this, type));
+        return vertex;
+    }
+
+    public addInEdgeTo(vertex: GraphVertex<K, T>, type: string): GraphVertex<K, T> {
+        this.inVertices.add(new Tuple2(vertex, type));
+        if (!vertex.outVertices.has(type)) vertex.outVertices.set(type, new Set());
+        vertex.outVertices.get(type)!.add(this);
+        return vertex;
+    }
+
+    public hasIncomingEdges(): boolean {
+        return !!this.inVertices.size;
+    }
+
+    public hasOutgoingEdges(): boolean {
+        return !!this.outVertices.size;
+    }
+
+    public getSubGraphOfType(type: string): ExecutionGraph<K, T> {
+        let subGraph: ExecutionGraph<K, T> = new ExecutionGraph(true);
+
+        var typeVertices = new LinkedList(Array.from(this.outVertices.get(type) ?? []));
+
+        typeVertices.map((e) => e.getData()).forEach((e) => subGraph.addVertex(e));
+
+        while (!typeVertices.isEmpty()) {
+            var vertex = typeVertices.pop();
+            Array.from(vertex.outVertices.values())
+                .flatMap((e) => Array.from(e))
+                .forEach((e) => {
+                    subGraph.addVertex(e.getData());
+                    typeVertices.add(e);
+                });
+        }
+
+        return subGraph;
+    }
+
+    public toString(): string {
+        var ins = Array.from(this.getInVertices())
+            .map((e) => e.getT1().getKey() + '(' + e.getT2() + ')')
+            .join(', ');
+
+        var outs = Array.from(this.outVertices.entries())
+            .map(
+                ([key, value]) =>
+                    key +
+                    ': ' +
+                    Array.from(value)
+                        .map((e) => e.getKey())
+                        .join(','),
+            )
+            .join('\n\t\t');
+
+        return this.getKey() + ':\n\tIn: ' + ins + '\n\tOut: \n\t\t' + outs;
+    }
+}

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

@@ -0,0 +1,4 @@
+export interface GraphVertexType<K> {
+    getUniqueKey(): K;
+    getDepenedencies(): Set<string>;
+}

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

@@ -0,0 +1,22 @@
+import { TokenValueExtractor } from '../expression/tokenextractor/TokenValueExtractor';
+
+export class ArgumentsTokenValueExtractor extends TokenValueExtractor {
+    public static readonly PREFIX: string = 'Arguments.';
+
+    private args: Map<string, any>;
+
+    public constructor(args: Map<string, any>) {
+        super();
+        this.args = args;
+    }
+
+    protected getValueInternal(token: string): any {
+        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+
+        return this.retrieveElementFrom(token, parts, 2, this.args.get(parts[1]));
+    }
+
+    public getPrefix(): string {
+        return ArgumentsTokenValueExtractor.PREFIX;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { ContextElement } from '../ContextElement';
+import { TokenValueExtractor } from '../expression/tokenextractor/TokenValueExtractor';
+
+export class ContextTokenValueExtractor extends TokenValueExtractor {
+    public static readonly PREFIX: string = 'Context.';
+
+    private context: Map<string, ContextElement>;
+
+    public constructor(context: Map<string, ContextElement>) {
+        super();
+        this.context = context;
+    }
+
+    protected getValueInternal(token: string): any {
+        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+
+        let key: string = parts[1];
+        let bIndex: number = key.indexOf('[');
+        let fromIndex = 2;
+        if (bIndex != -1) {
+            key = parts[1].substring(0, bIndex);
+            parts[1] = parts[1].substring(bIndex);
+            fromIndex = 1;
+        }
+
+        return this.retrieveElementFrom(
+            token,
+            parts,
+            fromIndex,
+            this.context.get(key)?.getElement(),
+        );
+    }
+
+    public getPrefix(): string {
+        return ContextTokenValueExtractor.PREFIX;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { TokenValueExtractor } from '../expression/tokenextractor/TokenValueExtractor';
+
+export class OutputMapTokenValueExtractor extends TokenValueExtractor {
+    public static readonly PREFIX: string = 'Steps.';
+
+    private output: Map<string, Map<string, Map<string, any>>>;
+
+    public constructor(output: Map<string, Map<string, Map<string, any>>>) {
+        super();
+        this.output = output;
+    }
+
+    protected getValueInternal(token: string): any {
+        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+
+        let ind: number = 1;
+
+        let events: Map<string, Map<string, any>> | undefined = this.output.get(parts[ind++]);
+        if (!events || ind >= parts.length) return undefined;
+
+        let eachEvent: Map<string, any> | undefined = events.get(parts[ind++]);
+        if (!eachEvent || ind >= parts.length) return undefined;
+
+        let element: any = eachEvent.get(parts[ind++]);
+
+        return this.retrieveElementFrom(token, parts, ind, element);
+    }
+
+    public getPrefix(): string {
+        return OutputMapTokenValueExtractor.PREFIX;
+    }
+}

package/src/engine/util/ArrayUtil.ts

@@ -0,0 +1,23 @@
+export class ArrayUtil {
+    public static removeAListFrom(source: any[], removeList: any[]): void {
+        if (!removeList || !source || !source.length || !removeList.length) return;
+
+        const e: Set<any> = new Set<any>(removeList);
+
+        for (let i = 0; i < source.length; i++) {
+            if (!e.has(source[i])) continue;
+            source.splice(i, 1);
+            i--;
+        }
+    }
+
+    public static of<K>(...k: K[]): K[] {
+        const copy: K[] = new Array(k.length);
+
+        for (let i = 0; i < k.length; i++) copy[i] = k[i];
+
+        return copy;
+    }
+
+    private constructor() {}
+}

package/src/engine/util/LinkedList.ts

@@ -0,0 +1,229 @@
+import { KIRuntimeException } from '../exception/KIRuntimeException';
+import { StringFormatter } from './string/StringFormatter';
+
+export class LinkedList<T> {
+    private head?: Node<T> = undefined;
+    private tail?: Node<T> = undefined;
+    public length: number = 0;
+
+    public constructor(list?: T[]) {
+        if (list?.length) {
+            for (const t of list) {
+                if (!this.head) {
+                    this.tail = this.head = new Node(t);
+                } else {
+                    const node = new Node(t, this.tail);
+                    this.tail!.next = node;
+                    this.tail = node;
+                }
+            }
+            this.length = list.length;
+        }
+    }
+
+    public push(value: T) {
+        const node = new Node(value, undefined, this.head);
+        if (!this.head) {
+            this.tail = this.head = node;
+        } else {
+            this.head.previous = node;
+            this.head = node;
+        }
+        this.length++;
+    }
+
+    public pop(): T {
+        if (!this.head) {
+            throw Error("List is empty and cannot pop further.");
+        }
+        const value: T = this.head!.value;
+        this.length--;
+
+        if (this.head == this.tail) {
+            this.head = this.tail = undefined;
+            return value;
+        }
+
+        const node: Node<T> = this.head!;
+
+        this.head = node.next;
+        node.next = undefined;
+        node.previous = undefined;
+        this.head!.previous = undefined;
+        return value;
+    }
+
+    public isEmpty(): boolean {
+        return !this.length;
+    }
+
+    public size(): number {
+        return this.length;
+    }
+
+    public get(index: number): T {
+        if (index < 0 || index >= this.length) {
+            throw new Error(`${index} is out of bounds [0,${this.length}]`);
+        }
+
+        let x = this.head;
+        while (index > 0) {
+            x = this.head!.next;
+            --index;
+        }
+
+        return x!.value;
+    }
+
+    public set(index: number, value: T): LinkedList<T> {
+        if (index < 0 || index >= this.length)
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Index $ out of bound to set the value in linked list.',
+                    index,
+                ),
+            );
+
+        let x = this.head;
+        while (index > 0) {
+            x = this.head!.next;
+            --index;
+        }
+        x!.value = value;
+        return this;
+    }
+
+    public toString(): string {
+        let x = this.head;
+        let str: string = '';
+
+        while (x) {
+            str += x.value;
+            x = x.next;
+            if (x) str += ', ';
+        }
+
+        return `[${str}]`;
+    }
+
+    public toArray(): T[] {
+        let arr: T[] = [];
+
+        let x = this.head;
+
+        while (x) {
+            arr.push(x.value);
+            x = x.next;
+        }
+
+        return arr;
+    }
+
+    public peek(): T {
+        if (!this.head) {
+            throw new Error("List is empty so cannot peak");
+        }
+
+        return this.head.value;
+    }
+
+    public peekLast(): T {
+        if (!this.tail) {
+            throw new Error("List is empty so cannot peak");
+        }
+        return this.tail.value;
+    }
+
+    public getFirst(): T {
+        if (!this.head){
+            throw new Error("List is empty so cannot get first");
+        }
+        return this.head.value;
+    }
+
+    public removeFirst(): T {
+        return this.pop();
+    }
+
+    public removeLast(): T {
+        if (!this.tail) {
+            throw new Error("List is empty so cannot remove");
+        }
+        --this.length;
+        const v: T = this.tail.value;
+        if (this.length == 0) {
+            this.head = this.tail = undefined;
+        } else {
+            const n = this.tail.previous;
+            n!.next = undefined;
+            this.tail.previous = undefined;
+            this.tail = n;
+        }
+
+        return v;
+    }
+
+    public addAll(list: T[]): LinkedList<T> {
+        if (!list || !list.length) return this;
+        list.forEach(this.add.bind(this));
+        return this;
+    }
+
+    public add(t: T): LinkedList<T> {
+        ++this.length;
+        if (!this.tail && !this.head) {
+            this.head = this.tail = new Node(t);
+        } else if (this.head === this.tail) {
+            this.tail = new Node(t, this.head);
+            this.head!.next = this.tail;
+        } else {
+            this.tail = new Node(t, this.tail);
+            this.tail.previous!.next = this.tail;
+        }
+        return this;
+    }
+
+    public map<U>(
+        callbackfn: (value: T, index: number) => U,
+        thisArg?: any,
+    ): LinkedList<U> {
+        let newList: LinkedList<U> = new LinkedList();
+
+        let x = this.head;
+
+        let index: number = 0;
+        while (x) {
+            newList.add(callbackfn(x.value, index));
+            x = x.next;
+            ++index;
+        }
+
+        return newList;
+    }
+
+    public forEach(callbackfn: (value: T, index: number) => void, thisArg?: any): void {
+        let x = this.head;
+        let index: number = 0;
+        while (x) {
+            callbackfn(x.value, index);
+            x = x.next;
+            ++index;
+        }
+    }
+}
+
+class Node<T> {
+    public value: T;
+    public next?: Node<T>;
+    public previous?: Node<T>;
+
+    constructor(t: T, previous?: Node<T>, next?: Node<T>) {
+        this.value = t;
+        this.next = next;
+        this.previous = previous;
+    }
+
+    public toString(): string {
+        return '' + this.value;
+    }
+}

package/src/engine/util/MapUtil.ts

@@ -0,0 +1,86 @@
+import { isNullValue } from './NullCheck';
+
+export class MapUtil {
+    public static of<K, V>(
+        k1?: K,
+        v1?: V,
+        k2?: K,
+        v2?: V,
+        k3?: K,
+        v3?: V,
+        k4?: K,
+        v4?: V,
+        k5?: K,
+        v5?: V,
+        k6?: K,
+        v6?: V,
+        k7?: K,
+        v7?: V,
+        k8?: K,
+        v8?: V,
+        k9?: K,
+        v9?: V,
+        k10?: K,
+        v10?: V,
+    ): Map<K, V> {
+        const map: Map<K, V> = new Map();
+
+        if (k1 && v1) map.set(k1, v1);
+
+        if (k2 && v2) map.set(k2, v2);
+
+        if (k3 && v3) map.set(k3, v3);
+
+        if (k4 && v4) map.set(k4, v4);
+
+        if (k5 && v5) map.set(k5, v5);
+
+        if (k6 && v6) map.set(k6, v6);
+
+        if (k7 && v7) map.set(k7, v7);
+
+        if (k8 && v8) map.set(k8, v8);
+
+        if (k9 && v9) map.set(k9, v9);
+
+        if (k10 && v10) map.set(k10, v10);
+
+        return map;
+    }
+
+    public static ofArrayEntries<K, V>(...entry: [K, V][]): Map<K, V> {
+        const map: Map<K, V> = new Map();
+
+        for (const [k, v] of entry) {
+            map.set(k, v);
+        }
+
+        return map;
+    }
+
+    public static entry<K, V>(k: K, v: V): MapEntry<K, V> {
+        return new MapEntry(k, v);
+    }
+
+    public static ofEntries<K, V>(...entry: MapEntry<K, V>[]): Map<K, V> {
+        const map: Map<K, V> = new Map();
+
+        for (const eachEntry of entry) {
+            map.set(eachEntry.k, eachEntry.v);
+        }
+
+        return map;
+    }
+
+    private constructor() {}
+}
+
+export class MapEntry<K, V> {
+    k: K;
+    v: V;
+
+    public constructor(k: K, v: V) {
+        this.k = k;
+        this.v = v;
+    }
+}

package/src/engine/util/NullCheck.ts

@@ -0,0 +1,3 @@
+export function isNullValue(v: any): boolean {
+    return v === null || v === undefined;
+}

package/src/engine/util/Tuples.ts

@@ -0,0 +1,43 @@
+export class Tuple2<F, S> {
+    private f: F;
+    private s: S;
+
+    constructor(f: F, s: S) {
+        this.f = f;
+        this.s = s;
+    }
+
+    public getT1(): F {
+        return this.f;
+    }
+
+    public getT2(): S {
+        return this.s;
+    }
+}
+
+export class Tuple3<F, S, T> extends Tuple2<F, S> {
+    private t: T;
+
+    constructor(f: F, s: S, t: T) {
+        super(f, s);
+        this.t = t;
+    }
+
+    public getT3(): T {
+        return this.t;
+    }
+}
+
+export class Tuple4<F, S, T, FR> extends Tuple3<F, S, T> {
+    private fr: FR;
+
+    constructor(f: F, s: S, t: T, fr: FR) {
+        super(f, s, t);
+        this.fr = fr;
+    }
+
+    public getT4(): FR {
+        return this.fr;
+    }
+}