@fincity/kirun-js 1.0.0

package/src/engine/function/AbstractFunction.ts

@@ -0,0 +1,76 @@
+import { Schema } from '../json/schema/Schema';
+import { SchemaValidator } from '../json/schema/validator/SchemaValidator';
+import { Event } from '../model/Event';
+import { FunctionOutput } from '../model/FunctionOutput';
+import { FunctionSignature } from '../model/FunctionSignature';
+import { Parameter } from '../model/Parameter';
+import { FunctionExecutionParameters } from '../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../util/NullCheck';
+import { Tuple2 } from '../util/Tuples';
+import { Function } from './Function';
+
+export abstract class AbstractFunction implements Function {
+    protected validateArguments(args: Map<string, any>): Map<string, any> {
+        return Array.from(this.getSignature().getParameters().entries())
+            .map((e) => {
+                let key: string = e[0];
+                let param: Parameter = e[1];
+                let jsonElement: any = args.get(e[0]);
+
+                if (isNullValue(jsonElement)) {
+                    return new Tuple2(
+                        key,
+                        SchemaValidator.validate(
+                            undefined,
+                            param.getSchema(),
+                            undefined,
+                            undefined,
+                        ),
+                    );
+                }
+
+                if (!param?.isVariableArgument())
+                    return new Tuple2(
+                        key,
+                        SchemaValidator.validate(
+                            undefined,
+                            param.getSchema(),
+                            undefined,
+                            jsonElement,
+                        ),
+                    );
+
+                let array: any[] | undefined = undefined;
+
+                if (Array.isArray(jsonElement)) array = jsonElement as any[];
+                else {
+                    array = [];
+                    array.push(jsonElement);
+                }
+
+                for (const je of array) {
+                    SchemaValidator.validate(undefined, param.getSchema(), undefined, je);
+                }
+
+                return new Tuple2(key, jsonElement);
+            })
+            .reduce((a, c) => {
+                a.set(c.getT1(), c.getT2());
+                return a;
+            }, new Map<string, any>());
+    }
+
+    public execute(context: FunctionExecutionParameters): FunctionOutput {
+        context.setArguments(this.validateArguments(context.getArguments()??new Map()));
+        return this.internalExecute(context);
+    }
+
+    public getProbableEventSignature(
+        probableParameters: Map<string, Schema[]>,
+    ): Map<string, Event> {
+        return this.getSignature().getEvents();
+    }
+
+    protected abstract internalExecute(context: FunctionExecutionParameters): FunctionOutput;
+    public abstract getSignature(): FunctionSignature;
+}

package/src/engine/function/Function.ts

@@ -0,0 +1,13 @@
+import { Schema } from '../json/schema/Schema';
+import { Event } from '../model/Event';
+import { FunctionOutput } from '../model/FunctionOutput';
+import { FunctionSignature } from '../model/FunctionSignature';
+import { FunctionExecutionParameters } from '../runtime/FunctionExecutionParameters';
+
+export interface Function {
+    getSignature(): FunctionSignature;
+
+    getProbableEventSignature(probableParameters: Map<string, Schema[]>): Map<string, Event>;
+
+    execute(context: FunctionExecutionParameters): FunctionOutput;
+}

package/src/engine/function/system/GenerateEvent.ts

@@ -0,0 +1,76 @@
+import { KIRuntimeException } from '../../exception/KIRuntimeException';
+import { Schema } from '../../json/schema/Schema';
+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 { ExpressionEvaluator } from '../../runtime/expression/ExpressionEvaluator';
+import { FunctionExecutionParameters } from '../../runtime/FunctionExecutionParameters';
+import { KIRuntime } from '../../runtime/KIRuntime';
+import { isNullValue } from '../../util/NullCheck';
+import { AbstractFunction } from '../AbstractFunction';
+
+const VALUE = 'value';
+const EVENT_NAME = 'eventName';
+const RESULTS = 'results';
+
+const SIGNATURE: FunctionSignature = new FunctionSignature('GenerateEvent')
+    .setNamespace(Namespaces.SYSTEM)
+    .setParameters(
+        new Map([
+            Parameter.ofEntry(EVENT_NAME, Schema.ofString(EVENT_NAME)),
+            Parameter.ofEntry(
+                RESULTS,
+                Schema.ofObject(RESULTS).setProperties(
+                    new Map([
+                        ['name', Schema.ofString('name')],
+                        [VALUE, Parameter.EXPRESSION],
+                    ]),
+                ),
+                true,
+            ),
+        ]),
+    )
+    .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
+
+interface ResultType {
+    name: string;
+    value: any;
+}
+
+export class GenerateEvent extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        const events: Map<string, Map<string, any>[]> | undefined = context.getEvents();
+        const args: Map<string, any> | undefined = context.getArguments();
+
+        const eventName: string = args?.get(EVENT_NAME);
+
+        const map: Map<string, any> = context
+            ?.getArguments()
+            ?.get(RESULTS)
+            .map((e: ResultType) => {
+                let je: any = e[VALUE];
+
+                if (isNullValue(je)) throw new KIRuntimeException('Expect a value object');
+
+                let v: any = je.value;
+                if (je.isExpression)
+                    v = new ExpressionEvaluator(v).evaluate(context.getValuesMap());
+                return [e.name, v];
+            })
+            .reduce((a: Map<string, any>, c: [string, any]) => {
+                a.set(c[0], c[1]);
+                return a;
+            }, new Map());
+
+        if (!events?.has(eventName)) events?.set(eventName, []);
+        events?.get(eventName)?.push(map);
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}

