@fincity/kirun-js 1.0.0

package/src/engine/function/system/context/SetFunction.ts

@@ -0,0 +1,244 @@
+import { ExecutionException } from '../../../exception/ExecutionException';
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+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 { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { ParameterType } from '../../../model/ParameterType';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { ContextElement } from '../../../runtime/ContextElement';
+import { Expression } from '../../../runtime/expression/Expression';
+import { ExpressionEvaluator } from '../../../runtime/expression/ExpressionEvaluator';
+import { ExpressionToken } from '../../../runtime/expression/ExpressionToken';
+import { ExpressionTokenValue } from '../../../runtime/expression/ExpressionTokenValue';
+import { Operation } from '../../../runtime/expression/Operation';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { LinkedList } from '../../../util/LinkedList';
+import { isNullValue } from '../../../util/NullCheck';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { StringUtil } from '../../../util/string/StringUtil';
+import { Tuple2 } from '../../../util/Tuples';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const NAME = 'name';
+const VALUE = 'value';
+const SIGNATURE = new FunctionSignature('Set')
+    .setNamespace(Namespaces.SYSTEM_CTX)
+    .setParameters(
+        new Map([
+            Parameter.ofEntry(
+                NAME,
+                new Schema().setName(NAME).setType(TypeUtil.of(SchemaType.STRING)).setMinLength(1),
+                false,
+                ParameterType.CONSTANT,
+            ),
+            Parameter.ofEntry(VALUE, Schema.ofAny(VALUE)),
+        ]),
+    )
+    .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
+
+export class SetFunction extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let key: string = context?.getArguments()?.get(NAME);
+
+        if (StringUtil.isNullOrBlank(key)) {
+            throw new KIRuntimeException(
+                'Empty string is not a valid name for the context element',
+            );
+        }
+
+        let value: any = context?.getArguments()?.get(VALUE);
+
+        const exp: Expression = new Expression(key);
+
+        const contextToken: ExpressionToken = exp.getTokens().peekLast();
+
+        if (
+            !contextToken.getExpression().startsWith('Context') ||
+            contextToken instanceof Expression ||
+            (contextToken instanceof ExpressionTokenValue &&
+                !(contextToken as ExpressionTokenValue)
+                    .getElement()
+                    .toString()
+                    .startsWith('Context'))
+        ) {
+            throw new ExecutionException(
+                StringFormatter.format('The context path $ is not a valid path in context', key),
+            );
+        }
+
+        for (const op of exp.getOperations().toArray()) {
+            if (op == Operation.ARRAY_OPERATOR || op == Operation.OBJECT_OPERATOR) continue;
+
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Expected a reference to the context location, but found an expression $',
+                    key,
+                ),
+            );
+        }
+
+        for (let i = 0; i < exp.getTokens().size(); i++) {
+            let ex = exp.getTokens().get(i);
+            if (ex instanceof Expression)
+                exp.getTokens().set(
+                    i,
+                    new ExpressionTokenValue(
+                        key,
+                        new ExpressionEvaluator(ex as Expression).evaluate(context.getValuesMap()),
+                    ),
+                );
+        }
+
+        let tokens: LinkedList<ExpressionToken> = exp.getTokens();
+        tokens.removeLast();
+        let ops: LinkedList<Operation> = exp.getOperations();
+        ops.removeLast();
+        let ce: ContextElement | undefined = context
+            .getContext()
+            ?.get(tokens.removeLast().getExpression());
+
+        if (!ce) {
+            throw new KIRuntimeException(
+                StringFormatter.format("Context doesn't have any element with name '$' ", key),
+            );
+        }
+
+        if (ops.isEmpty()) {
+            ce.setElement(value);
+            return new FunctionOutput([EventResult.outputOf(new Map())]);
+        }
+
+        let el: any = ce.getElement();
+
+        while (ops.size() > 1) {
+            if (isNullValue(el)) {
+                throw new KIRuntimeException(
+                    StringFormatter.format('Unable to set the context in the path $', key),
+                );
+            }
+
+            const op: Operation = ops.removeLast();
+            const token: ExpressionToken = tokens.removeLast();
+            if (op == Operation.OBJECT_OPERATOR) {
+                if (typeof el != 'object') {
+                    throw new KIRuntimeException(
+                        StringFormatter.format('$ has no object in the context', key),
+                    );
+                }
+
+                let mem: string | undefined = undefined;
+                if (token instanceof ExpressionTokenValue)
+                    mem = (token as ExpressionTokenValue).getTokenValue().getAsString();
+                else mem = token.getExpression();
+
+                el = el.getAsJsonObject().get(mem);
+            } else {
+                const je: any =
+                    token instanceof ExpressionTokenValue
+                        ? (token as ExpressionTokenValue).getElement()
+                        : token.getExpression();
+
+                if (Array.isArray(je) || typeof je === 'object') {
+                    throw new KIRuntimeException(
+                        StringFormatter.format(
+                            'Cannot extract json with key $ from the object $',
+                            je,
+                            el,
+                        ),
+                    );
+                }
+
+                if (Array.isArray(el)) {
+                    const prim: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitive(je);
+
+                    if (prim.getT1() != SchemaType.INTEGER || prim.getT1() != SchemaType.LONG) {
+                        throw new KIRuntimeException(
+                            StringFormatter.format('Expecting a numerical index but found $', je),
+                        );
+                    }
+
+                    let index = prim.getT2() as number;
+                    if (index >= el.length)
+                        throw new KIRuntimeException(
+                            StringFormatter.format('Index out of bound while accessing $', key),
+                        );
+                    el = el[index];
+                } else {
+                    const mem: string = je.getAsString();
+                    el = el[mem];
+                }
+            }
+        }
+
+        if (el == null) {
+            throw new KIRuntimeException(
+                StringFormatter.format('Unable to set the context in the path $', key),
+            );
+        }
+
+        const op: Operation = ops.removeLast();
+        const token: ExpressionToken = tokens.removeLast();
+
+        // TODO: Here I need to validate the schema of the value I have to put in the
+        // context.
+
+        if (op == Operation.OBJECT_OPERATOR) {
+            if (typeof el == 'object') {
+                throw new KIRuntimeException(
+                    StringFormatter.format('$ has no object in the context', key),
+                );
+            }
+
+            let mem: string;
+            if (token instanceof ExpressionTokenValue)
+                mem = (token as ExpressionTokenValue).getTokenValue();
+            else mem = token.getExpression();
+
+            el[mem] = value;
+        } else {
+            let je =
+                token instanceof ExpressionTokenValue
+                    ? (token as ExpressionTokenValue).getElement()
+                    : token.getExpression();
+
+            if (Array.isArray(je) || typeof je === 'object') {
+                throw new KIRuntimeException(
+                    StringFormatter.format(
+                        'Cannot extract json with key $ from the object $',
+                        je,
+                        el,
+                    ),
+                );
+            }
+
+            if (Array.isArray(el)) {
+                const prim: Tuple2<SchemaType, any> = PrimitiveUtil.findPrimitive(je);
+
+                if (prim.getT1() != SchemaType.INTEGER && prim.getT1() != SchemaType.LONG) {
+                    throw new KIRuntimeException(
+                        StringFormatter.format('Expecting a numerical index but found $', je),
+                    );
+                }
+
+                let index = prim.getT2() as number;
+                while (index >= el.length) el.push(undefined);
+                el[index] = value;
+            } else {
+                let mem: string = je;
+                el[mem] = value;
+            }
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}

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

