@fincity/kirun-js 1.9.1 → 2.0.1

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

@@ -10,10 +10,10 @@ import {
 
 const repo = new KIRunSchemaRepository();
 
-test('Schema Validator fail with date test', () => {
+test('Schema Validator fail with date test', async () => {
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
 
-    expect(SchemaValidator.validate([], schema, repo, 2)).toBe(2);
+    expect(await SchemaValidator.validate([], schema, repo, 2)).toBe(2);
 
     let obj = { name: 'shagil' };
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -25,17 +25,17 @@ test('Schema Validator fail with date test', () => {
         )
         .setRequired(['name', 'date']);
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, obj)).toThrow('date is mandatory');
+    expect(SchemaValidator.validate([], objSchema, repo, obj)).rejects.toThrow('date is mandatory');
     const dateObj = { name: 'surendhar.s', date: '1999-13-12' };
     const errorMsg =
         'Value {"name":"surendhar.s","date":"1999-13-12"} is not of valid type(s)' +
         '\n' +
         'Type is missing in schema for declared DATE format.';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, dateObj)).toThrow(errorMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, dateObj)).rejects.toThrow(errorMsg);
 });
 
-test('Schema Validator pass with date test ', () => {
+test('Schema Validator pass with date test ', async () => {
     let intSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER)).setMinimum(100);
 
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -55,10 +55,10 @@ test('Schema Validator pass with date test ', () => {
 
     const dateObj = { intSchema: 1231, date: '1999-09-12' };
 
-    expect(SchemaValidator.validate([], objSchema, repo, dateObj)).toBe(dateObj);
+    expect(await SchemaValidator.validate([], objSchema, repo, dateObj)).toBe(dateObj);
 });
 
-test('Schema Validator fail with time string type missing test ', () => {
+test('Schema Validator fail with time string type missing test ', async () => {
     let intSchema: Schema = new Schema()
         .setType(TypeUtil.of(SchemaType.INTEGER))
         .setMaximum(100)
@@ -80,10 +80,10 @@ test('Schema Validator fail with time string type missing test ', () => {
         'Value {"intSchema":95,"time":"22:23:61","name":"s.surendhar"} is not of valid type(s)\n' +
         'Type is missing in schema for declared TIME format.';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, timeObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, timeObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator fail with time test ', () => {
+test('Schema Validator fail with time test ', async () => {
     let intSchema: Schema = new Schema()
         .setType(TypeUtil.of(SchemaType.INTEGER))
         .setMaximum(100)
@@ -111,10 +111,10 @@ test('Schema Validator fail with time test ', () => {
         'Value "22:23:61" is not of valid type(s)\n' +
         '22:23:61 is not matched with the time pattern';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, timeObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, timeObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator pass with time test ', () => {
+test('Schema Validator pass with time test ', async () => {
     let intSchema: Schema = new Schema()
         .setType(TypeUtil.of(SchemaType.INTEGER))
         .setMaximum(100)
@@ -137,10 +137,10 @@ test('Schema Validator pass with time test ', () => {
 
     const timeObj = { intSchema: 95, time: '22:23:24', name: 's.surendhar' };
 
-    expect(SchemaValidator.validate([], objSchema, repo, timeObj)).toBe(timeObj);
+    expect(await SchemaValidator.validate([], objSchema, repo, timeObj)).toBe(timeObj);
 });
 
-test('Schema Validator fail with email string type missing test ', () => {
+test('Schema Validator fail with email string type missing test ', async () => {
     let intSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER)).setMaximum(100);
 
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -159,10 +159,10 @@ test('Schema Validator fail with email string type missing test ', () => {
         'Value {"intSchema":95,"email":"iosdjfdf123--@gmail.com","name":"s.surendhar"} is not of valid type(s)\n' +
         'Type is missing in schema for declared EMAIL format.';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, emailObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, emailObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator fail with email test ', () => {
+test('Schema Validator fail with email test ', async () => {
     let intSchema: Schema = new Schema()
         .setType(TypeUtil.of(SchemaType.INTEGER))
         .setMaximum(3)
@@ -190,10 +190,10 @@ test('Schema Validator fail with email test ', () => {
         'Value "asdasdf@@*.com" is not of valid type(s)\n' +
         'asdasdf@@*.com is not matched with the email pattern';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, emailObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, emailObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator pass with time test ', () => {
+test('Schema Validator pass with time test ', async () => {
     let intSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
 
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -213,10 +213,10 @@ test('Schema Validator pass with time test ', () => {
 
     const emailObj = { intSchema: 95, email: 'surendhar.s@finc.c', name: 's.surendhar' };
 
-    expect(SchemaValidator.validate([], objSchema, repo, emailObj)).toBe(emailObj);
+    expect(await SchemaValidator.validate([], objSchema, repo, emailObj)).toBe(emailObj);
 });
 
-test('Schema Validator fail with dateTime string type missing test ', () => {
+test('Schema Validator fail with dateTime string type missing test ', async () => {
     let intSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER)).setMaximum(100);
 
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -235,10 +235,10 @@ test('Schema Validator fail with dateTime string type missing test ', () => {
         'Value {"intSchema":95,"dateTime":"2023-08-21T07:56:45+12:12","name":"s.surendhar"} is not of valid type(s)\n' +
         'Type is missing in schema for declared DATETIME format.';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, emailObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, emailObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator fail with dateTime test ', () => {
+test('Schema Validator fail with dateTime test ', async () => {
     let intSchema: Schema = new Schema()
         .setType(TypeUtil.of(SchemaType.INTEGER))
         .setMaximum(3)
@@ -266,10 +266,10 @@ test('Schema Validator fail with dateTime test ', () => {
         'Value "2023-08-221T07:56:45+12:12" is not of valid type(s)\n' +
         '2023-08-221T07:56:45+12:12 is not matched with the date time pattern';
 
-    expect(() => SchemaValidator.validate([], objSchema, repo, dateTimeObj)).toThrow(errMsg);
+    expect(SchemaValidator.validate([], objSchema, repo, dateTimeObj)).rejects.toThrow(errMsg);
 });
 
-test('Schema Validator pass with time test ', () => {
+test('Schema Validator pass with time test ', async () => {
     let intSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
 
     let objSchema: Schema = Schema.ofObject('testObj')
@@ -293,7 +293,7 @@ test('Schema Validator pass with time test ', () => {
         name: 's.surendhar',
     };
 
-    expect(SchemaValidator.validate([], objSchema, repo, dateTimeObj)).toBe(dateTimeObj);
+    expect(await SchemaValidator.validate([], objSchema, repo, dateTimeObj)).toBe(dateTimeObj);
 });
 
 const dateTimeObj = { dateTime: '2023-08-21T07:56:45+12:12' };

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

@@ -9,20 +9,20 @@ import { StringValidator } from '../../../../../src';
 
 const repo = new KIRunSchemaRepository();
 
-test('String valid case', () => {
+test('String valid case', async () => {
     let value: String = 'surendhar';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING));
 
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String invalid case', () => {
+test('String invalid case', async () => {
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING));
 
     expect(() => StringValidator.validate([], schema, 123).toThrow(123 + ' is not String'));
 });
 
-test('String min length invalid', () => {
+test('String min length invalid', async () => {
     let value: String = 'abcd';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMinLength(5);
 
@@ -33,7 +33,7 @@ test('String min length invalid', () => {
     );
 });
 
-test('String max length invalid', () => {
+test('String max length invalid', async () => {
     let value: String = 'surendhar';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMaxLength(8);
 
@@ -44,21 +44,21 @@ test('String max length invalid', () => {
     );
 });
 
-test('String min length', () => {
+test('String min length', async () => {
     let value: String = 'abcdefg';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMinLength(5);
 
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String max length', () => {
+test('String max length', async () => {
     let value: String = 'surendhar';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMaxLength(12323);
 
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String date invalid case', () => {
+test('String date invalid case', async () => {
     let value: String = '1234-12-1245';
 
     let schema: Schema = new Schema().setFormat(StringFormat.DATE);
@@ -70,7 +70,7 @@ test('String date invalid case', () => {
     );
 });
 
-test('String date valid case', () => {
+test('String date valid case', async () => {
     let value: String = '2023-01-26';
 
     let schema: Schema = new Schema().setFormat(StringFormat.DATE);
@@ -78,7 +78,7 @@ test('String date valid case', () => {
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String time invalid case', () => {
+test('String time invalid case', async () => {
     let value: String = '231:45:56';
 
     let schema: Schema = new Schema().setFormat(StringFormat.TIME);
@@ -88,7 +88,7 @@ test('String time invalid case', () => {
     );
 });
 
-test('String time valid case', () => {
+test('String time valid case', async () => {
     let value: String = '22:32:45';
 
     let schema: Schema = new Schema().setFormat(StringFormat.TIME);
@@ -96,7 +96,7 @@ test('String time valid case', () => {
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String date time invalid case', () => {
+test('String date time invalid case', async () => {
     let value: String = '26-jan-2023 231:45:56';
 
     let schema: Schema = new Schema().setFormat(StringFormat.DATETIME);
@@ -106,7 +106,7 @@ test('String date time invalid case', () => {
     );
 });
 
-test('String date time valid case', () => {
+test('String date time valid case', async () => {
     let value: String = '2032-02-12T02:54:23';
 
     let schema: Schema = new Schema().setFormat(StringFormat.DATETIME);
@@ -114,7 +114,7 @@ test('String date time valid case', () => {
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });
 
-test('String email invalid case', () => {
+test('String email invalid case', async () => {
     let value: String = 'testemail fai%6&8ls@gmail.com';
 
     let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);
@@ -124,7 +124,7 @@ test('String email invalid case', () => {
     );
 });
 
-test('String email valid case', () => {
+test('String email valid case', async () => {
     let value: String = 'testemaifai%6&8lworkings@magil.com';
 
     let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);

package/__tests__/engine/repository/KIRunFunctionRepositoryTest.ts

@@ -1,29 +1,29 @@
 import { KIRunFunctionRepository, Namespaces } from '../../../src';
 
-test('KIRunFunctionRepository Test', () => {
+test('KIRunFunctionRepository Test', async () => {
     const repo = new KIRunFunctionRepository();
 
-    let fun = repo.find(Namespaces.STRING, 'ToString');
+    let fun = await repo.find(Namespaces.STRING, 'ToString');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('ToString');
 
-    fun = repo.find(Namespaces.STRING, 'IndexOfWithStartPoint');
+    fun = await repo.find(Namespaces.STRING, 'IndexOfWithStartPoint');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('IndexOfWithStartPoint');
 
-    fun = repo.find(Namespaces.SYSTEM_ARRAY, 'Compare');
+    fun = await repo.find(Namespaces.SYSTEM_ARRAY, 'Compare');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('Compare');
 
-    fun = repo.find(Namespaces.MATH, 'RandomInt');
+    fun = await repo.find(Namespaces.MATH, 'RandomInt');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('RandomInt');
 
-    fun = repo.find(Namespaces.MATH, 'Exponential');
+    fun = await repo.find(Namespaces.MATH, 'Exponential');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('Exponential');
 
-    fun = repo.find(Namespaces.SYSTEM, 'If');
+    fun = await repo.find(Namespaces.SYSTEM, 'If');
     expect(fun).toBeTruthy();
     expect(fun?.getSignature().getName()).toBe('If');
 });

package/__tests__/engine/repository/RepositoryFilterTest.ts

@@ -3,8 +3,8 @@ import { KIRunSchemaRepository, KIRunFunctionRepository } from '../../../src';
 const funcRepo = new KIRunFunctionRepository();
 const schemaRepo = new KIRunSchemaRepository();
 
-test('Repository Filter Test', () => {
-    expect(funcRepo.filter('Rep')).toStrictEqual([
+test('Repository Filter Test', async () => {
+    expect(await funcRepo.filter('Rep')).toStrictEqual([
         'System.String.Repeat',
         'System.String.Replace',
         'System.String.ReplaceFirst',
@@ -12,18 +12,18 @@ test('Repository Filter Test', () => {
         'System.String.ReplaceAtGivenPosition',
     ]);
 
-    expect(funcRepo.filter('root')).toStrictEqual([
+    expect(await funcRepo.filter('root')).toStrictEqual([
         'System.Math.CubeRoot',
         'System.Math.SquareRoot',
     ]);
 
-    expect(schemaRepo.filter('root')).toStrictEqual([]);
+    expect(await schemaRepo.filter('root')).toStrictEqual([]);
 
-    expect(schemaRepo.filter('rin')).toStrictEqual(['System.string']);
+    expect(await schemaRepo.filter('rin')).toStrictEqual(['System.string']);
 
-    expect(schemaRepo.filter('ny')).toStrictEqual(['System.any']);
+    expect(await schemaRepo.filter('ny')).toStrictEqual(['System.any']);
 
-    expect(schemaRepo.filter('')).toStrictEqual([
+    expect(await schemaRepo.filter('')).toStrictEqual([
         'System.any',
         'System.boolean',
         'System.double',

package/__tests__/engine/runtime/KIRuntimeFunctionInFunction.ts

@@ -143,16 +143,20 @@ test('KIRuntime Function in Function', async () => {
     );
 
     class InternalRepository implements Repository<Function> {
-        find(namespace: string, name: string): Function | undefined {
-            if (namespace !== 'Internal') return;
+        async find(namespace: string, name: string): Promise<Function | undefined> {
+            if (namespace !== 'Internal') return Promise.resolve(undefined);
 
-            if (name === 'Third') return third;
-            if (name === 'Second') return second;
+            if (name === 'Third') return Promise.resolve(third);
+            if (name === 'Second') return Promise.resolve(second);
+
+            return Promise.resolve(undefined);
         }
 
-        filter(name: string): string[] {
-            return [third.getSignature().getFullName(), second.getSignature().getFullName()].filter(
-                (e) => e.toLowerCase().includes(name.toLowerCase()),
+        async filter(name: string): Promise<string[]> {
+            return Promise.resolve(
+                [third.getSignature().getFullName(), second.getSignature().getFullName()].filter(
+                    (e) => e.toLowerCase().includes(name.toLowerCase()),
+                ),
             );
         }
     }

package/__tests__/engine/runtime/KIRuntimeNoParamMapTest.ts

@@ -29,10 +29,10 @@ test('KIRuntime Without any parameter map passed in definition', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }

package/__tests__/engine/runtime/KIRuntimeNoValuesTest.ts

@@ -31,10 +31,10 @@ test('KIRuntime With Definition without values object inside parameter Map', asy
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -340,17 +340,19 @@ test('KIRuntime Test 4', async () => {
     var expression = { isExpression: true, value: 'Steps.fib.output.value' };
     let resultObj = { name: 'result', value: expression };
 
-    var hybrid = new HybridRepository(new KIRunFunctionRepository(), {
-        find(namespace, name): Function {
+    class X {
+        async find(namespace: string, name: string): Promise<Function> {
             return fibFunction;
-        },
+        }
 
-        filter(name: string): string[] {
+        async filter(name: string): Promise<string[]> {
             return [fibFunction.getSignature().getFullName()].filter((e) =>
                 e.toLowerCase().includes(name.toLowerCase()),
             );
-        },
-    });
+        }
+    }
+
+    var hybrid = new HybridRepository(new KIRunFunctionRepository(), new X());
 
     start = new Date().getTime();
     let out: EventResult[] = (

package/__tests__/engine/runtime/KIRuntimeTestWithoutGenEvent.ts

@@ -53,6 +53,7 @@ test('KIRuntime Without Gen Event Definition 1', async () => {
 
     const fd = FunctionDefinition.from(def);
 
+    const oldConsole = console.log;
     const test = (console.log = jest.fn().mockImplementation(() => {}));
 
     await new KIRuntime(fd, false).execute(
@@ -67,6 +68,7 @@ test('KIRuntime Without Gen Event Definition 1', async () => {
             ]),
         ),
     );
+    console.log = oldConsole;
     expect(test.mock.calls[0][0]).toBe('Nothing muchh....');
     expect(test.mock.calls[0][1]).toBe(31);
 });
@@ -124,7 +126,7 @@ test('KIRuntime Without Gen Event Definition 2', async () => {
     };
 
     const fd = FunctionDefinition.from(def);
-
+    const oldConsole = console.log;
     const test = (console.log = jest.fn().mockImplementation(() => {}));
 
     await new KIRuntime(fd, false).execute(
@@ -139,6 +141,7 @@ test('KIRuntime Without Gen Event Definition 2', async () => {
             ]),
         ),
     );
+    console.log = oldConsole;
     expect(test.mock.calls[0][0]).toBe('Something muchh....');
     expect(test.mock.calls[0][1]).toBe(31);
 });

package/__tests__/engine/runtime/KIRuntimeUndefinedParamTest.ts

@@ -71,25 +71,21 @@ test('KIRuntime Undefined and null param type with varargs', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }
 
-    try {
-        var fo: FunctionOutput = await new KIRuntime(fd).execute(
-            new FunctionExecutionParameters(
-                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
-                new KIRunSchemaRepository(),
-            ).setArguments(new Map()),
-        );
-        expect(fo.allResults()).toStrictEqual([]);
-    } catch (e: any) {
-        console.error(e);
-    }
+    var fo: FunctionOutput = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map()),
+    );
+    expect(fo.allResults()[0].getResult().size).toBe(0);
 });
 
 test('KIRuntime Undefined and null param type without varargs', async () => {
@@ -115,23 +111,24 @@ test('KIRuntime Undefined and null param type without varargs', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }
 
-    try {
-        var fo: FunctionOutput = await new KIRuntime(fd).execute(
-            new FunctionExecutionParameters(
-                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
-                new KIRunSchemaRepository(),
-            ).setArguments(new Map()),
-        );
-        expect(fo.allResults()).toStrictEqual([]);
-    } catch (e: any) {
-        console.error(e);
-    }
+    expect(
+        (
+            await new KIRuntime(fd).execute(
+                new FunctionExecutionParameters(
+                    new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                    new KIRunSchemaRepository(),
+                ).setArguments(new Map()),
+            )
+        )
+            .allResults()[0]
+            .getResult().size,
+    ).toBe(0);
 });

package/__tests__/engine/runtime/KIRuntimeValuesEmptyTest.ts

@@ -79,10 +79,10 @@ test('KIRuntime With Definition no values passed ', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }
@@ -121,10 +121,10 @@ test('KIRuntime With Definition with no value passed', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }
@@ -164,10 +164,10 @@ test('KIRuntime With Definition with no value and values passed', async () => {
     const tstPrint = new Print();
 
     class TestRepository implements Repository<Function> {
-        public find(namespace: string, name: string): Function | undefined {
+        public async find(namespace: string, name: string): Promise<Function | undefined> {
             return tstPrint;
         }
-        filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             throw new Error('Method not implemented.');
         }
     }

package/__tests__/indexTest.ts

@@ -1,45 +1,45 @@
-import { HybridRepository } from '../src/index';
+import { HybridRepository, Repository } from '../src/index';
 
-class TestRepository {
+class TestRepository implements Repository<string> {
     static TEST_INDEX: Map<string, string> = new Map<string, string>([
         ['one', 'one'],
         ['one1', 'one1'],
     ]);
 
-    find(namespace: string, name: string): string | undefined {
+    async find(namespace: string, name: string): Promise<string | undefined> {
         return TestRepository.TEST_INDEX.get(name);
     }
 
-    filter(name: string): string[] {
+    async filter(name: string): Promise<string[]> {
         return Array.from(TestRepository.TEST_INDEX.keys()).filter(
             (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
         );
     }
 }
 
-class TestRepository2 {
+class TestRepository2 implements Repository<string> {
     static TEST_INDEX: Map<string, string> = new Map<string, string>([
         ['two', 'two'],
         ['two1', 'two1'],
     ]);
 
-    find(namespace: string, name: string): string | undefined {
+    async find(namespace: string, name: string): Promise<string | undefined> {
         return TestRepository2.TEST_INDEX.get(name);
     }
 
-    filter(name: string): string[] {
+    async filter(name: string): Promise<string[]> {
         return Array.from(TestRepository.TEST_INDEX.keys()).filter(
             (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
         );
     }
 }
 
-test('Hybrid Repository Test', () => {
+test('Hybrid Repository Test', async () => {
     let hybrid: HybridRepository<string> = new HybridRepository<string>(
         new TestRepository(),
         new TestRepository2(),
     );
 
-    expect(hybrid.find('', 'one')).toBe('one');
-    expect(hybrid.find('', 'two1')).toBe('two1');
+    expect(await hybrid.find('', 'one')).toBe('one');
+    expect(await hybrid.find('', 'two1')).toBe('two1');
 });