package/src/engine/function/system/If.ts

@@ -0,0 +1,40 @@
+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';
+
+export class If extends AbstractFunction {
+    private static readonly CONDITION: string = 'condition';
+
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('If')
+        .setNamespace(Namespaces.SYSTEM)
+        .setParameters(
+            new Map([Parameter.ofEntry(If.CONDITION, Schema.of(If.CONDITION, SchemaType.BOOLEAN))]),
+        )
+        .setEvents(
+            new Map([
+                Event.eventMapEntry(Event.TRUE, new Map()),
+                Event.eventMapEntry(Event.FALSE, new Map()),
+                Event.outputEventMapEntry(new Map()),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return If.SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        var condition = context.getArguments()?.get(If.CONDITION);
+
+        return new FunctionOutput([
+            EventResult.of(condition ? Event.TRUE : Event.FALSE, new Map()),
+            EventResult.outputOf(new Map()),
+        ]);
+    }
+}

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

@@ -0,0 +1,158 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { TypeUtil } from '../../../json/schema/type/TypeUtil';
+import { Event } from '../../../model/Event';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+
+export abstract class AbstractArrayFunction extends AbstractFunction {
+    public static readonly EVENT_INDEX_NAME: string = 'index';
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+
+    public static readonly EVENT_INDEX: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractArrayFunction.EVENT_INDEX_NAME,
+            Schema.ofInteger(AbstractArrayFunction.EVENT_INDEX_NAME),
+        ),
+    );
+
+    public static readonly EVENT_RESULT_INTEGER: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractArrayFunction.EVENT_RESULT_NAME,
+            Schema.ofInteger(AbstractArrayFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_RESULT_BOOLEAN: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractArrayFunction.EVENT_RESULT_NAME,
+            Schema.ofBoolean(AbstractArrayFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_RESULT_ARRAY: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractArrayFunction.EVENT_RESULT_NAME,
+            Schema.ofArray(
+                AbstractArrayFunction.EVENT_RESULT_NAME,
+                Schema.ofAny(AbstractArrayFunction.EVENT_RESULT_NAME),
+            ),
+        ),
+    );
+
+    public static readonly EVENT_RESULT_EMPTY: Event = new Event(Event.OUTPUT, MapUtil.of());
+
+    public static readonly EVENT_RESULT_ANY: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(this.EVENT_RESULT_NAME, Schema.ofAny(this.EVENT_RESULT_NAME)),
+    );
+
+    public static readonly PARAMETER_INT_LENGTH: Parameter = Parameter.of(
+        'length',
+        Schema.ofInteger('length').setDefaultValue(-1),
+    );
+    public static readonly PARAMETER_ARRAY_FIND: Parameter = Parameter.of(
+        'find',
+        Schema.ofArray('eachFind', Schema.ofAny('eachFind')),
+    );
+    public static readonly PARAMETER_INT_SOURCE_FROM: Parameter = Parameter.of(
+        'srcFrom',
+        Schema.ofInteger('srcFrom').setDefaultValue(0).setMinimum(0),
+    );
+    public static readonly PARAMETER_INT_SECOND_SOURCE_FROM: Parameter = Parameter.of(
+        'secondSrcFrom',
+        Schema.ofInteger('secondSrcFrom').setDefaultValue(0),
+    );
+    public static readonly PARAMETER_INT_FIND_FROM: Parameter = Parameter.of(
+        'findFrom',
+        Schema.ofInteger('findFrom').setDefaultValue(0),
+    );
+
+    public static readonly PARAMETER_INT_OFFSET: Parameter = Parameter.of(
+        'offset',
+        Schema.ofInteger('offset').setDefaultValue(0),
+    );
+
+    public static readonly PARAMETER_ROTATE_LENGTH: Parameter = Parameter.of(
+        'rotateLength',
+        Schema.ofInteger('rotateLength').setDefaultValue(1).setMinimum(1),
+    );
+
+    public static readonly PARAMETER_BOOLEAN_ASCENDING: Parameter = Parameter.of(
+        'ascending',
+        Schema.ofBoolean('ascending').setDefaultValue(false),
+    );
+
+    public static readonly PARAMETER_ARRAY_SOURCE: Parameter = Parameter.of(
+        'source',
+        Schema.ofArray('eachSource', Schema.ofAny('eachSource')),
+    );
+
+    public static readonly PARAMETER_ARRAY_SECOND_SOURCE: Parameter = Parameter.of(
+        'secondSource',
+        Schema.ofArray('eachSecondSource', Schema.ofAny('eachSecondSource')),
+    );
+
+    public static readonly PARAMETER_ARRAY_SOURCE_PRIMITIVE: Parameter = Parameter.of(
+        'source',
+        Schema.ofArray(
+            'eachSource',
+            new Schema()
+                .setName('eachSource')
+                .setType(
+                    TypeUtil.of(
+                        SchemaType.STRING,
+                        SchemaType.NULL,
+                        SchemaType.INTEGER,
+                        SchemaType.FLOAT,
+                        SchemaType.DOUBLE,
+                        SchemaType.LONG,
+                    ),
+                ),
+        ),
+    );
+
+    public static readonly PARAMETER_BOOLEAN_DEEP_COPY: Parameter = Parameter.of(
+        'deepCopy',
+        Schema.ofBoolean('deepCopy').setDefaultValue(true),
+    );
+    public static readonly PARAMETER_ANY: Parameter = Parameter.of(
+        'element',
+        Schema.ofAny('element'),
+    );
+
+    public static readonly PARAMETER_ANY_NOT_NULL: Parameter = Parameter.of(
+        'elementObject',
+        Schema.ofAnyNotNull('elementObject'),
+    );
+
+    public static readonly PARAMETER_ARRAY_RESULT: Parameter = Parameter.of(
+        AbstractArrayFunction.EVENT_RESULT_NAME,
+        Schema.ofArray('eachResult', Schema.ofAny('eachResult')),
+    );
+
+    private signature: FunctionSignature;
+
+    protected constructor(functionName: string, parameters: Parameter[], event: Event) {
+        super();
+
+        const paramMap: Map<string, Parameter> = new Map();
+        for (const param of parameters) paramMap.set(param.getParameterName(), param);
+
+        this.signature = new FunctionSignature(functionName)
+            .setNamespace(Namespaces.SYSTEM_ARRAY)
+            .setParameters(paramMap)
+            .setEvents(MapUtil.of(event.getName(), event));
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+}

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