@@ -0,0 +1,55 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const COUNT = 'count';
+const VALUE = 'value';
+const INDEX = 'index';
+
+const SIGNATURE = new FunctionSignature('CountLoop')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(
+        new Map([
+            Parameter.ofEntry(COUNT, Schema.of(COUNT, SchemaType.INTEGER).setDefaultValue(1)),
+        ]),
+    )
+    .setEvents(
+        new Map([
+            Event.eventMapEntry(
+                Event.ITERATION,
+                new Map([[INDEX, Schema.of(INDEX, SchemaType.INTEGER)]]),
+            ),
+            Event.outputEventMapEntry(new Map([[VALUE, Schema.of(VALUE, SchemaType.INTEGER)]])),
+        ]),
+    );
+
+export class CountLoop extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let count: number = context.getArguments()?.get(COUNT);
+        let current = 0;
+
+        return new FunctionOutput({
+            next(): EventResult {
+                if (current >= count) {
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
+                }
+
+                const eve = EventResult.of(Event.ITERATION, new Map([[INDEX, current]]));
+                ++current;
+
+                return eve;
+            },
+        });
+    }
+}

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

@@ -0,0 +1,120 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const FROM = 'from';
+const TO = 'to';
+const STEP = 'step';
+const VALUE = 'value';
+const INDEX = 'index';
+
+const SIGNATURE = new FunctionSignature('RangeLoop')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(
+        new Map([
+            Parameter.ofEntry(
+                FROM,
+                Schema.of(
+                    FROM,
+                    SchemaType.INTEGER,
+                    SchemaType.LONG,
+                    SchemaType.FLOAT,
+                    SchemaType.DOUBLE,
+                ).setDefaultValue(0),
+            ),
+            Parameter.ofEntry(
+                TO,
+                Schema.of(
+                    TO,
+                    SchemaType.INTEGER,
+                    SchemaType.LONG,
+                    SchemaType.FLOAT,
+                    SchemaType.DOUBLE,
+                ).setDefaultValue(1),
+            ),
+            Parameter.ofEntry(
+                STEP,
+                Schema.of(
+                    STEP,
+                    SchemaType.INTEGER,
+                    SchemaType.LONG,
+                    SchemaType.FLOAT,
+                    SchemaType.DOUBLE,
+                )
+                    .setDefaultValue(1)
+                    .setNot(new Schema().setConstant(0)),
+            ),
+        ]),
+    )
+    .setEvents(
+        new Map([
+            Event.eventMapEntry(
+                Event.ITERATION,
+                new Map([
+                    [
+                        INDEX,
+                        Schema.of(
+                            INDEX,
+                            SchemaType.INTEGER,
+                            SchemaType.LONG,
+                            SchemaType.FLOAT,
+                            SchemaType.DOUBLE,
+                        ),
+                    ],
+                ]),
+            ),
+            Event.outputEventMapEntry(
+                new Map([
+                    [
+                        VALUE,
+                        Schema.of(
+                            VALUE,
+                            SchemaType.INTEGER,
+                            SchemaType.LONG,
+                            SchemaType.FLOAT,
+                            SchemaType.DOUBLE,
+                        ),
+                    ],
+                ]),
+            ),
+        ]),
+    );
+
+export class RangeLoop extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let from: number = context.getArguments()?.get(FROM);
+        let to: number = context.getArguments()?.get(TO);
+        let step: number = context.getArguments()?.get(STEP);
+
+        const forward = step > 0;
+        let current: number = from;
+        let done: boolean = false;
+
+        return new FunctionOutput({
+            next(): EventResult | undefined {
+                if (done) return undefined;
+
+                if ((forward && current >= to) || (!forward && current <= to)) {
+                    done = true;
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
+                }
+
+                const eve = EventResult.of(Event.ITERATION, new Map([[INDEX, current]]));
+                current += step;
+
+                return eve;
+            },
+        });
+    }
+}

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

