@fincity/kirun-js 1.5.0 → 1.6.1

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

@@ -0,0 +1,280 @@
+import {
+    HybridRepository,
+    KIRunSchemaRepository,
+    ObjectValidator,
+    Repository,
+    Schema,
+    SchemaType,
+    SchemaValidator,
+} from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema Object validator test boolean value', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: false,
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+        name: 'Kiran',
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { type: 'INTEGER' },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+        name: 'Kiran',
+        num: 23,
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test boolean value old style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { booleanValue: false },
+    });
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+        name: 'Kiran',
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { schemaValue: { type: 'INTEGER' } },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+        name: 'Kiran',
+        num: 23,
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old ARRAY style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { schemaValue: { type: 'ARRAY' } },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    var obj = { name: 'Kiran', num: [1, 2, 3] };
+    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old Object style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: {
+            name: { type: 'STRING' },
+            lastname: { type: 'STRING' },
+            age: { type: 'INTEGER' },
+        },
+        additionalProperties: { schemaValue: { type: 'OBJECT' } },
+    });
+
+    var obj = { name: 'Kiran', age: 23 };
+    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+
+    var objwithAdditional = {
+        name: 'Kiran',
+        lastname: 'grandhi',
+        addresses: {
+            area: 'j.p.nagar',
+            city: 'banga',
+        },
+    };
+
+    expect(SchemaValidator.validate([], schema!, repo, objwithAdditional)).toStrictEqual(
+        objwithAdditional,
+    );
+
+    var objwithMoreAdditional = {
+        name: 'Kiran',
+        lastname: 'grandhi',
+        addresses: {
+            area: 'j.p.nagar',
+            city: 'banga',
+        },
+        city: 'kakinada',
+    };
+
+    expect(() => SchemaValidator.validate([], schema!, repo, objwithMoreAdditional)).toThrow();
+});
+
+test('Schema test with object value as null for any', () => {
+    let filterOperator = Schema.from({
+        namespace: 'test',
+        name: 'filterOperator',
+        version: 1,
+        type: 'STRING',
+        defaultValue: 'EQUALS',
+        enums: ['EQUALS', 'LESS_THAN', 'GREATER_THAN', 'LESS_THAN_EQUAL', 'BETWEEN', 'IN'],
+    });
+
+    let filterCondition = Schema.from({
+        namespace: 'test',
+        name: 'FilterCondition',
+        version: 1,
+        type: 'OBJECT',
+        properties: {
+            field: {
+                namespace: '_',
+                name: 'field',
+                version: 1,
+                type: 'STRING',
+            },
+            multiValue: {
+                namespace: '_',
+                name: 'multiValue',
+                version: 1,
+                type: 'ARRAY',
+                items: {
+                    namespace: '_',
+                    name: 'singleType',
+                    version: 1,
+                    type: [
+                        'FLOAT',
+                        'BOOLEAN',
+                        'STRING',
+                        'DOUBLE',
+                        'INTEGER',
+                        'LONG',
+                        'NULL',
+                        'ARRAY',
+                        'OBJECT',
+                    ],
+                },
+            },
+            isValue: {
+                namespace: '_',
+                name: 'isValue',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+            toValue: {
+                namespace: '_',
+                name: 'toValue',
+                version: 1,
+                type: [
+                    'FLOAT',
+                    'BOOLEAN',
+                    'STRING',
+                    'DOUBLE',
+                    'INTEGER',
+                    'LONG',
+                    'NULL',
+                    'ARRAY',
+                    'OBJECT',
+                ],
+            },
+            operator: {
+                namespace: '_',
+                version: 1,
+                ref: 'test.filterOperator',
+            },
+            negate: {
+                namespace: '_',
+                name: 'negate',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+            value: {
+                namespace: '_',
+                name: 'value',
+                version: 1,
+                type: [
+                    'FLOAT',
+                    'BOOLEAN',
+                    'STRING',
+                    'DOUBLE',
+                    'INTEGER',
+                    'LONG',
+                    'NULL',
+                    'ARRAY',
+                    'OBJECT',
+                ],
+            },
+            isToValue: {
+                namespace: '_',
+                name: 'isToValue',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+        },
+        additionalProperties: false,
+        required: ['operator', 'field'],
+    });
+
+    var schemaMap = new Map<string, Schema>();
+
+    schemaMap.set('filterOperator', filterOperator!);
+    schemaMap.set('FilterCondition', filterCondition!);
+
+    class TestRepository implements Repository<Schema> {
+        public find(namespace: string, name: string): Schema | undefined {
+            if (!namespace) {
+                return undefined;
+            }
+            return schemaMap.get(name);
+        }
+
+        public filter(name: string): string[] {
+            return [];
+        }
+    }
+    var repo = new HybridRepository(new TestRepository(), new KIRunSchemaRepository());
+
+    var tempOb2 = { field: 'nullcheck', operator: 'LESS_THAN', value: null, isValue: true };
+
+    var res3 = SchemaValidator.validate(undefined, filterCondition, repo, tempOb2);
+    expect(res3).toStrictEqual(tempOb2);
+});

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

@@ -0,0 +1,243 @@
+import { AdditionalType, 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);
+            },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
+        },
+        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);
+            },
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
+        },
+        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 AdditionalType().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 AdditionalType().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);
+            },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
+        },
+        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/json/schema/validator/SchemaValidatorTest.ts

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, HybridRepository } from '../../../../../src';
+import { AdditionalType, 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';
@@ -39,15 +39,13 @@ test('Schema validation when ref of ref', () => {
 
     const urlParamsSchema = Schema.ofObject('UrlParameters')
         .setNamespace('Test')
-        .setAdditionalProperties(
-            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.Location`)),
-        )
+        .setAdditionalProperties(new AdditionalType().setSchemaValue(Schema.ofRef(`Test.Location`)))
         .setDefaultValue({});
 
     const testSchema = Schema.ofObject('TestSchema')
         .setNamespace('Test')
         .setAdditionalProperties(
-            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
+            new AdditionalType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
         )
         .setDefaultValue({});
 
@@ -63,6 +61,12 @@ test('Schema validation when ref of ref', () => {
                 if (namespace !== 'Test') return undefined;
                 return schemaMap.get(name);
             },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .map((e) => e!.getFullName())
+                    .filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1);
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -95,6 +99,11 @@ test('Schema Validator Test 2', () => {
                 }
                 return undefined;
             },
+            filter(name): string[] {
+                return [locationSchema!.getFullName()].filter((n) =>
+                    n.toLowerCase().includes(name.toLowerCase()),
+                );
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -132,7 +141,14 @@ test('Schema Validator Test 3', () => {
                 }
                 return undefined;
             },
+
+            filter(name): string[] {
+                return [locationSchema!.getFullName()].filter((n) =>
+                    n.toLowerCase().includes(name.toLowerCase()),
+                );
+            },
         },
+
         new KIRunSchemaRepository(),
     );
 

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

@@ -129,7 +129,5 @@ test('String email valid case', () => {
 
     let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);
 
-    console.log(StringValidator.validate([], schema, value));
-
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });

package/__tests__/engine/repository/RepositoryFilterTest.ts

@@ -0,0 +1,39 @@
+import { KIRunSchemaRepository, KIRunFunctionRepository } from '../../../src';
+
+const funcRepo = new KIRunFunctionRepository();
+const schemaRepo = new KIRunSchemaRepository();
+
+test('Repository Filter Test', () => {
+    expect(funcRepo.filter('Rep')).toStrictEqual([
+        'System.String.Repeat',
+        'System.String.Replace',
+        'System.String.ReplaceFirst',
+        'System.String.PrePad',
+        'System.String.ReplaceAtGivenPosition',
+    ]);
+
+    expect(funcRepo.filter('root')).toStrictEqual([
+        'System.Math.CubeRoot',
+        'System.Math.SquareRoot',
+    ]);
+
+    expect(schemaRepo.filter('root')).toStrictEqual([]);
+
+    expect(schemaRepo.filter('rin')).toStrictEqual(['System.string']);
+
+    expect(schemaRepo.filter('ny')).toStrictEqual(['System.any']);
+
+    expect(schemaRepo.filter('')).toStrictEqual([
+        'System.any',
+        'System.boolean',
+        'System.double',
+        'System.float',
+        'System.integer',
+        'System.long',
+        'System.number',
+        'System.string',
+        'System.ParameterExpression',
+        'System.Null',
+        'System.Schema',
+    ]);
+});

package/__tests__/engine/runtime/KIRuntimeFunctionInFunction.ts

@@ -149,6 +149,12 @@ test('KIRuntime Function in Function', async () => {
             if (name === 'Third') return third;
             if (name === 'Second') return second;
         }
+
+        filter(name: string): string[] {
+            return [third.getSignature().getFullName(), second.getSignature().getFullName()].filter(
+                (e) => e.toLowerCase().includes(name.toLowerCase()),
+            );
+        }
     }
 
     const repo = new HybridRepository(new KIRunFunctionRepository(), new InternalRepository());

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -344,6 +344,12 @@ test('KIRuntime Test 4', async () => {
         find(namespace, name): Function {
             return fibFunction;
         },
+
+        filter(name: string): string[] {
+            return [fibFunction.getSignature().getFullName()].filter((e) =>
+                e.toLowerCase().includes(name.toLowerCase()),
+            );
+        },
     });
 
     start = new Date().getTime();

package/__tests__/indexTest.ts

@@ -9,6 +9,12 @@ class TestRepository {
     find(namespace: string, name: string): string | undefined {
         return TestRepository.TEST_INDEX.get(name);
     }
+
+    filter(name: string): string[] {
+        return Array.from(TestRepository.TEST_INDEX.keys()).filter(
+            (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
+        );
+    }
 }
 
 class TestRepository2 {
@@ -20,6 +26,12 @@ class TestRepository2 {
     find(namespace: string, name: string): string | undefined {
         return TestRepository2.TEST_INDEX.get(name);
     }
+
+    filter(name: string): string[] {
+        return Array.from(TestRepository.TEST_INDEX.keys()).filter(
+            (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
+        );
+    }
 }
 
 test('Hybrid Repository Test', () => {