@@ -0,0 +1,31 @@
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Add extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Add',
+            [
+                AbstractArrayFunction.PARAMETER_ARRAY_SOURCE,
+                AbstractArrayFunction.PARAMETER_ARRAY_SECOND_SOURCE,
+            ],
+            AbstractArrayFunction.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(AbstractArrayFunction.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let secondSource: any[] = context
+            ?.getArguments()
+            ?.get(AbstractArrayFunction.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        source.splice(source.length, 0, ...secondSource);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

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

@@ -0,0 +1,44 @@
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class AddFirst extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'AddFirst',
+            [
+                AbstractArrayFunction.PARAMETER_ARRAY_SOURCE,
+                AbstractArrayFunction.PARAMETER_ANY_NOT_NULL,
+            ],
+            AbstractArrayFunction.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(AbstractArrayFunction.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let input: any = context
+            ?.getArguments()
+            ?.get(AbstractArrayFunction.PARAMETER_ANY_NOT_NULL.getParameterName());
+
+        if (source.length == 0) {
+            source.push(input);
+            return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        }
+
+        source.push(input);
+
+        let len: number = source.length - 1;
+
+        while (len > 0) {
+            let temp: any = source[len - 1];
+            source[len - 1] = source[len];
+            source[len--] = temp;
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

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

@@ -0,0 +1,66 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class BinarySearch extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'BinarySearch',
+            [
+                BinarySearch.PARAMETER_ARRAY_SOURCE,
+                BinarySearch.PARAMETER_INT_SOURCE_FROM,
+                BinarySearch.PARAMETER_ANY_NOT_NULL,
+                BinarySearch.PARAMETER_INT_LENGTH,
+            ],
+            BinarySearch.EVENT_INDEX,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(BinarySearch.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let start: number = context
+            ?.getArguments()
+            ?.get(BinarySearch.PARAMETER_INT_SOURCE_FROM.getParameterName());
+
+        let find: any = context
+            ?.getArguments()
+            ?.get(BinarySearch.PARAMETER_ANY_NOT_NULL.getParameterName());
+
+        let end: number = context
+            ?.getArguments()
+            ?.get(BinarySearch.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (source.length == 0 || start < 0 || start > source.length)
+            throw new KIRuntimeException('Search source array cannot be empty');
+
+        if (end == -1) end = source.length - start;
+
+        end = start + end;
+
+        if (end > source.length)
+            throw new KIRuntimeException(
+                'End point for array cannot be more than the size of the source array',
+            );
+
+        let index: number = -1;
+
+        while (start <= end) {
+            let mid: number = Math.floor((start + end) / 2);
+            if (PrimitiveUtil.compare(source[mid], find) == 0) {
+                index = mid;
+                break;
+            } else if (PrimitiveUtil.compare(source[mid], find) > 0) end = mid - 1;
+            else start = mid + 1;
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[BinarySearch.EVENT_INDEX.getName(), index]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,150 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { ArrayUtil } from '../../../util/ArrayUtil';
+import { MapUtil } from '../../../util/MapUtil';
+import { isNullValue } from '../../../util/NullCheck';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Compare extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Compare',
+            ArrayUtil.of(
+                Compare.PARAMETER_ARRAY_SOURCE,
+                Compare.PARAMETER_INT_SOURCE_FROM,
+                Compare.PARAMETER_ARRAY_FIND,
+                Compare.PARAMETER_INT_FIND_FROM,
+                Compare.PARAMETER_INT_LENGTH,
+            ),
+            Compare.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        var source = context
+            ?.getArguments()
+            ?.get(Compare.PARAMETER_ARRAY_SOURCE.getParameterName());
+        var srcfrom = context
+            ?.getArguments()
+            ?.get(Compare.PARAMETER_INT_SOURCE_FROM.getParameterName());
+        var find = context?.getArguments()?.get(Compare.PARAMETER_ARRAY_FIND.getParameterName());
+        var findfrom = context
+            ?.getArguments()
+            ?.get(Compare.PARAMETER_INT_FIND_FROM.getParameterName());
+        var length = context?.getArguments()?.get(Compare.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (source.length == 0) {
+            throw new KIRuntimeException('Compare source array cannot be empty');
+        }
+
+        if (find.length == 0) {
+            throw new KIRuntimeException('Compare find array cannot be empty');
+        }
+
+        if (length == -1) length = source.length - srcfrom;
+
+        if (srcfrom + length > source.length)
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Source array size $ is less than comparing size $',
+                    source.length,
+                    srcfrom + length,
+                ),
+            );
+
+        if (findfrom + length > find.length)
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Find array size $ is less than comparing size $',
+                    find.length,
+                    findfrom + length,
+                ),
+            );
+
+        return new FunctionOutput(
+            ArrayUtil.of(
+                EventResult.outputOf(
+                    MapUtil.of(
+                        Compare.EVENT_RESULT_NAME,
+                        this.compare(
+                            source,
+                            srcfrom,
+                            srcfrom + length,
+                            find,
+                            findfrom,
+                            findfrom + length,
+                        ),
+                    ),
+                ),
+            ),
+        );
+    }
+
+    public compare(
+        source: any[],
+        srcfrom: number,
+        srcto: number,
+        find: any[],
+        findfrom: number,
+        findto: number,
+    ): number {
+        if (srcto < srcfrom) {
+            let x: number = srcfrom;
+            srcfrom = srcto;
+            srcto = x;
+        }
+
+        if (findto < findfrom) {
+            let x: number = findfrom;
+            findfrom = findto;
+            findto = x;
+        }
+
+        if (srcto - srcfrom != findto - findfrom) {
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Cannot compare uneven arrays from $ to $ in source array with $ to $ in find array',
+                    srcto,
+                    srcfrom,
+                    findto,
+                    findfrom,
+                ),
+            );
+        }
+
+        for (let i = srcfrom, j = findfrom; i < srcto; i++, j++) {
+            let x: number = 1;
+
+            if (isNullValue(source[i]) || isNullValue(find[j])) {
+                let s: boolean = isNullValue(source[i]);
+                let f: boolean = isNullValue(find[j]);
+
+                if (s == f) x = 0;
+                else if (s) x = -1;
+            } else {
+                let typs: string = typeof source[i];
+                let typf: string = typeof find[j];
+
+                if (typs === 'object' || typf === 'object') {
+                    x = 1;
+                } else if (typs === 'string' || typf === 'string') {
+                    let s = '' + source[i];
+                    let f = '' + find[j];
+                    if (s === f) x = 0;
+                    else if (s < f) x = -1;
+                } else if (typs === 'boolean' || typf === 'boolean') {
+                    x = typs == typf ? 0 : 1;
+                } else if (typs === 'number' && typf === 'number') {
+                    x = source[i] - find[j];
+                }
+            }
+
+            if (x != 0) return x;
+        }
+
+        return 0;
+    }
+}