@@ -0,0 +1,34 @@
+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 { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const VALUE = 'value';
+
+const SIGNATURE = new FunctionSignature('Add')
+    .setNamespace(Namespaces.MATH)
+    .setParameters(
+        new Map([
+            [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
+        ]),
+    )
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
+
+export class Add extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let nums: number[] = context.getArguments()?.get(VALUE);
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[VALUE, nums.reduce((a, c) => (a += c), 0)]])),
+        ]);
+    }
+}

package/src/engine/function/system/math/GenericMathFunction.ts

@@ -0,0 +1,80 @@
+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 { 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 { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const VALUE = 'value';
+const VALUE1 = 'value1';
+const VALUE2 = 'value2';
+
+const paramFunctions = [
+    () => {
+        return new Map([
+            [VALUE,new Parameter(VALUE,Schema.ofNumber(VALUE))],
+        ]);
+    },
+    () => {
+        return new Map([
+            [VALUE1, new Parameter(VALUE1, Schema.ofNumber(VALUE1))],
+            [VALUE2, new Parameter(VALUE2, Schema.ofNumber(VALUE2))],
+        ]);
+    },
+];
+
+export class GenericMathFunction extends AbstractFunction {
+    private signature: FunctionSignature;
+    private parametersNumber: number;
+    private mathFunction: (v1: number, v2?: number) => number;
+
+    public constructor(
+        functionName: string,
+        mathFunction: (v1: number, v2?: number) => number,
+        parametersNumber: number = 1,
+        ...returnType: SchemaType[]
+    ) {
+        super();
+        if (!returnType || !returnType.length) returnType = [SchemaType.DOUBLE];
+        this.parametersNumber = parametersNumber;
+        this.mathFunction = mathFunction;
+        this.signature = new FunctionSignature(functionName)
+            .setNamespace(Namespaces.MATH)
+            .setParameters(paramFunctions[parametersNumber - 1]())
+            .setEvents(
+                new Map([
+                    Event.outputEventMapEntry(
+                        new Map([
+                            [
+                                VALUE,
+                                new Schema().setType(TypeUtil.of(...returnType)).setName(VALUE),
+                            ],
+                        ]),
+                    ) as [string, Event],
+                ]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let v1 = PrimitiveUtil.findPrimitiveNumberType(
+            context.getArguments()?.get(this.parametersNumber == 1 ? VALUE : VALUE1),
+        ).getT2();
+        let v2;
+        if (this.parametersNumber == 2)
+            v2 = PrimitiveUtil.findPrimitiveNumberType(context.getArguments()?.get(VALUE2)).getT2();
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[VALUE, this.mathFunction.call(this, v1, v2)]])),
+        ]);
+    }
+}

