@fincity/kirun-js 1.3.0 → 1.4.1

package/__tests__/engine/function/system/math/RandomIntTest.ts

@@ -48,7 +48,6 @@ test(' rand int 3', async () => {
     );
     let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
-    console.log(num);
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
 });

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

@@ -1,4 +1,4 @@
-import { HybridRepository } from '../../../../../src';
+import { AdditionalPropertiesType, HybridRepository } from '../../../../../src';
 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';
@@ -26,6 +26,56 @@ test('Schema Validator Test 1', () => {
     // expect(SchemaValidator.validate([], schema, repo, 2.5)).toThrowError(new SchemaValidationException('', '2.5 is not a number of type Integer'));
 });
 
+test('Schema validation when ref of ref', () => {
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+    });
+
+    const urlParamsSchema = Schema.ofObject('UrlParameters')
+        .setNamespace('Test')
+        .setAdditionalProperties(
+            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.Location`)),
+        )
+        .setDefaultValue({});
+
+    const testSchema = Schema.ofObject('TestSchema')
+        .setNamespace('Test')
+        .setAdditionalProperties(
+            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
+        )
+        .setDefaultValue({});
+
+    const schemaMap = new Map([
+        ['Location', locationSchema],
+        ['UrlParameters', urlParamsSchema],
+        ['TestSchema', testSchema],
+    ]);
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace: string, name: string): Schema | undefined {
+                if (namespace !== 'Test') return undefined;
+                return schemaMap.get(name);
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+    const obj = { url: 'http://xxxxxx.com' };
+    const queryParams = {
+        obj: { obj: { url: 'http://xxxxxx.com' } },
+    };
+
+    expect(
+        SchemaValidator.validate(undefined, Schema.ofRef('Test.TestSchema'), repo, queryParams),
+    ).toBe(queryParams);
+});
+
 test('Schema Validator Test 2', () => {
     const locationSchema = Schema.from({
         name: 'Location',

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -20,6 +20,7 @@ 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';
+import { MapUtil } from '../../../src';
 
 test('KIRuntime Test 1', async () => {
     let start = new Date().getTime();
@@ -50,8 +51,8 @@ test('KIRuntime Test 1', async () => {
         create.getName(),
     ).setParameterMap(
         new Map([
-            ['name', [ParameterReference.ofValue('a')]],
-            ['schema', [ParameterReference.ofValue(arrayOfIntegerSchema)]],
+            ['name', MapUtil.ofEntriesArray(ParameterReference.ofValue('a'))],
+            ['schema', MapUtil.ofEntriesArray(ParameterReference.ofValue(arrayOfIntegerSchema))],
         ]),
     );
 
@@ -59,11 +60,11 @@ test('KIRuntime Test 1', async () => {
     var loop = new Statement('loop', rangeLoop.getNamespace(), rangeLoop.getName())
         .setParameterMap(
             new Map([
-                ['from', [ParameterReference.ofValue(0)]],
-                ['to', [ParameterReference.ofExpression('Arguments.Count')]],
+                ['from', MapUtil.ofEntriesArray(ParameterReference.ofValue(0))],
+                ['to', MapUtil.ofEntriesArray(ParameterReference.ofExpression('Arguments.Count'))],
             ]),
         )
-        .setDependentStatements(['Steps.createArray.output']);
+        .setDependentStatements(MapUtil.of('Steps.createArray.output', true));
 
     var resultObj = { name: 'result', value: { isExpression: true, value: 'Context.a' } };
 
@@ -71,11 +72,11 @@ test('KIRuntime Test 1', async () => {
     var outputGenerate = new Statement('outputStep', generate.getNamespace(), generate.getName())
         .setParameterMap(
             new Map([
-                ['eventName', [ParameterReference.ofValue('output')]],
-                ['results', [ParameterReference.ofValue(resultObj)]],
+                ['eventName', MapUtil.ofEntriesArray(ParameterReference.ofValue('output'))],
+                ['results', MapUtil.ofEntriesArray(ParameterReference.ofValue(resultObj))],
             ]),
         )
-        .setDependentStatements(['Steps.loop.output']);
+        .setDependentStatements(MapUtil.of('Steps.loop.output', true));
 
     var ifFunction = new If().getSignature();
     var ifStep = new Statement(
@@ -86,11 +87,11 @@ test('KIRuntime Test 1', async () => {
         new Map([
             [
                 'condition',
-                [
+                MapUtil.ofEntriesArray(
                     ParameterReference.ofExpression(
                         'Steps.loop.iteration.index = 0 or Steps.loop.iteration.index = 1',
                     ),
-                ],
+                ),
             ],
         ]),
     );
@@ -99,26 +100,41 @@ test('KIRuntime Test 1', async () => {
     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')]],
+                [
+                    'name',
+                    MapUtil.ofEntriesArray(
+                        ParameterReference.ofValue('Context.a[Steps.loop.iteration.index]'),
+                    ),
+                ],
+                [
+                    'value',
+                    MapUtil.ofEntriesArray(
+                        ParameterReference.ofExpression('Steps.loop.iteration.index'),
+                    ),
+                ],
             ]),
         )
-        .setDependentStatements(['Steps.if.true']);
+        .setDependentStatements(MapUtil.of('Steps.if.true', true));
     var set2 = new Statement('setOnFalse', set.getNamespace(), set.getName())
         .setParameterMap(
             new Map([
-                ['name', [ParameterReference.ofValue('Context.a[Steps.loop.iteration.index]')]],
+                [
+                    'name',
+                    MapUtil.ofEntriesArray(
+                        ParameterReference.ofValue('Context.a[Steps.loop.iteration.index]'),
+                    ),
+                ],
                 [
                     'value',
-                    [
+                    MapUtil.ofEntriesArray(
                         ParameterReference.ofExpression(
                             'Context.a[Steps.loop.iteration.index - 1] + Context.a[Steps.loop.iteration.index - 2]',
                         ),
-                    ],
+                    ),
                 ],
             ]),
         )
-        .setDependentStatements(['Steps.if.false']);
+        .setDependentStatements(MapUtil.of('Steps.if.false', true));
 
     start = new Date().getTime();
     let out: EventResult[] = (
@@ -178,7 +194,12 @@ test('KIRuntime Test 2', async () => {
                     Statement.ofEntry(
                         new Statement('first', Namespaces.MATH, 'Absolute').setParameterMap(
                             new Map([
-                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                                [
+                                    'value',
+                                    MapUtil.ofEntriesArray(
+                                        ParameterReference.ofExpression('Arguments.Value'),
+                                    ),
+                                ],
                             ]),
                         ),
                     ),
@@ -189,8 +210,14 @@ test('KIRuntime Test 2', async () => {
                             genEvent.getName(),
                         ).setParameterMap(
                             new Map([
-                                ['eventName', [ParameterReference.ofValue('output')]],
-                                ['results', [ParameterReference.ofValue(resultObj)]],
+                                [
+                                    'eventName',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue('output')),
+                                ],
+                                [
+                                    'results',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue(resultObj)),
+                                ],
                             ]),
                         ),
                     ),
@@ -226,7 +253,12 @@ test('KIRuntime Test 3', async () => {
                     Statement.ofEntry(
                         new Statement('first', Namespaces.MATH, 'CubeRoot').setParameterMap(
                             new Map([
-                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                                [
+                                    'value',
+                                    MapUtil.ofEntriesArray(
+                                        ParameterReference.ofExpression('Arguments.Value'),
+                                    ),
+                                ],
                             ]),
                         ),
                     ),
@@ -237,8 +269,14 @@ test('KIRuntime Test 3', async () => {
                             genEvent.getName(),
                         ).setParameterMap(
                             new Map([
-                                ['eventName', [ParameterReference.ofValue('output')]],
-                                ['results', [ParameterReference.ofValue(resultObj)]],
+                                [
+                                    'eventName',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue('output')),
+                                ],
+                                [
+                                    'results',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue(resultObj)),
+                                ],
                             ]),
                         ),
                     ),
@@ -326,7 +364,12 @@ test('KIRuntime Test 4', async () => {
                             'asdf',
                         ).setParameterMap(
                             new Map([
-                                ['value', [ParameterReference.ofExpression('Arguments.Value')]],
+                                [
+                                    'value',
+                                    MapUtil.ofEntriesArray(
+                                        ParameterReference.ofExpression('Arguments.Value'),
+                                    ),
+                                ],
                             ]),
                         ),
                     ),
@@ -337,8 +380,14 @@ test('KIRuntime Test 4', async () => {
                             genEvent.getName(),
                         ).setParameterMap(
                             new Map([
-                                ['eventName', [ParameterReference.ofValue('output')]],
-                                ['results', [ParameterReference.ofValue(resultObj)]],
+                                [
+                                    'eventName',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue('output')),
+                                ],
+                                [
+                                    'results',
+                                    MapUtil.ofEntriesArray(ParameterReference.ofValue(resultObj)),
+                                ],
                             ]),
                         ),
                     ),

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -42,11 +42,11 @@ test('KIRuntime With Definition 1', async () => {
                 namespace: Namespaces.MATH,
                 name: 'Add',
                 parameterMap: {
-                    value: [
-                        { type: 'EXPRESSION', expression: 'Arguments.a' },
-                        { type: 'EXPRESSION', expression: '10 + 1' },
-                        { type: 'EXPRESSION', expression: 'Arguments.c' },
-                    ],
+                    value: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'EXPRESSION', expression: '10 + 1' },
+                        three: { key: 'three', type: 'EXPRESSION', expression: 'Arguments.c' },
+                    },
                 },
             },
             genOutput: {
@@ -54,16 +54,17 @@ test('KIRuntime With Definition 1', async () => {
                 namespace: Namespaces.SYSTEM,
                 name: 'GenerateEvent',
                 parameterMap: {
-                    eventName: [{ type: 'VALUE', value: 'output' }],
-                    results: [
-                        {
+                    eventName: { one: { key: 'one', type: 'VALUE', value: 'output' } },
+                    results: {
+                        one: {
+                            key: 'one',
                             type: 'VALUE',
                             value: {
                                 name: 'additionResult',
                                 value: { isExpression: true, value: 'Steps.add.output.value' },
                             },
                         },
-                    ],
+                    },
                 },
             },
         },
@@ -86,3 +87,40 @@ test('KIRuntime With Definition 1', async () => {
 
     expect(result.allResults()[0].getResult().get('additionResult')).toBe(31);
 });
+
+test('KIRuntime With Definition 2', async () => {
+    var def = {
+        name: 'checkWithNoParamsOrEvents',
+        namespace: 'UIApp',
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'VALUE', value: 2 },
+                        two: { key: 'two', type: 'VALUE', value: 5 },
+                    },
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                dependentStatements: { 'Steps.add.output': true },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map()),
+    );
+
+    expect(result.allResults()[0].getResult()).toMatchObject({});
+});

package/__tests__/engine/runtime/expression/ExpressionEvaluatorTernaryOperatorTest.ts

@@ -0,0 +1,42 @@
+import {
+    ArgumentsTokenValueExtractor,
+    Expression,
+    MapUtil,
+    TokenValueExtractor,
+} from '../../../../src';
+import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+
+test('Expression with Ternary Operator - 1 ', () => {
+    var exp = new Expression('a > 10 ?  a - 2 : a + 3'.replace(' ', ''));
+    expect(exp.toString()).toBe('((a>10)?(a-2):(a+3))');
+
+    exp = new Expression('a > 10 ?  a - 2 : a + 3');
+    expect(exp.toString()).toBe('((a>10)?(a-2):(a+3))');
+
+    exp = new Expression('a > 10 ? a > 15 ? a + 2 : a - 2 : a + 3');
+    expect(exp.toString()).toBe('((a>10)?((a>15)?(a+2):(a-2)):(a+3))');
+});
+
+test('Expression Evaluation with Ternary Operator - 1 ', () => {
+    let x = { a: 2, b: [true, false], c: { x: 'Arguments.b2' } };
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['b1', 4],
+            ['b2', 4],
+            ['c', x],
+            ['d', 'c'],
+        ]),
+    );
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    var ev = new ExpressionEvaluator('Arguments.e = null ? Arguments.c.a : 3 ');
+    expect(ev.evaluate(valuesMap)).toBe(2);
+
+    ev = new ExpressionEvaluator('Arguments.f ? Arguments.c.a : 3 ');
+    expect(ev.evaluate(valuesMap)).toBe(3);
+
+    ev = new ExpressionEvaluator('Arguments.e = null ? Arguments.c : 3 ');
+    expect(ev.evaluate(valuesMap)).toMatchObject(x);
+});