@fincity/kirun-js 1.0.0

package/__tests__/engine/function/system/string/StringFunctionRepositoryTest.ts

@@ -0,0 +1,146 @@
+import { AbstractStringFunction } from '../../../../../src/engine/function/system/string/AbstractStringFunction';
+import { StringFunctionRepository } from '../../../../../src/engine/function/system/string/StringFunctionRepository';
+import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const repo = new StringFunctionRepository();
+
+test('StringFunctionRepository - Trim', () => {
+    let fun = repo.find(Namespaces.STRING, 'Trim');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(MapUtil.of(AbstractStringFunction.PARAMETER_STRING_NAME, ' Kiran '));
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe('Kiran');
+});
+
+test('StringFunctionRepo -Repeat', () => {
+    let fun = repo.find(Namespaces.STRING, 'Repeat');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            ' surendhar ',
+            AbstractStringFunction.PARAMETER_INDEX_NAME,
+            3,
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(' surendhar  surendhar  surendhar ');
+});
+
+test('StringFunctionRepo -Lowercase', () => {
+    let fun = repo.find(Namespaces.STRING, 'LowerCase');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            ' SURENDHAR ',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(' surendhar ');
+});
+
+test('StringFunctionRepo -UpperCase', () => {
+    let fun = repo.find(Namespaces.STRING, 'UpperCase');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            ' surendhar ',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(' SURENDHAR ');
+});
+
+test('StringFunctionRepo -Blank1', () => {
+    let fun = repo.find(Namespaces.STRING, 'Blank');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ''),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+});
+
+test('StringFunctionRepo -Blank2', () => {
+    let fun = repo.find(Namespaces.STRING, 'Blank');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            ' this is a string',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+});
+
+test('StringFunctionRepo -Empty1', () => {
+    let fun = repo.find(Namespaces.STRING, 'Empty');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ''),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+});
+
+test('StringFunctionRepo -Empty2', () => {
+    let fun = repo.find(Namespaces.STRING, 'Empty');
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ' '),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+});

package/__tests__/engine/function/system/string/ToStringTest.ts

@@ -0,0 +1,43 @@
+import { ToString } from '../../../../../src/engine/function/system/string/ToString';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const toString: ToString = new ToString();
+
+test('toString test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(MapUtil.of('anytype', 123));
+
+    expect(toString.execute(fep).allResults()[0].getResult().get('result')).toBe('123');
+});
+
+// test('toString test2', () => {
+//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+//     let array: string[] = [];
+//     array.push('I');
+//     array.push('am');
+//     array.push('using');
+//     array.push('eclipse');
+//     array.push('to');
+//     array.push('test');
+//     array.push('the');
+//     array.push('changes');
+//     array.push('with');
+//     array.push('test');
+//     array.push('Driven');
+//     array.push('developement');
+
+//     fep.setArguments(MapUtil.of('anytype', array));
+
+//     expect(toString.execute(fep).allResults()[0].getResult().get('result')).toBe(
+//         'I am using eclipse to test the changes with test Driven developement',
+//     );
+// });
+
+test('toString test2 ', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(MapUtil.of('anytype', true));
+
+    expect(toString.execute(fep).allResults()[0].getResult().get('result')).toBe('true');
+});

package/__tests__/engine/function/system/string/TrimToTest.ts

@@ -0,0 +1,28 @@
+import { TrimTo } from '../../../../../src/engine/function/system/string/TrimTo';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+const trim: TrimTo = new TrimTo();
+
+test('Trim to test1 ', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+        new Map<string, string | number>([
+            [TrimTo.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [TrimTo.PARAMETER_LENGTH_NAME, 14],
+        ]),
+    );
+
+    expect(trim.execute(fep).allResults()[0].getResult().get(TrimTo.EVENT_RESULT_NAME)).toBe(
+        ' THIScompatY I',
+    );
+});
+
+test('Trim to test2 ', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+        new Map<string, string | number>([
+            [TrimTo.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [TrimTo.PARAMETER_LENGTH_NAME, 0],
+        ]),
+    );
+
+    expect(trim.execute(fep).allResults()[0].getResult().get(TrimTo.EVENT_RESULT_NAME)).toBe('');
+});

package/__tests__/engine/json/schema/validator/SchemaValidatorTest.ts