package/src/engine/function/system/math/Hypotenuse.ts

@@ -0,0 +1,57 @@
+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 { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const VALUE = 'value';
+
+export class Hypotenuse extends AbstractFunction {
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Hypotenuse')
+        .setNamespace(Namespaces.MATH)
+        .setParameters(
+            new Map([
+                [
+                    VALUE,
+                   new Parameter(VALUE,Schema.ofNumber(VALUE))
+                        .setVariableArgument(true),
+                ],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    new Map([
+                        [
+                            VALUE,
+                            new Schema().setType(TypeUtil.of(SchemaType.DOUBLE)).setName(VALUE),
+                        ],
+                    ]),
+                ) as [string, Event],
+            ]),
+        );
+
+    public constructor() {
+        super();
+    }
+
+    public getSignature(): FunctionSignature {
+        return Hypotenuse.SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let nums: number[] = context.getArguments()?.get(VALUE);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                new Map([[VALUE, Math.sqrt(nums.reduce((a, c) => (a += c * c), 0))]]),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/math/MathFunctionRepository.ts

@@ -0,0 +1,63 @@
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { Repository } from '../../../Repository';
+import { Function } from '../../Function';
+import { Add } from './Add';
+import { GenericMathFunction } from './GenericMathFunction';
+import { Hypotenuse } from './Hypotenuse';
+import { Maximum } from './Maximum';
+import { Minimum } from './Minimum';
+import { Random } from './Random';
+
+const functionObjectsIndex: any = {
+    Absolute: new GenericMathFunction(
+        'Absolute',
+        (v) => Math.abs(v),
+        1,
+        SchemaType.INTEGER,
+        SchemaType.LONG,
+        SchemaType.FLOAT,
+        SchemaType.DOUBLE,
+    ),
+    ACosine: new GenericMathFunction('ArcCosine', (v) => Math.acos(v)),
+    ASine: new GenericMathFunction('ArcSine', (v) => Math.asin(v)),
+    ATangent: new GenericMathFunction('ArcTangent', (v) => Math.atan(v)),
+    Ceiling: new GenericMathFunction('Ceiling', (v) => Math.ceil(v)),
+    Cosine: new GenericMathFunction('Cosine', (v) => Math.cos(v)),
+    CosineH: new GenericMathFunction('HyperbolicCosine', (v) => Math.cosh(v)),
+    CubeRoot: new GenericMathFunction('CubeRoot', (v) => Math.cbrt(v)),
+    Exponential: new GenericMathFunction('Exponential', (v) => Math.exp(v)),
+    Expm1: new GenericMathFunction('ExponentialMinus1', (v) => Math.expm1(v)),
+    Floor: new GenericMathFunction('Floor', (v) => Math.floor(v)),
+    Log: new GenericMathFunction('LogNatural', (v) => Math.log(v)),
+    Log10: new GenericMathFunction('Log10', (v) => Math.log10(v)),
+    Round: new GenericMathFunction(
+        'Round',
+        (v) => Math.round(v),
+        1,
+        SchemaType.INTEGER,
+        SchemaType.LONG,
+    ),
+    Sine: new GenericMathFunction('Sine', (v) => Math.sin(v)),
+    SineH: new GenericMathFunction('HyperbolicSine', (v) => Math.sinh(v)),
+    Tangent: new GenericMathFunction('Tangent', (v) => Math.tan(v)),
+    TangentH: new GenericMathFunction('HyperbolicTangent', (v) => Math.tanh(v)),
+    ToDegrees: new GenericMathFunction('ToDegrees', (v) => v * (Math.PI / 180)),
+    ToRadians: new GenericMathFunction('ToRadians', (v) => v * (180 / Math.PI)),
+    SquareRoot: new GenericMathFunction('SquareRoot', (v) => Math.sqrt(v)),
+    ArcTangent: new GenericMathFunction('ArcTangent2', (v1, v2) => Math.atan2(v1, v2!), 2),
+    Power: new GenericMathFunction('Power', (v1, v2) => Math.pow(v1, v2!), 2),
+    Add: new Add(),
+    Hypotenuse: new Hypotenuse(),
+    Maximum: new Maximum(),
+    Minimum: new Minimum(),
+    Random: new Random(),
+};
+
+export class MathFunctionRepository implements Repository<Function> {
+    find(namespace: string, name: string): Function | undefined {
+        if (namespace != Namespaces.MATH) return undefined;
+
+        return functionObjectsIndex[name];
+    }
+}