@fincity/kirun-js 2.1.4 → 2.1.6

package/__tests__/engine/function/system/IfTest.ts

@@ -0,0 +1,51 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+} from '../../../../src';
+import { If } from '../../../../src/engine/function/system/If';
+
+const ifFunction = new If();
+
+test('if test', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    let fo = await ifFunction.execute(fep.setArguments(new Map([['condition', true]])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', false]])));
+    expect(fo.allResults()[0].getName()).toBe('false');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', undefined]])));
+    expect(fo.allResults()[0].getName()).toBe('false');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', null]])));
+    expect(fo.allResults()[0].getName()).toBe('false');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', '']]))); // empty string
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', ' ']]))); // space
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', 'abc']])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', 0]])));
+    expect(fo.allResults()[0].getName()).toBe('false');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', 1]])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', -1]])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', {}]])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+
+    fo = await ifFunction.execute(fep.setArguments(new Map([['condition', []]])));
+    expect(fo.allResults()[0].getName()).toBe('true');
+});

package/__tests__/engine/runtime/KIRuntimeVariableArgDefaultNullTest.ts

@@ -0,0 +1,294 @@
+import {
+    AbstractFunction,
+    EventResult,
+    Function,
+    FunctionOutput,
+    FunctionSignature,
+    HybridRepository,
+    Parameter,
+    Schema,
+    SchemaType,
+} from '../../../src';
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
+import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
+
+test('KIRuntime Print function with no arguments', async () => {
+    var def = {
+        name: 'varArgWithNothing',
+        namespace: 'Test',
+        steps: {
+            testFunction: {
+                statementName: 'testFunction',
+                namespace: 'LocalFunction',
+                name: 'Other',
+                parameterMap: {
+                    storageName: {
+                        one: {
+                            type: 'VALUE',
+                            value: 'Test',
+                            key: 'one',
+                            order: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    var OtherFunction = new KIRuntime(
+        FunctionDefinition.from({
+            namespace: 'LocalFunction',
+            name: 'Other',
+            steps: {
+                print: {
+                    statementName: 'print',
+                    namespace: Namespaces.SYSTEM,
+                    name: 'Print',
+                    parameterMap: {
+                        values: {
+                            one: {
+                                type: 'EXPRESSION',
+                                expression: '"Storage : " + Arguments.storageName + "\n"',
+                                key: 'one',
+                                order: 1,
+                            },
+                            two: {
+                                type: 'EXPRESSION',
+                                expression: '"Page : " + Arguments.page + "\n"',
+                                key: 'two',
+                                order: 2,
+                            },
+                            three: {
+                                type: 'EXPRESSION',
+                                expression: '"Size : " + Arguments.size + "\n"',
+                                key: 'three',
+                                order: 3,
+                            },
+                            five: {
+                                type: 'EXPRESSION',
+                                expression: '"Count : " + Arguments.count + "\n"',
+                                key: 'five',
+                                order: 5,
+                            },
+                            six: {
+                                type: 'EXPRESSION',
+                                expression: '"Client Code : " + Arguments.clientCode + "\n"',
+                                key: 'six',
+                                order: 6,
+                            },
+
+                            eight: {
+                                type: 'EXPRESSION',
+                                expression: '"Eager : " + Arguments.eager + "\n"',
+                                key: 'eight',
+                                order: 8,
+                            },
+                        },
+                    },
+                },
+            },
+            parameters: {
+                appCode: {
+                    schema: {
+                        namespace: '_',
+                        name: 'appCode',
+                        version: 1,
+                        type: {
+                            type: 'STRING',
+                        },
+                        defaultValue: '',
+                    },
+                    parameterName: 'appCode',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                page: {
+                    schema: {
+                        namespace: '_',
+                        name: 'page',
+                        version: 1,
+                        type: {
+                            type: 'INTEGER',
+                        },
+                        defaultValue: 0,
+                    },
+                    parameterName: 'page',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                storageName: {
+                    schema: {
+                        namespace: '_',
+                        name: 'storageName',
+                        version: 1,
+                        type: {
+                            type: 'STRING',
+                        },
+                    },
+                    parameterName: 'storageName',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                size: {
+                    schema: {
+                        namespace: '_',
+                        name: 'size',
+                        version: 1,
+                        type: {
+                            type: 'INTEGER',
+                        },
+                        defaultValue: 20,
+                    },
+                    parameterName: 'size',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                count: {
+                    schema: {
+                        namespace: '_',
+                        name: 'count',
+                        version: 1,
+                        type: {
+                            type: 'BOOLEAN',
+                        },
+                        defaultValue: true,
+                    },
+                    parameterName: 'count',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                clientCode: {
+                    schema: {
+                        namespace: '_',
+                        name: 'clientCode',
+                        version: 1,
+                        type: {
+                            type: 'STRING',
+                        },
+                        defaultValue: '',
+                    },
+                    parameterName: 'clientCode',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                eagerFields: {
+                    schema: {
+                        namespace: '_',
+                        name: 'eagerFields',
+                        version: 1,
+                        type: {
+                            type: 'STRING',
+                        },
+                    },
+                    parameterName: 'eagerFields',
+                    variableArgument: true,
+                    type: 'EXPRESSION',
+                },
+                filter: {
+                    schema: {
+                        namespace: '_',
+                        name: 'filter',
+                        version: 1,
+                        type: {
+                            type: 'OBJECT',
+                        },
+                        defaultValue: {},
+                    },
+                    parameterName: 'filter',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+                eager: {
+                    schema: {
+                        namespace: '_',
+                        name: 'eager',
+                        version: 1,
+                        type: {
+                            type: 'BOOLEAN',
+                        },
+                        defaultValue: false,
+                    },
+                    parameterName: 'eager',
+                    variableArgument: false,
+                    type: 'EXPRESSION',
+                },
+            },
+        }),
+        false,
+    );
+    const fd = FunctionDefinition.from(def);
+    const oldConsole = console.log;
+    const test = (console.log = jest.fn().mockImplementation(() => {}));
+
+    let result = await new KIRuntime(fd, false).execute(
+        new FunctionExecutionParameters(
+            new HybridRepository<Function>(new KIRunFunctionRepository(), {
+                find: async (namespace: string, name: string): Promise<Function | undefined> => {
+                    if (namespace === 'LocalFunction' && name === 'Other') return OtherFunction;
+                    return undefined;
+                },
+
+                filter: async (name: string): Promise<string[]> => {
+                    return ['LocalFunction.Other'];
+                },
+            }),
+            new KIRunSchemaRepository(),
+        ),
+    );
+
+    console.log = oldConsole;
+
+    expect(test.mock.calls[0]).toMatchObject([
+        'Storage : Test\n',
+        'Page : 0\n',
+        'Size : 20\n',
+        'Count : true\n',
+        'Client Code : \n',
+        'Eager : false\n',
+    ]);
+});
+
+test("KIRuntime Print function with 'null' argument", async () => {
+    class TestPrint extends AbstractFunction {
+        private static readonly VALUES: string = 'values';
+
+        private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Print')
+            .setNamespace(Namespaces.SYSTEM)
+            .setParameters(
+                new Map([
+                    Parameter.ofEntry(
+                        TestPrint.VALUES,
+                        Schema.of(
+                            TestPrint.VALUES,
+                            SchemaType.STRING,
+                            SchemaType.NULL,
+                        ).setDefaultValue(null),
+                        false,
+                    ),
+                ]),
+            );
+
+        public getSignature(): FunctionSignature {
+            return TestPrint.SIGNATURE;
+        }
+
+        protected async internalExecute(
+            context: FunctionExecutionParameters,
+        ): Promise<FunctionOutput> {
+            var values = context.getArguments()?.get(TestPrint.VALUES);
+
+            console?.log(values);
+
+            return new FunctionOutput([EventResult.outputOf(new Map())]);
+        }
+    }
+
+    var fun = new TestPrint();
+    fun.execute(
+        new FunctionExecutionParameters(new KIRunFunctionRepository(), new KIRunSchemaRepository()),
+    );
+});

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

@@ -244,37 +244,133 @@ test('Partial path evaluation', () => {
     expect(ev.evaluate(valuesMap)).toBe(2);
 });
 
-test('Expression with consecutive negative operators', () => {
+// test('Expression with consecutive negative operators', () => {
+//     let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+//         new Map<string, any>([
+//             ['a', 'kirun '],
+//             ['b', 1],
+//             ['b1', 4],
+//             ['b2', 4],
+//         ]),
+//     );
+
+//     let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+//     let ev = new ExpressionEvaluator('Arguments.b - Arguments.b1 - Arguments.b2');
+//     expect(ev.evaluate(valuesMap)).toBe(-7);
+// });
+
+// test('Expression with multiple coalesce operator', () => {
+//     let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+//         new Map<string, any>([
+//             ['a', 'kirun '],
+//             ['b', 1],
+//             ['b1', 4],
+//             ['b2', 4],
+//         ]),
+//     );
+
+//     let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+//     let ev = new ExpressionEvaluator('Arguments.b3 ?? (Arguments.b - 3) ?? Arguments.b5 ?? 4');
+//     expect(ev.evaluate(valuesMap)).toBe(-2);
+
+//     ev = new ExpressionEvaluator('Arguments.b3 ?? Arguments.b - 3 ?? Arguments.b5 ?? 4');
+//     expect(ev.evaluate(valuesMap)).toBe(-2);
+// });
+
+test('Expression with logical operators and all value types including object', () => {
     let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
         new Map<string, any>([
-            ['a', 'kirun '],
-            ['b', 1],
-            ['b1', 4],
-            ['b2', 4],
+            ['string', 'kirun '],
+            ['stringEmpty', ''],
+            ['number', 122.2],
+            ['number0', 0],
+            ['booleanTrue', true],
+            ['booleanFalse', false],
+            ['null', null],
+            ['undefined', undefined],
+            ['object', { a: 1, b: '2', c: true, d: null, e: undefined }],
+            ['array', [1, '2', true, null, undefined]],
+            ['array2', [1, '2', true, null, undefined]],
+            ['emptyArray', []],
         ]),
     );
 
     let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
 
-    let ev = new ExpressionEvaluator('Arguments.b - Arguments.b1 - Arguments.b2');
-    expect(ev.evaluate(valuesMap)).toBe(-7);
-});
+    let ev = new ExpressionEvaluator('not not Arguments.object');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
 
-test('Expression with multiple coalesce operator', () => {
-    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
-        new Map<string, any>([
-            ['a', 'kirun '],
-            ['b', 1],
-            ['b1', 4],
-            ['b2', 4],
-        ]),
-    );
+    ev = new ExpressionEvaluator('not not Arguments.stringEmpty');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
 
-    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+    ev = new ExpressionEvaluator('not not Arguments.number');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('not not Arguments.number0');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('not not Arguments.booleanTrue');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('not not Arguments.booleanFalse');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('not not Arguments.null');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('not not Arguments.undefined');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
 
-    let ev = new ExpressionEvaluator('Arguments.b3 ?? (Arguments.b - 3) ?? Arguments.b5 ?? 4');
-    expect(ev.evaluate(valuesMap)).toBe(-2);
+    ev = new ExpressionEvaluator('not not Arguments.array');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('not not Arguments.emptyArray');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.object = true');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.object != true');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.stringEmpty = true');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.stringEmpty != false');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.number0 = true');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.number0 = false');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.array.length');
+    expect(ev.evaluate(valuesMap)).toBe(5);
+
+    ev = new ExpressionEvaluator('Arguments.object.length');
+    expect(ev.evaluate(valuesMap)).toBe(5);
+
+    ev = new ExpressionEvaluator('Arguments.object and Arguments.array');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.object or Arguments.null');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.object and Arguments.null');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.object ? 3 : 4');
+    expect(ev.evaluate(valuesMap)).toBe(3);
+
+    ev = new ExpressionEvaluator('not Arguments.object ? 3 : 4');
+    expect(ev.evaluate(valuesMap)).toBe(4);
+
+    ev = new ExpressionEvaluator('Arguments.array = Arguments.array2');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
 
-    ev = new ExpressionEvaluator('Arguments.b3 ?? Arguments.b - 3 ?? Arguments.b5 ?? 4');
-    expect(ev.evaluate(valuesMap)).toBe(-2);
+    ev = new ExpressionEvaluator('Arguments.number0 ? 3 : 4');
+    expect(ev.evaluate(valuesMap)).toBe(4);
 });