@fincity/kirun-js 1.4.3 → 1.4.5

package/__tests__/engine/json/schema/type/TypeUtilTest.ts

@@ -1,9 +1,9 @@
 import { SchemaType, TypeUtil } from '../../../../../src';
 
 test('TypeUtilTest', () => {
-    expect(TypeUtil.from('Object')?.contains(SchemaType.OBJECT)).toBeTruthy();
+    expect(TypeUtil.from('OBJECT')?.contains(SchemaType.OBJECT)).toBeTruthy();
 
-    let type = TypeUtil.from(['Object', 'String']);
+    let type = TypeUtil.from(['OBJECT', 'STRING']);
 
     expect(type?.contains(SchemaType.STRING)).toBeTruthy();
     expect(type?.contains(SchemaType.OBJECT)).toBeTruthy();

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

@@ -30,9 +30,9 @@ test('Schema validation when ref of ref', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
-            url: { name: 'url', type: 'String' },
+            url: { name: 'url', type: 'STRING' },
         },
         required: ['url'],
     });
@@ -66,7 +66,7 @@ test('Schema validation when ref of ref', () => {
         },
         new KIRunSchemaRepository(),
     );
-    const obj = { url: 'http://xxxxxx.com' };
+    const obj = { obj: { url: 'http://xxxxxx.com' } };
     const queryParams = {
         obj: { obj: { url: 'http://xxxxxx.com' } },
     };
@@ -80,9 +80,9 @@ test('Schema Validator Test 2', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
-            url: { name: 'url', type: 'String' },
+            url: { name: 'url', type: 'STRING' },
         },
         required: ['url'],
     });
@@ -116,7 +116,7 @@ test('Schema Validator Test 3', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
             url: { name: 'url', type: 'String' },
         },

package/__tests__/engine/runtime/KIRuntimeExtended.ts

@@ -0,0 +1,142 @@
+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 Extended Definition', async () => {
+    var def = {
+        name: 'checkExtendedFunction',
+        namespace: 'Test',
+        parameters: {
+            a: { parameterName: 'a', schema: { name: 'INTEGER', type: 'INTEGER' } },
+        },
+        events: {
+            output: {
+                name: 'output',
+                parameters: { additionResult: { name: 'additionResult', type: 'INTEGER' } },
+            },
+        },
+        steps: {
+            add1: {
+                statementName: 'add1',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'VALUE', value: 1 },
+                    },
+                },
+            },
+            if1: {
+                statementName: 'if1',
+                namespace: Namespaces.SYSTEM,
+                name: 'If',
+                parameterMap: {
+                    condition: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value % 2 = 0',
+                        },
+                    },
+                },
+            },
+            add2: {
+                statementName: 'add2',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 2 },
+                    },
+                },
+                dependentStatements: {
+                    'Steps.if1.true': true,
+                },
+            },
+            add3: {
+                statementName: 'add3',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add2.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 2 },
+                    },
+                },
+            },
+            add4: {
+                statementName: 'add4',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 1 },
+                    },
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                parameterMap: {
+                    eventName: { one: { key: 'one', type: 'VALUE', value: 'output' } },
+                    results: {
+                        one: {
+                            key: 'one',
+                            type: 'VALUE',
+                            value: {
+                                name: 'additionResult',
+                                value: { isExpression: true, value: 'Steps.add4.output.value' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(fd, true).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['a', 7]])),
+    );
+
+    expect(result.allResults()[0].getResult().get('additionResult')).toBe(9);
+});

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -26,14 +26,14 @@ test('KIRuntime With Definition 1', async () => {
         name: 'getAppData',
         namespace: 'UIApp',
         parameters: {
-            a: { parameterName: 'a', schema: { name: 'integer', type: 'Integer' } },
-            b: { parameterName: 'b', schema: { name: 'integer', type: 'Integer' } },
-            c: { parameterName: 'c', schema: { name: 'integer', type: 'Integer' } },
+            a: { parameterName: 'a', schema: { name: 'INTEGER', type: 'INTEGER' } },
+            b: { parameterName: 'b', schema: { name: 'INTEGER', type: 'INTEGER' } },
+            c: { parameterName: 'c', schema: { name: 'INTEGER', type: 'INTEGER' } },
         },
         events: {
             output: {
                 name: 'output',
-                parameters: { additionResult: { name: 'additionResult', type: 'Integer' } },
+                parameters: { additionResult: { name: 'additionResult', type: 'INTEGER' } },
             },
         },
         steps: {
@@ -72,7 +72,7 @@ test('KIRuntime With Definition 1', async () => {
 
     const fd = FunctionDefinition.from(def);
 
-    let result = await new KIRuntime(fd).execute(
+    let result = await new KIRuntime(fd, true).execute(
         new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),

package/__tests__/engine/runtime/expression/operators/unary/LogicalNotOperatorTest.ts

@@ -0,0 +1,17 @@
+import { LogicalNotOperator } from '../../../../../../src';
+
+test('Logical Not Test', () => {
+    expect(new LogicalNotOperator().apply(null)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(undefined)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(false)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(0)).toBeTruthy();
+
+    expect(new LogicalNotOperator().apply(true)).toBeFalsy();
+    expect(new LogicalNotOperator().apply(1)).toBeFalsy();
+
+    expect(new LogicalNotOperator().apply({ name: 'Kiran' })).toBeFalsy();
+
+    expect(new LogicalNotOperator().apply([])).toBeFalsy();
+    expect(new LogicalNotOperator().apply('')).toBeFalsy();
+    expect(new LogicalNotOperator().apply('TRUE')).toBeFalsy();
+});