@fincity/kirun-js 1.1.2 → 1.1.3

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

@@ -2,11 +2,15 @@ import { Reverse } from '../../../../../src/engine/function/system/string/Revers
 import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const reve: Reverse = new Reverse();
 
 test('reverse test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of('value', ' mr"ofta"lp edoc on a si sihT'));
 
@@ -16,7 +20,10 @@ test('reverse test1', async () => {
 });
 
 test('reverse test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of('value', ' '));
 
@@ -26,7 +33,7 @@ test('reverse test2', async () => {
 });
 
 // test('reverse test3', async () => {
-//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(new KIRunFunctionRepository(), new KIRunSchemaRepository());
 
 //     fep.setArguments(MapUtil.of('value', null));
 

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

@@ -1,11 +1,15 @@
 import { Split } from '../../../../../src/engine/function/system/string/Split';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const Spli: Split = new Split();
 
 test('split test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             'string',
@@ -35,7 +39,10 @@ test('split test1', async () => {
 });
 
 test('split test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             'string',

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

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 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';
@@ -8,7 +9,10 @@ const stringRepo = new StringFunctionRepository();
 
 test('StringRepo - contains', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'Contains');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     if (!fun) {
         throw new Error('Function not available');
@@ -84,7 +88,10 @@ test('string function repo 2', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             AbstractStringFunction.PARAMETER_STRING_NAME,
@@ -140,7 +147,10 @@ test('string function repo 3', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of(

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

@@ -3,12 +3,16 @@ import { StringFunctionRepository } from '../../../../../src/engine/function/sys
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const stringRepo = new StringFunctionRepository();
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     if (!fun) {
         throw new Error('Function not available');
@@ -48,7 +52,10 @@ test('StringRepo3 - EqualsIgnoreCase', async () => {
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map([
             [AbstractStringFunction.PARAMETER_STRING_NAME, '         no code  Kirun  PLATform   '],
             [

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

@@ -3,6 +3,7 @@ import { StringFunctionRepository } from '../../../../../src/engine/function/sys
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const repo = new StringFunctionRepository();
 
@@ -11,7 +12,10 @@ test('StringFunctionRepository - Trim', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(MapUtil.of(AbstractStringFunction.PARAMETER_STRING_NAME, ' Kiran '));
     expect(
         (await fun.execute(fep))
@@ -26,7 +30,10 @@ test('StringFunctionRepo -Repeat', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -51,7 +58,10 @@ test('StringFunctionRepo -Lowercase', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -73,7 +83,10 @@ test('StringFunctionRepo -UpperCase', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -95,7 +108,10 @@ test('StringFunctionRepo -Blank1', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of<string, string>(AbstractStringFunction.PARAMETER_STRING_NAME, ''));
 
@@ -112,7 +128,10 @@ test('StringFunctionRepo -Blank2', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -134,7 +153,10 @@ test('StringFunctionRepo -Empty1', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ''),
@@ -153,7 +175,10 @@ test('StringFunctionRepo -Empty2', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ' '),

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

@@ -1,18 +1,22 @@
 import { ToString } from '../../../../../src/engine/function/system/string/ToString';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const toString: ToString = new ToString();
 
 test('toString test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(MapUtil.of('anytype', 123));
 
     expect((await toString.execute(fep)).allResults()[0].getResult().get('result')).toBe('123');
 });
 
 // test('toString test2', async () => {
-//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(new KIRunFunctionRepository(), new KIRunSchemaRepository());
 
 //     let array: string[] = [];
 //     array.push('I');
@@ -36,7 +40,10 @@ test('toString test1', async () => {
 // });
 
 test('toString test2 ', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(MapUtil.of('anytype', true));
 
     expect((await toString.execute(fep)).allResults()[0].getResult().get('result')).toBe('true');

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

@@ -1,10 +1,14 @@
 import { TrimTo } from '../../../../../src/engine/function/system/string/TrimTo';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const trim: TrimTo = new TrimTo();
 
 test('Trim to test1 ', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map<string, string | number>([
             [TrimTo.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
             [TrimTo.PARAMETER_LENGTH_NAME, 14],
@@ -17,7 +21,10 @@ test('Trim to test1 ', async () => {
 });
 
 test('Trim to test2 ', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map<string, string | number>([
             [TrimTo.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
             [TrimTo.PARAMETER_LENGTH_NAME, 0],

package/__tests__/engine/json/schema/SchemaUtil.ts

@@ -0,0 +1,3 @@
+import { SchemaUtil } from '../../../../src';
+
+test('Schema Util Test', () => {});

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

@@ -0,0 +1,10 @@
+import { SchemaType, TypeUtil } from '../../../../../src';
+
+test('TypeUtilTest', () => {
+    expect(TypeUtil.from('Object')?.contains(SchemaType.OBJECT)).toBeTruthy();
+
+    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

@@ -1,3 +1,4 @@
+import { 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';
@@ -24,3 +25,31 @@ 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 Validator Test 2', () => {
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+    });
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace, name): Schema | undefined {
+                if (namespace === 'Test' && name === 'Location') {
+                    return locationSchema;
+                }
+                return undefined;
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    const obj = { url: 'http://xxxx.com' };
+
+    expect(SchemaValidator.validate(undefined, Schema.ofRef('Test.Location'), repo, obj)).toBe(obj);
+});

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -147,9 +147,12 @@ test('KIRuntime Test 1', async () => {
                 .setParameters(
                     new Map([['Count', new Parameter('Count', Schema.ofInteger('Count'))]]),
                 ) as FunctionDefinition,
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Count', num]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Count', num]])),
+        )
     ).allResults();
     console.log('KIRunt Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);
@@ -193,9 +196,12 @@ test('KIRuntime Test 2', async () => {
                     ),
                 ]),
             ),
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', -10]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Value', -10]])),
+        )
     ).allResults();
 
     expect(out[0].getResult().get('result')).toBe(10);
@@ -238,9 +244,12 @@ test('KIRuntime Test 3', async () => {
                     ),
                 ]),
             ),
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', 27]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Value', 27]])),
+        )
     ).allResults();
 
     expect(out[0].getResult().get('result')).toBe(3);
@@ -335,9 +344,11 @@ test('KIRuntime Test 4', async () => {
                     ),
                 ]),
             ),
-            hybrid,
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', num]])))
+        ).execute(
+            new FunctionExecutionParameters(hybrid, new KIRunSchemaRepository()).setArguments(
+                new Map([['Value', num]]),
+            ),
+        )
     ).allResults();
     console.log('KIRun Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);

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: {
@@ -71,12 +71,11 @@ test('KIRuntime With Definition 1', async () => {
 
     const fd = FunctionDefinition.from(def);
 
-    let result = await new KIRuntime(
-        fd,
-        new KIRunFunctionRepository(),
-        new KIRunSchemaRepository(),
-    ).execute(
-        new FunctionExecutionParameters().setArguments(
+    let result = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
             new Map([
                 ['a', 7],
                 ['b', 11],

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

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../src';
 import { Schema } from '../../../../src/engine/json/schema/Schema';
 import { ContextElement } from '../../../../src/engine/runtime/ContextElement';
 import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
@@ -34,7 +35,10 @@ test('Expression Test', () => {
         ['loop', new Map([['iteration', new Map([['index', 2]])]])],
     ]);
 
-    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters()
+    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
         .setArguments(new Map())
         .setContext(
             new Map([