@fincity/kirun-js 1.6.12 → 1.6.14

package/__tests__/engine/function/system/array/ArrayToArrayOfObjectsTest.ts

@@ -18,9 +18,9 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
 
-    expect(result).toMatchObject([{ value: 1 }, { value: 2 }, { value: 3 }]);
+    expect(result).toStrictEqual([{ value: 1 }, { value: 2 }, { value: 3 }]);
 
     result = (
         await fun.execute(
@@ -37,9 +37,9 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
 
-    expect(result).toMatchObject([{ number: 1 }, { number: 2 }, { number: 3 }]);
+    expect(result).toStrictEqual([{ number: 1 }, { number: 2 }, { number: 3 }]);
 
     result = (
         await fun.execute(
@@ -51,9 +51,9 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
 
-    expect(result).toMatchObject([
+    expect(result).toStrictEqual([
         { value: { number: 1 } },
         { value: { number: 2 } },
         { value: { number: 3 } },
@@ -80,9 +80,9 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
 
-    expect(result).toMatchObject([
+    expect(result).toStrictEqual([
         { value1: 'a', value2: 1 },
         { value1: 'b', value2: 2 },
         { value1: 'c', value2: '3' },
@@ -110,12 +110,12 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
 
-    expect(result).toMatchObject([
-        { key: 'a', value: 1 },
-        { key: 'b', value: 2 },
-        { key: 'c', value: '3' },
+    expect(result).toStrictEqual([
+        { key: 'a', value: 1, other: undefined },
+        { key: 'b', value: 2, other: undefined },
+        { key: 'c', value: '3', other: undefined },
     ]);
 
     result = (
@@ -140,7 +140,120 @@ test('Array to Array of objects', async () => {
     )
         .allResults()[0]
         .getResult()
-        .get('output');
+        .get('result');
+
+    expect(result).toStrictEqual([{ maKey: 'a' }, { maKey: 'b' }, { maKey: 'c' }]);
+});
+
+test('Array with nested object and mixed', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([
+                    ['source', [true, 1, 2, ['a', 'b', 'c']]],
+                    ['keyName', ['akey', 'bkey', 'ckey']],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject([
+        { akey: true },
+        { akey: 1 },
+        { akey: 2 },
+        { akey: 'a', bkey: 'b', ckey: 'c' },
+    ]);
+});
+
+test('Array with nested array object and mixed without key', async () => {
+    let fun = new ArrayToArrayOfObjects();
 
-    expect(result).toMatchObject([{ maKey: 'a' }, { maKey: 'b' }, { maKey: 'c' }]);
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['source', [true, 1, 2, ['a', 'b', 'c']]]])),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toStrictEqual([
+        { value: true },
+        { value: 1 },
+        { value: 2 },
+        { value1: 'a', value2: 'b', value3: 'c' },
+    ]);
+});
+
+test('Array with nested array object and mixed without key', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([['source', [true, 1, 2, ['a', 'b', 'c', ['d', 'e'], { obj1: 'val1' }]]]]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toStrictEqual([
+        { value: true },
+        { value: 1 },
+        { value: 2 },
+        {
+            value1: 'a',
+            value2: 'b',
+            value3: 'c',
+            value4: ['d', 'e'],
+            value5: {
+                obj1: 'val1',
+            },
+        },
+    ]);
+});
+
+test('Array with nested array object and mixed with key arrays', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([
+                    ['source', [[true, false], [1, 'surendhar'], ['satya']]],
+                    ['keyName', ['valueA', 'valueB', 'valueC', 'valueD']],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    console.log(result);
+
+    expect(result).toStrictEqual([
+        { valueA: true, valueB: false, valueC: undefined, valueD: undefined },
+        { valueA: 1, valueB: 'surendhar', valueC: undefined, valueD: undefined },
+        { valueA: 'satya', valueB: undefined, valueC: undefined, valueD: undefined },
+    ]);
 });

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -1,25 +1,9 @@
-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 { Namespaces } from '../../../src/engine/namespaces/Namespaces';
 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';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
 
 test('KIRuntime With Definition 1', async () => {
     var def = {

package/__tests__/engine/runtime/expression/tokenextractor/OutputMapTokenValueExtractorTest.ts

@@ -42,3 +42,13 @@ test('OutputMapTokenValueExtractor Test', () => {
     expect(omtv.getValue('Steps.step1.output.zero')).toBe(0);
     expect(omtv.getValue('Steps.step1.output.obj.address.phone.phone2')).toBe('5678');
 });
+
+test('OutputMapTokenValueExtractor Test 2', () => {
+    let output: Map<string, Map<string, Map<string, any>>> = new Map([
+        ['step1', new Map([['output', new Map([['arr', ['a', 'b', 'c']]])]])],
+    ]);
+
+    var omtv = new OutputMapTokenValueExtractor(output);
+    expect(omtv.getValue('Steps.step1.output.arr[1]')).toBe('b');
+    expect(omtv.getValue('Steps.step1.output.arr1[1]')).toBeUndefined();
+});