@fincity/kirun-js 1.1.1 → 1.1.4

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/AnyOfAllOfOneOfValidatorTest.ts

@@ -0,0 +1,38 @@
+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";
+import { AnyOfAllOfOneOfValidator } from "../../../../../src/engine/json/schema/validator/AnyOfAllOfOneOfValidator";
+import { KIRunSchemaRepository } from "../../../../../src/engine/repository/KIRunSchemaRepository";
+
+const repo = new KIRunSchemaRepository();
+
+test("Any Of All Of One Validator Test 1", () => {
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], schema, repo, 10)).toBe(10);
+})
+
+test("Any Of All Of One Validator Test 2", () => {
+    let arraySchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.ARRAY));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], arraySchema, repo, [1, 2, 3])).toStrictEqual([1, 2, 3]);
+})
+
+test("Any Of All Of One Validator Test 3", () => {
+    let objSchema: Schema = Schema.ofObject("testObj").setProperties(new Map<string, Schema>([['key', Schema.ofString('key')]]));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { "key": "value" })).toStrictEqual({ "key": "value" });
+})
+
+test("Any Of All Of One Validator Test 3", () => {
+    let nullSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.NULL));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
+})
+
+test("Any Of All Of One Validator Test 3", () => {
+    let nullSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.BOOLEAN));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
+})
+

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,69 @@ 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);
+});
+
+test('Schema Validator Test 3', () => {
+    const obj = { url: 'http://xxxx.com' };
+
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+        defaultValue: obj,
+    });
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace, name): Schema | undefined {
+                if (namespace === 'Test' && name === 'Location') {
+                    return locationSchema;
+                }
+                return undefined;
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    const obj1 = { url: 'http://yyyy.com' };
+
+    expect(
+        SchemaValidator.validate(
+            undefined,
+            Schema.ofRef('Test.Location').setDefaultValue(obj1),
+            repo,
+            undefined,
+        ),
+    ).toMatchObject(obj1);
+});

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

@@ -0,0 +1,88 @@
+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 With Definition 1', async () => {
+    var def = {
+        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' } },
+        },
+        events: {
+            output: {
+                name: 'output',
+                parameters: { additionResult: { name: 'additionResult', type: 'Integer' } },
+            },
+        },
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: [
+                        { type: 'EXPRESSION', expression: 'Arguments.a' },
+                        { type: 'EXPRESSION', expression: '10 + 1' },
+                        { type: 'EXPRESSION', expression: 'Arguments.c' },
+                    ],
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                parameterMap: {
+                    eventName: [{ type: 'VALUE', value: 'output' }],
+                    results: [
+                        {
+                            type: 'VALUE',
+                            value: {
+                                name: 'additionResult',
+                                value: { isExpression: true, value: 'Steps.add.output.value' },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                ['a', 7],
+                ['b', 11],
+                ['c', 13],
+            ]),
+        ),
+    );
+
+    expect(result.allResults()[0].getResult().get('additionResult')).toBe(31);
+});

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([