@fincity/kirun-js 1.4.14 → 1.5.2

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

@@ -0,0 +1,226 @@
+import { AdditionalPropertiesType, ArraySchemaType, 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';
+import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
+import { SchemaValidator } from '../../../../../src/engine/json/schema/validator/SchemaValidator';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+
+test('filter condition with ref schema', () => {
+    let filterOperator: Schema = Schema.ofString('filterOperator')
+        .setNamespace('Test')
+        .setEnums(['EQUALS', 'LESS_THAN', 'GREATER_THAN', 'LESS_THAN_EQUAL']);
+
+    let filterCondition: Schema = Schema.ofObject('filterCondition')
+        .setNamespace('Test')
+        .setProperties(
+            new Map<string, Schema>([
+                ['negate', Schema.ofBoolean('negate')],
+                ['filterConditionOperator', Schema.ofRef('Test.filterOperator')],
+                ['field', Schema.ofString('field')],
+                ['value', Schema.ofAny('value')],
+                ['toValue', Schema.ofAny('toValue')],
+                [
+                    'multiValue',
+                    Schema.ofArray('multiValue').setItems(
+                        new ArraySchemaType().setSingleSchema(Schema.ofAny('singleType')),
+                    ),
+                ],
+                ['isValue', Schema.ofBoolean('isValue')],
+                ['isToValue', Schema.ofBoolean('isToValue')],
+            ]),
+        );
+
+    var schemaMap = new Map<string, Schema>([
+        ['filterOperator', filterOperator],
+        ['filterCondition', filterCondition],
+    ]);
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace: string, name: string): Schema | undefined {
+                if (namespace !== 'Test') return undefined;
+                return schemaMap.get(name);
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    var tempOb = {
+        field: 'a.b.c.d',
+        value: 'surendhar',
+        filterConditionOperator: 'LESS_THAN',
+        negate: true,
+        isValue: false,
+    };
+
+    expect(SchemaValidator.validate([], filterCondition, repo, tempOb)).toBe(tempOb);
+});
+
+test('complex condition with ref schema', () => {
+    let complexOperator: Schema = Schema.ofString('complexOperator')
+        .setNamespace('Test')
+        .setEnums(['AND', 'OR']);
+
+    // let arraySchema: Schema = Schema.ofArray('conditions', Schema.ofRef('#'));
+    let arraySchema: Schema = Schema.ofArray('conditions', Schema.ofRef('Test.complexCondition'));
+
+    let complexCondition: Schema = Schema.ofObject('complexCondition')
+        .setNamespace('Test')
+        .setProperties(
+            new Map<string, Schema>([
+                ['negate', Schema.ofBoolean('negate')],
+                ['complexConditionOperator', Schema.ofRef('Test.complexOperator')],
+                ['conditions', arraySchema],
+            ]),
+        );
+
+    var schemaMap = new Map<string, Schema>([
+        ['complexOperator', complexOperator],
+        ['complexCondition', complexCondition],
+    ]);
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace: string, name: string): Schema | undefined {
+                if (namespace !== 'Test') return undefined;
+                return schemaMap.get(name);
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    let ja: any[] = [];
+
+    let mjob = {
+        conditions: [...ja],
+        negate: true,
+        complexConditionOperator: 'AND',
+    };
+
+    let njob = {
+        conditions: [...ja],
+        negate: true,
+        complexConditionOperator: 'OR',
+    };
+
+    ja.push(mjob);
+    ja.push(njob);
+
+    let bjob = {
+        conditions: [...ja],
+        negate: true,
+        complexConditionOperator: 'AND',
+    };
+
+    expect(SchemaValidator.validate([], complexCondition, repo, bjob)).toBe(bjob);
+});
+
+test('filter complex condition with ref schema', () => {
+    let filterOperator: Schema = Schema.ofString('filterOperator')
+        .setNamespace('Test')
+        .setEnums(['EQUALS', 'LESS_THAN', 'GREATER_THAN', 'LESS_THAN_EQUAL', 'IN'])
+        .setDefaultValue('EQUALS');
+
+    let filterCondition: Schema = Schema.ofObject('filterCondition')
+        .setNamespace('Test')
+        .setProperties(
+            new Map<string, Schema>([
+                ['negate', Schema.ofBoolean('negate').setDefaultValue(false)],
+                ['operator', Schema.ofRef('Test.filterOperator')],
+                ['field', Schema.ofString('field')],
+                ['value', Schema.ofAny('value')],
+                ['toValue', Schema.ofAny('toValue')],
+                [
+                    'multiValue',
+                    Schema.ofArray('multiValue').setItems(
+                        new ArraySchemaType().setSingleSchema(Schema.ofAny('singleType')),
+                    ),
+                ],
+                ['isValue', Schema.ofBoolean('isValue').setDefaultValue(false)],
+                ['isToValue', Schema.ofBoolean('isToValue').setDefaultValue(false)],
+            ]),
+        )
+        .setRequired(['operator', 'field'])
+        .setAdditionalProperties(new AdditionalPropertiesType().setBooleanValue(false));
+
+    let complexOperator: Schema = Schema.ofString('complexOperator')
+        .setNamespace('Test')
+        .setEnums(['AND', 'OR']);
+
+    let arraySchema: Schema = Schema.ofArray(
+        'conditions',
+        new Schema().setAnyOf([Schema.ofRef('#'), Schema.ofRef('Test.FilterCondition')]),
+    );
+
+    let complexCondition: Schema = Schema.ofObject('complexCondition')
+        .setNamespace('Test')
+        .setProperties(
+            new Map<string, Schema>([
+                ['conditions', arraySchema],
+                ['negate', Schema.ofBoolean('negate').setDefaultValue(false)],
+                ['operator', Schema.ofRef('Test.complexOperator')],
+            ]),
+        )
+        .setRequired(['conditions', 'operator'])
+        .setAdditionalProperties(new AdditionalPropertiesType().setBooleanValue(false));
+
+    var schemaMap = new Map<string, Schema>([
+        ['filterOperator', filterOperator],
+        ['filterCondition', filterCondition],
+        ['complexOperator', complexOperator],
+        ['complexCondition', complexCondition],
+    ]);
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace: string, name: string): Schema | undefined {
+                if (namespace !== 'Test') return undefined;
+                return schemaMap.get(name);
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    var tempOb = {
+        field: 'a.b.c.d',
+        value: 'surendhar',
+        operator: 'LESS_THAN',
+        negate: true,
+        isValue: false,
+    };
+
+    var tempOb1 = {
+        ...tempOb,
+        operator: 'GREATER_THAN',
+        isValue: true,
+    };
+
+    var tempOb2 = {
+        field: 'k.lm.mno',
+        operator: 'IN',
+        multiValue: [1, 2, 3, 4, 5, 5, 6, 7],
+        negate: true,
+    };
+    var ja: any[] = [];
+
+    ja.push(tempOb);
+    ja.push(tempOb1);
+    ja.push(tempOb2);
+
+    var mjob = {
+        conditions: [],
+        negate: false,
+        operator: 'AND',
+    };
+
+    var bjob = {
+        conditions: [mjob],
+        negate: true,
+        operator: 'OR',
+    };
+
+    var res = SchemaValidator.validate([], complexCondition, repo, bjob);
+
+    expect(res).toBe(bjob);
+});

package/__tests__/engine/runtime/KIRuntimeTestWithoutGenEvent.ts

@@ -0,0 +1,214 @@
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
+
+test('KIRuntime Without Gen Event 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' } },
+        },
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'EXPRESSION', expression: '10 + 1' },
+                        three: { key: 'three', type: 'EXPRESSION', expression: 'Arguments.c' },
+                    },
+                },
+            },
+            print: {
+                statementName: 'print',
+                namespace: Namespaces.SYSTEM,
+                name: 'Print',
+                parameterMap: {
+                    values: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add.output.value',
+                            order: 2,
+                        },
+                        abc: {
+                            key: 'abc',
+                            type: 'VALUE',
+                            value: 'Nothing muchh....',
+                            order: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const test = (console.log = jest.fn().mockImplementation(() => {}));
+
+    await new KIRuntime(fd, false).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                ['a', 7],
+                ['b', 11],
+                ['c', 13],
+            ]),
+        ),
+    );
+    expect(test.mock.calls[0][0]).toBe('Nothing muchh....');
+    expect(test.mock.calls[0][1]).toBe(31);
+});
+
+test('KIRuntime Without Gen Event Definition 2', 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: {},
+            },
+        },
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'EXPRESSION', expression: '10 + 1' },
+                        three: { key: 'three', type: 'EXPRESSION', expression: 'Arguments.c' },
+                    },
+                },
+            },
+            print: {
+                statementName: 'print',
+                namespace: Namespaces.SYSTEM,
+                name: 'Print',
+                parameterMap: {
+                    values: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add.output.value',
+                            order: 2,
+                        },
+                        abc: {
+                            key: 'abc',
+                            type: 'VALUE',
+                            value: 'Something muchh....',
+                            order: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const test = (console.log = jest.fn().mockImplementation(() => {}));
+
+    await new KIRuntime(fd, false).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                ['a', 7],
+                ['b', 11],
+                ['c', 13],
+            ]),
+        ),
+    );
+    expect(test.mock.calls[0][0]).toBe('Something muchh....');
+    expect(test.mock.calls[0][1]).toBe(31);
+});
+
+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: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'EXPRESSION', expression: '10 + 1' },
+                        three: { key: 'three', type: 'EXPRESSION', expression: 'Arguments.c' },
+                    },
+                },
+            },
+            print: {
+                statementName: 'print',
+                namespace: Namespaces.SYSTEM,
+                name: 'Print',
+                parameterMap: {
+                    values: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add.output.value',
+                            order: 2,
+                        },
+                        abc: {
+                            key: 'abc',
+                            type: 'VALUE',
+                            value: 'Something muchh....',
+                            order: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const fep = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
+        new Map([
+            ['a', 7],
+            ['b', 11],
+            ['c', 13],
+        ]),
+    );
+
+    const runtime = new KIRuntime(fd, false);
+
+    await expect(() => runtime.execute(fep)).rejects.toThrowError();
+});