@@ -0,0 +1,26 @@
+import { Schema } from '../../../../../src/engine/json/schema/Schema';
+import { SchemaType } from '../../../../../src/engine/json/schema/type/SchemaType';
+import { TypeUtil } from '../../../../../src/engine/json/schema/type/TypeUtil';
+import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
+import { SchemaValidator } from '../../../../../src/engine/json/schema/validator/SchemaValidator';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+
+const repo = new KIRunSchemaRepository();
+
+test('Schema Validator Test 1', () => {
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
+
+    expect(SchemaValidator.validate([], schema, repo, 2)).toBe(2);
+
+    let obj = { name: 'shagil' };
+    let objSchema: Schema = Schema.ofObject('testObj')
+        .setProperties(new Map<string, Schema>([['name', Schema.ofString('name')]]))
+        .setRequired(['name']);
+    expect(SchemaValidator.validate([], objSchema, repo, obj)).toBe(obj);
+
+    expect(() => SchemaValidator.validate([], objSchema, repo, { name: 123 })).toThrow(
+        'Value {"name":123} is not of valid type(s)\nValue 123 is not of valid type(s)\n123 is not String',
+    );
+
+    // expect(SchemaValidator.validate([], schema, repo, 2.5)).toThrowError(new SchemaValidationException('', '2.5 is not a number of type Integer'));
+});

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -0,0 +1,351 @@
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
+import { EventResult } from '../../../src/engine/model/EventResult';
+import { Event } from '../../../src/engine/model/Event';
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+import { Parameter } from '../../../src/engine/model/Parameter';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { Create } from '../../../src/engine/function/system/context/Create';
+import { SetFunction } from '../../../src/engine/function/system/context/SetFunction';
+import { GenerateEvent } from '../../../src/engine/function/system/GenerateEvent';
+import { If } from '../../../src/engine/function/system/If';
+import { RangeLoop } from '../../../src/engine/function/system/loop/RangeLoop';
+import { Statement } from '../../../src/engine/model/Statement';
+import { ParameterReference } from '../../../src/engine/model/ParameterReference';
+import { Schema } from '../../../src/engine/json/schema/Schema';
+import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
+import { FunctionSignature } from '../../../src/engine/model/FunctionSignature';
+import { AbstractFunction } from '../../../src/engine/function/AbstractFunction';
+import { FunctionOutput } from '../../../src/engine/model/FunctionOutput';
+import { HybridRepository } from '../../../src/engine/HybridRepository';
+import { Function } from '../../../src/engine/function/Function';
+
+test('KIRuntime Test 1', () => {
+    let start = new Date().getTime();
+    let num: number = 7000;
+    let array: number[] = [];
+    let a = 0,
+        b = 1;
+    array.push(a);
+    array.push(b);
+
+    for (let i = 2; i < num; i++) {
+        array.push(array[i - 2] + array[i - 1]);
+    }
+
+    console.log('Normal Logic : ' + (new Date().getTime() - start));
+
+    var create = new Create().getSignature();
+    var integerSchema = { name: 'EachElement', type: 'INTEGER' };
+    var arrayOfIntegerSchema = {
+        name: 'ArrayType',
+        type: 'ARRAY',
+        defaultValue: new Array(),
+        items: integerSchema,
+    };
+    var createArray =new Statement('createArray', create.getNamespace(), create.getName())
+        .setParameterMap(
+            new Map([
+                ['name', [ParameterReference.ofValue('a')]],
+                ['schema', [ParameterReference.ofValue(arrayOfIntegerSchema)]],
+            ]),
+        );
+
+    var rangeLoop = new RangeLoop().getSignature();
+    var loop =new Statement('loop', rangeLoop.getNamespace(), rangeLoop.getName())
+        .setParameterMap(
+            new Map([
+                ['from', [ParameterReference.ofValue(0)]],
+                ['to', [ParameterReference.ofExpression('Arguments.Count')]],
+            ]),
+        )
+        .setDependentStatements(['Steps.createArray.output']);
+
+    var resultObj = { name: 'result', value: { isExpression: true, value: 'Context.a' } };
+
+    var generate = new GenerateEvent().getSignature();
+    var outputGenerate =new Statement('outputStep', generate.getNamespace(), generate.getName())
+        .setParameterMap(
+            new Map([
+                ['eventName', [ParameterReference.ofValue('output')]],
+                ['results', [ParameterReference.ofValue(resultObj)]],
+            ]),
+        )
+        .setDependentStatements(['Steps.loop.output']);
+
+    var ifFunction = new If().getSignature();
+    var ifStep =new Statement('if', ifFunction.getNamespace(), ifFunction.getName())
+        .setParameterMap(
+            new Map([
+                [
+                    'condition',
+                    [
+                        ParameterReference.ofExpression(
+                            'Steps.loop.iteration.index = 0 or Steps.loop.iteration.index = 1',
+                        ),
+                    ],
+                ],
+            ]),
+        );
+
+    var set = new SetFunction().getSignature();
+    var set1 =new Statement('setOnTrue', set.getNamespace(), set.getName())
+        .setParameterMap(
+            new Map([
+                ['name', [ParameterReference.ofValue('Context.a[Steps.loop.iteration.index]')]],
+                ['value', [ParameterReference.ofExpression('Steps.loop.iteration.index')]],
+            ]),
+        )
+        .setDependentStatements(['Steps.if.true']);
+    var set2 =new Statement('setOnFalse', set.getNamespace(), set.getName())
+        .setParameterMap(
+            new Map([
+                ['name', [ParameterReference.ofValue('Context.a[Steps.loop.iteration.index]')]],
+                [
+                    'value',
+                    [
+                        ParameterReference.ofExpression(
+                            'Context.a[Steps.loop.iteration.index - 1] + Context.a[Steps.loop.iteration.index - 2]',
+                        ),
+                    ],
+                ],
+            ]),
+        )
+        .setDependentStatements(['Steps.if.false']);
+
+    start = new Date().getTime();
+    let out: EventResult[] = new KIRuntime(
+        new FunctionDefinition('Fibonacci')
+            .setSteps(
+                new Map([
+                    Statement.ofEntry(createArray),
+                    Statement.ofEntry(loop),
+                    Statement.ofEntry(outputGenerate),
+                    Statement.ofEntry(ifStep),
+                    Statement.ofEntry(set1),
+                    Statement.ofEntry(set2),
+                ]),
+            )
+            .setNamespace('Test')
+            .setEvents(
+                new Map([
+                    Event.outputEventMapEntry(
+                        new Map([['result', Schema.ofArray('result', Schema.ofInteger('result'))]]),
+                    ),
+                ]),
+            )
+            .setParameters(
+                new Map([
+                    [
+                        'Count',
+                       new Parameter('Count',Schema.ofInteger('Count')),
+                    ],
+                ]),
+            ) as FunctionDefinition,
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .execute(new FunctionExecutionParameters().setArguments(new Map([['Count', num]])))
+        .allResults();
+    console.log('KIRunt Logic : ' + (new Date().getTime() - start));
+    expect(out[0].getResult().get('result')).toStrictEqual(array);
+});
+
+test('KIRuntime Test 2', () => {
+    var genEvent = new GenerateEvent().getSignature();
+
+    var expression = { isExpression: true, value: 'Steps.first.output.value' };
+
+    let resultObj = { name: 'result', value: expression };
+
+    let out: EventResult[] = new KIRuntime(
+        (
+            new FunctionDefinition('SingleCall')
+                .setNamespace('Test')
+                .setParameters(
+                    new Map([
+                        [
+                            'Value',
+                           new Parameter('Value',Schema.ofInteger('Value')),
+                        ],
+                    ]),
+                ) as FunctionDefinition
+        ).setSteps(
+            new Map([
+                Statement.ofEntry(
+                   new Statement('first', Namespaces.MATH, 'Absolute')
+                        .setParameterMap(
+                            new Map([
+                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                            ]),
+                        ),
+                ),
+                Statement.ofEntry(
+                   new Statement('second', genEvent.getNamespace(), genEvent.getName())
+                        .setParameterMap(
+                            new Map([
+                                ['eventName', [ParameterReference.ofValue('output')]],
+                                ['results', [ParameterReference.ofValue(resultObj)]],
+                            ]),
+                        ),
+                ),
+            ]),
+        ),
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .execute(new FunctionExecutionParameters().setArguments(new Map([['Value', -10]])))
+        .allResults();
+
+    expect(out[0].getResult().get('result')).toBe(10);
+});
+test('KIRuntime Test 3', () => {
+    var genEvent = new GenerateEvent().getSignature();
+
+    var expression = { isExpression: true, value: 'Steps.first.output.value' };
+
+    let resultObj = { name: 'result', value: expression };
+
+    let out: EventResult[] = new KIRuntime(
+        (
+            new FunctionDefinition('SingleCall')
+                .setNamespace('Test')
+                .setParameters(
+                    new Map([
+                        [
+                            'Value',
+                           new Parameter('Value',Schema.ofInteger('Value')),
+                        ],
+                    ]),
+                ) as FunctionDefinition
+        ).setSteps(
+            new Map([
+                Statement.ofEntry(
+                   new Statement('first', Namespaces.MATH, 'CubeRoot')
+                        .setParameterMap(
+                            new Map([
+                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                            ]),
+                        ),
+                ),
+                Statement.ofEntry(
+                   new Statement('second', genEvent.getNamespace(), genEvent.getName())
+                        .setParameterMap(
+                            new Map([
+                                ['eventName', [ParameterReference.ofValue('output')]],
+                                ['results', [ParameterReference.ofValue(resultObj)]],
+                            ]),
+                        ),
+                ),
+            ]),
+        ),
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .execute(new FunctionExecutionParameters().setArguments(new Map([['Value', 27]])))
+        .allResults();
+
+    expect(out[0].getResult().get('result')).toBe(3);
+});
+
+test('KIRuntime Test 4', () => {
+    let start = new Date().getTime();
+    const num = 7;
+    let array = new Array(num);
+    let a = 0,
+        b = 1;
+    array[0] = a;
+    array[1] = b;
+
+    for (let i = 2; i < num; i++) {
+        array[i] = array[i - 2] + array[i - 1];
+    }
+
+    console.log('Normal Logic : ' + (new Date().getTime() - start));
+
+    var fibFunctionSignature = new FunctionSignature('FibFunction')
+        .setNamespace('FibSpace')
+        .setParameters(
+            new Map([
+                [
+                    'value',
+                   new Parameter('value',Schema.ofInteger('value')),
+                ],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    new Map([['value', Schema.ofArray('value', Schema.ofInteger('value'))]]),
+                ),
+            ]),
+        );
+    class FibFunction extends AbstractFunction {
+        public getSignature(): FunctionSignature {
+            return fibFunctionSignature;
+        }
+
+        protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+            let count = context.getArguments()?.get('value');
+            let a = new Array(count);
+            for (let i = 0; i < count; i++) a[i] = i < 2 ? i : a[i - 1] + a[i - 2];
+            return new FunctionOutput([EventResult.outputOf(new Map([['value', a]]))]);
+        }
+    }
+
+    var fibFunction = new FibFunction();
+
+    var genEvent = new GenerateEvent().getSignature();
+
+    var expression = { isExpression: true, value: 'Steps.fib.output.value' };
+    let resultObj = { name: 'result', value: expression };
+
+    var hybrid = new HybridRepository(new KIRunFunctionRepository(), {
+        find(namespace, name): Function {
+            return fibFunction;
+        },
+    });
+
+    start = new Date().getTime();
+    let out: EventResult[] = new KIRuntime(
+        (
+            new FunctionDefinition('CustomFunction')
+                .setNamespace('Test')
+                .setParameters(
+                    new Map([
+                        [
+                            'Value',
+                           new Parameter('Value',Schema.ofInteger('Value')),
+                        ],
+                    ]),
+                ) as FunctionDefinition
+        ).setSteps(
+            new Map([
+                Statement.ofEntry(
+                   new Statement('fib', fibFunctionSignature.getNamespace(), 'asdf')
+                        .setParameterMap(
+                            new Map([
+                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                            ]),
+                        ),
+                ),
+                Statement.ofEntry(
+                   new Statement('fiboutput', genEvent.getNamespace(), genEvent.getName())
+                        .setParameterMap(
+                            new Map([
+                                ['eventName', [ParameterReference.ofValue('output')]],
+                                ['results', [ParameterReference.ofValue(resultObj)]],
+                            ]),
+                        ),
+                ),
+            ]),
+        ),
+        hybrid,
+        new KIRunSchemaRepository(),
+    )
+        .execute(new FunctionExecutionParameters().setArguments(new Map([['Value', num]])))
+        .allResults();
+    console.log('KIRun Logic : ' + (new Date().getTime() - start));
+    expect(out[0].getResult().get('result')).toStrictEqual(array);
+});