@fincity/kirun-js 1.5.2 → 1.6.3

package/src/engine/json/schema/Schema.ts

@@ -9,19 +9,20 @@ import { SingleType } from './type/SingleType';
 import { MultipleType } from './type/MultipleType';
 
 const ADDITIONAL_PROPERTY: string = 'additionalProperty';
+const ADDITIONAL_ITEMS: string = 'additionalItems';
 const ENUMS: string = 'enums';
 const ITEMS_STRING: string = 'items';
-const SCHEMA_ROOT_PATH: string = '#/';
+const SCHEMA_ROOT_PATH: string = 'System.Schema';
 const REQUIRED_STRING: string = 'required';
 const VERSION_STRING: string = 'version';
 const NAMESPACE_STRING: string = 'namespace';
 const TEMPORARY: string = '_';
 
-export class AdditionalPropertiesType {
+export class AdditionalType {
     private booleanValue?: boolean;
     private schemaValue?: Schema;
 
-    constructor(apt: AdditionalPropertiesType | undefined = undefined) {
+    constructor(apt: AdditionalType | undefined = undefined) {
         if (!apt) return;
         this.booleanValue = apt.booleanValue;
         if (!apt.schemaValue) return;
@@ -36,21 +37,27 @@ export class AdditionalPropertiesType {
         return this.schemaValue;
     }
 
-    public setBooleanValue(booleanValue: boolean): AdditionalPropertiesType {
+    public setBooleanValue(booleanValue: boolean): AdditionalType {
         this.booleanValue = booleanValue;
         return this;
     }
 
-    public setSchemaValue(schemaValue: Schema): AdditionalPropertiesType {
+    public setSchemaValue(schemaValue: Schema): AdditionalType {
         this.schemaValue = schemaValue;
         return this;
     }
 
-    public static from(obj: any): AdditionalPropertiesType | undefined {
-        if (!obj) return undefined;
-        const ad = new AdditionalPropertiesType();
-        ad.booleanValue = obj.booleanValue;
-        ad.schemaValue = obj.schemaValue;
+    public static from(obj: any): AdditionalType | undefined {
+        if (isNullValue(obj)) return undefined;
+        const ad = new AdditionalType();
+        if (typeof obj === 'boolean') ad.booleanValue = obj;
+        else {
+            let keys = Object.keys(obj);
+            if (keys.indexOf('booleanValue') != -1) ad.booleanValue = obj.booleanValue;
+            else if (keys.indexOf('schemaValue') != -1)
+                ad.schemaValue = Schema.from(obj.schemaValue);
+            else ad.schemaValue = Schema.from(obj);
+        }
         return ad;
     }
 }
@@ -133,9 +140,7 @@ export class Schema {
                 [
                     'properties',
                     Schema.of('properties', SchemaType.OBJECT).setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(
-                            Schema.ofRef(SCHEMA_ROOT_PATH),
-                        ),
+                        new AdditionalType().setSchemaValue(Schema.ofRef(SCHEMA_ROOT_PATH)),
                     ),
                 ],
                 [
@@ -162,9 +167,7 @@ export class Schema {
                 [
                     'patternProperties',
                     Schema.of('patternProperties', SchemaType.OBJECT).setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(
-                            Schema.ofRef(SCHEMA_ROOT_PATH),
-                        ),
+                        new AdditionalType().setSchemaValue(Schema.ofRef(SCHEMA_ROOT_PATH)),
                     ),
                 ],
 
@@ -179,16 +182,25 @@ export class Schema {
                 ],
 
                 ['contains', Schema.ofRef(SCHEMA_ROOT_PATH)],
+                ['minContains', Schema.ofInteger('minContains')],
+                ['maxContains', Schema.ofInteger('maxContains')],
                 ['minItems', Schema.ofInteger('minItems')],
                 ['maxItems', Schema.ofInteger('maxItems')],
                 ['uniqueItems', Schema.ofBoolean('uniqueItems')],
-
+                [
+                    'additionalItems',
+                    new Schema()
+                        .setName(ADDITIONAL_ITEMS)
+                        .setNamespace(Namespaces.SYSTEM)
+                        .setAnyOf([
+                            Schema.ofBoolean(ADDITIONAL_ITEMS),
+                            Schema.ofObject(ADDITIONAL_ITEMS).setRef(SCHEMA_ROOT_PATH),
+                        ]),
+                ],
                 [
                     '$defs',
                     Schema.of('$defs', SchemaType.OBJECT).setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(
-                            Schema.ofRef(SCHEMA_ROOT_PATH),
-                        ),
+                        new AdditionalType().setSchemaValue(Schema.ofRef(SCHEMA_ROOT_PATH)),
                     ),
                 ],
 
@@ -288,8 +300,8 @@ export class Schema {
             .setItems(ArraySchemaType.of(...itemSchemas));
     }
 
-    public static fromListOfSchemas(list: any): Schema[] {
-        if (isNullValue(list) && !Array.isArray(list)) return [];
+    public static fromListOfSchemas(list: any): Schema[] | undefined {
+        if (isNullValue(list) && !Array.isArray(list)) return undefined;
         let x: Schema[] = [];
         for (let e of Array.from(list)) {
             let v = Schema.from(e);
@@ -354,7 +366,7 @@ export class Schema {
 
         // Object
         schema.properties = Schema.fromMapOfSchemas(obj.properties);
-        schema.additionalProperties = AdditionalPropertiesType.from(obj.additionalProperties);
+        schema.additionalProperties = AdditionalType.from(obj.additionalProperties);
         schema.required = obj.required;
         schema.propertyNames = Schema.from(obj.propertyNames, true);
         schema.minProperties = obj.minProperties;
@@ -363,7 +375,10 @@ export class Schema {
 
         // Array
         schema.items = ArraySchemaType.from(obj.items);
+        schema.additionalItems = AdditionalType.from(obj.additionalItems);
         schema.contains = Schema.from(obj.contains);
+        schema.minContains = obj.minContains;
+        schema.maxContains = obj.maxContains;
         schema.minItems = obj.minItems;
         schema.maxItems = obj.maxItems;
         schema.uniqueItems = obj.uniqueItems;
@@ -409,7 +424,7 @@ export class Schema {
 
     // Object
     private properties?: Map<string, Schema>;
-    private additionalProperties?: AdditionalPropertiesType;
+    private additionalProperties?: AdditionalType;
     private required?: string[];
     private propertyNames?: Schema;
     private minProperties?: number;
@@ -418,7 +433,10 @@ export class Schema {
 
     // Array
     private items?: ArraySchemaType;
+    private additionalItems?: AdditionalType;
     private contains?: Schema;
+    private minContains?: number;
+    private maxContains?: number;
     private minItems?: number;
     private maxItems?: number;
     private uniqueItems?: boolean;
@@ -474,7 +492,7 @@ export class Schema {
             : undefined;
 
         this.additionalProperties = schema.additionalProperties
-            ? new AdditionalPropertiesType(schema.additionalProperties)
+            ? new AdditionalType(schema.additionalProperties)
             : undefined;
 
         this.required = schema.required ? [...schema.required] : undefined;
@@ -494,10 +512,14 @@ export class Schema {
 
         this.items = schema.items ? new ArraySchemaType(schema.items) : undefined;
         this.contains = schema.contains ? new Schema(this.contains) : undefined;
-
+        this.minContains = schema.minContains;
+        this.maxContains = schema.maxContains;
         this.minItems = schema.minItems;
         this.maxItems = schema.maxItems;
         this.uniqueItems = schema.uniqueItems;
+        this.additionalItems = schema.additionalItems
+            ? new AdditionalType(schema.additionalItems)
+            : undefined;
 
         this.$defs = schema.$defs
             ? new Map(Array.from(schema.$defs.entries()).map((e) => [e[0], new Schema(e[1])]))
@@ -507,15 +529,15 @@ export class Schema {
     }
 
     public getTitle(): string | undefined {
-        return this.getFullName();
-    }
-
-    private getFullName(): string | undefined {
         if (!this.namespace || this.namespace == TEMPORARY) return this.name;
 
         return this.namespace + '.' + this.name;
     }
 
+    public getFullName(): string {
+        return this.namespace + '.' + this.name;
+    }
+
     public get$defs(): Map<string, Schema> | undefined {
         return this.$defs;
     }
@@ -700,13 +722,22 @@ export class Schema {
         this.properties = properties;
         return this;
     }
-    public getAdditionalProperties(): AdditionalPropertiesType | undefined {
+    public getAdditionalProperties(): AdditionalType | undefined {
         return this.additionalProperties;
     }
-    public setAdditionalProperties(additionalProperties: AdditionalPropertiesType): Schema {
+    public setAdditionalProperties(additionalProperties: AdditionalType): Schema {
         this.additionalProperties = additionalProperties;
         return this;
     }
+
+    public getAdditionalItems(): AdditionalType | undefined {
+        return this.additionalItems;
+    }
+    public setAdditionalItems(additionalItems: AdditionalType): Schema {
+        this.additionalItems = additionalItems;
+        return this;
+    }
+
     public getRequired(): string[] | undefined {
         return this.required;
     }
@@ -757,6 +788,25 @@ export class Schema {
         this.contains = contains;
         return this;
     }
+
+    public getMinContains(): number | undefined {
+        return this.minContains;
+    }
+
+    public setMinContains(minContains: number): Schema {
+        this.minContains = minContains;
+        return this;
+    }
+
+    public getMaxContains(): number | undefined {
+        return this.maxContains;
+    }
+
+    public setMaxContains(maxContains: number): Schema {
+        this.maxContains = maxContains;
+        return this;
+    }
+
     public getMinItems(): number | undefined {
         return this.minItems;
     }

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

@@ -1,4 +1,5 @@
 import { Repository } from '../../Repository';
+import { isNullValue } from '../../util/NullCheck';
 import { StringUtil } from '../../util/string/StringUtil';
 import { Tuple2 } from '../../util/Tuples';
 import { Schema } from './Schema';
@@ -12,12 +13,15 @@ export class SchemaUtil {
 
     private static readonly CYCLIC_REFERENCE_LIMIT_COUNTER: number = 20;
 
-    public static getDefaultValue(s: Schema | undefined, sRepository: Repository<Schema>): any {
+    public static getDefaultValue(
+        s: Schema | undefined,
+        sRepository: Repository<Schema> | undefined,
+    ): any {
         if (!s) return undefined;
 
         if (s.getConstant()) return s.getConstant();
 
-        if (s.getDefaultValue()) return s.getDefaultValue();
+        if (!isNullValue(s.getDefaultValue())) return s.getDefaultValue();
 
         return SchemaUtil.getDefaultValue(
             SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
@@ -32,7 +36,6 @@ export class SchemaUtil {
         iteration: number = 0,
     ): Schema | undefined {
         iteration++;
-
         if (iteration == SchemaUtil.CYCLIC_REFERENCE_LIMIT_COUNTER)
             throw new SchemaValidationException(ref ?? '', 'Schema has a cyclic reference');
 

package/src/engine/json/schema/array/ArraySchemaType.ts

@@ -41,10 +41,21 @@ export class ArraySchemaType {
 
     public static from(obj: any): ArraySchemaType | undefined {
         if (!obj) return undefined;
-        if (Array.isArray(obj)) ArraySchemaType.of(...Schema.fromListOfSchemas(obj));
+        if (Array.isArray(obj))
+            return new ArraySchemaType().setTupleSchema(Schema.fromListOfSchemas(obj)!);
+
+        let keys: any[] = Object.keys(obj);
+
+        if (keys.indexOf('singleSchema') != -1) {
+            return new ArraySchemaType().setSingleSchema(Schema.from(obj['singleSchema'])!);
+        } else if (keys.indexOf('tupleSchema') != -1) {
+            return new ArraySchemaType().setTupleSchema(
+                Schema.fromListOfSchemas(obj['tupleSchema'])!,
+            );
+        }
 
         let x = Schema.from(obj);
         if (!x) return undefined;
-        return ArraySchemaType.of(x);
+        return new ArraySchemaType().setSingleSchema(x);
     }
 }

package/src/engine/json/schema/validator/ArrayValidator.ts

@@ -32,38 +32,71 @@ export class ArrayValidator {
 
         ArrayValidator.checkUniqueItems(parents, schema, array);
 
-        ArrayValidator.checkContains(parents, schema, repository, array);
+        ArrayValidator.checkContains(schema, parents, repository, array);
 
         return element;
     }
 
-    public static checkContains(
-        parents: Schema[],
+    private static checkContains(
         schema: Schema,
+        parents: Schema[],
         repository: Repository<Schema> | undefined,
         array: any[],
     ) {
-        if (!schema.getContains()) return;
+        if (isNullValue(schema.getContains())) return;
 
-        let flag: boolean = false;
-        for (let i = 0; i < array.length; i++) {
-            let newParents: Schema[] = !parents ? [] : [...parents];
+        let count = ArrayValidator.countContains(
+            parents,
+            schema,
+            repository,
+            array,
+            isNullValue(schema.getMinContains()) && isNullValue(schema.getMaxContains()),
+        );
 
-            try {
-                SchemaValidator.validate(newParents, schema.getContains(), repository, array[i]);
-                flag = true;
-                break;
-            } catch (err) {
-                flag = false;
-            }
+        if (count === 0) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'None of the items are of type contains schema',
+            );
         }
 
-        if (!flag) {
+        if (!isNullValue(schema.getMinContains()) && schema.getMinContains()! > count)
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
-                'None of the items are of type contains schema',
+                'The minimum number of the items of type contains schema should be ' +
+                    schema.getMinContains() +
+                    ' but found ' +
+                    count,
+            );
+
+        if (!isNullValue(schema.getMaxContains()) && schema.getMaxContains()! < count)
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'The maximum number of the items of type contains schema should be ' +
+                    schema.getMaxContains() +
+                    ' but found ' +
+                    count,
             );
+    }
+
+    public static countContains(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        array: any[],
+        stopOnFirst?: boolean,
+    ): number {
+        let count = 0;
+        for (let i = 0; i < array.length; i++) {
+            let newParents: Schema[] = !parents ? [] : [...parents];
+
+            try {
+                SchemaValidator.validate(newParents, schema.getContains(), repository, array[i]);
+                count++;
+                if (stopOnFirst) break;
+            } catch (err) {}
         }
+        return count;
     }
 
     public static checkUniqueItems(parents: Schema[], schema: Schema, array: any[]): void {
@@ -118,7 +151,10 @@ export class ArrayValidator {
         }
 
         if (type.getTupleSchema()) {
-            if (type.getTupleSchema()!.length !== array.length) {
+            if (
+                type.getTupleSchema()!.length !== array.length &&
+                isNullValue(schema?.getAdditionalItems())
+            ) {
                 throw new SchemaValidationException(
                     SchemaValidator.path(parents),
                     'Expected an array with only ' +
@@ -128,18 +164,93 @@ export class ArrayValidator {
                 );
             }
 
-            for (let i = 0; i < array.length; i++) {
-                let newParents: Schema[] = !parents ? [] : [...parents];
-                let element: any = SchemaValidator.validate(
-                    newParents,
-                    type.getTupleSchema()![i],
+            this.checkItemsInTupleSchema(parents, repository, array, type);
+
+            this.checkAdditionalItems(parents, schema, repository, array, type);
+        }
+    }
+
+    private static checkItemsInTupleSchema(
+        parents: Schema[],
+        repository: Repository<Schema> | undefined,
+        array: any[],
+        type: ArraySchemaType,
+    ) {
+        for (let i = 0; i < type.getTupleSchema()?.length!; i++) {
+            let newParents: Schema[] = !parents ? [] : [...parents];
+            let element: any = SchemaValidator.validate(
+                newParents,
+                type.getTupleSchema()![i],
+                repository,
+                array[i],
+            );
+            array[i] = element;
+        }
+    }
+
+    private static checkAdditionalItems(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        array: any[],
+        type: ArraySchemaType,
+    ) {
+        if (!isNullValue(schema.getAdditionalItems())) {
+            let additionalSchemaType = schema.getAdditionalItems();
+            if (additionalSchemaType?.getBooleanValue()) {
+                //validate the additional items whether schema is valid or not
+                let anySchemaType = Schema.ofAny('item'); // as additional items is true it should validate against any valid schema defined in the system
+                if (
+                    additionalSchemaType?.getBooleanValue() === false &&
+                    array.length > type.getTupleSchema()?.length!
+                )
+                    throw new SchemaValidationException(
+                        SchemaValidator.path(parents),
+                        'No Additional Items are defined',
+                    );
+
+                this.checkEachItemInAdditionalItems(
+                    parents,
+                    schema,
                     repository,
-                    array[i],
+                    array,
+                    type,
+                    anySchemaType,
+                );
+            } else if (additionalSchemaType?.getSchemaValue()) {
+                let schemaType = additionalSchemaType.getSchemaValue();
+                this.checkEachItemInAdditionalItems(
+                    parents,
+                    schema,
+                    repository,
+                    array,
+                    type,
+                    schemaType,
                 );
-                array[i] = element;
             }
         }
     }
 
+    private static checkEachItemInAdditionalItems(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        array: any[],
+        type: ArraySchemaType,
+        schemaType: Schema | undefined,
+    ) {
+        for (let i = type.getTupleSchema()?.length!; i < array.length; i++) {
+            let newParents: Schema[] = !parents ? [] : [...parents];
+            let element: any = SchemaValidator.validate(
+                newParents,
+                schemaType!,
+                repository,
+                array[i],
+            );
+            array[i] = element;
+        }
+        return;
+    }
+
     private constructor() {}
 }

package/src/engine/json/schema/validator/ObjectValidator.ts

@@ -1,6 +1,7 @@
 import { Repository } from '../../../Repository';
 import { isNullValue } from '../../../util/NullCheck';
-import { AdditionalPropertiesType, Schema } from '../Schema';
+import { AdditionalType, Schema } from '../Schema';
+import { SchemaUtil } from '../SchemaUtil';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
 
@@ -90,7 +91,7 @@ export class ObjectValidator {
         jsonObject: any,
         keys: Set<string>,
     ) {
-        let apt: AdditionalPropertiesType = schema.getAdditionalProperties()!;
+        let apt: AdditionalType = schema.getAdditionalProperties()!;
         if (apt.getSchemaValue()) {
             for (let key of Array.from(keys.values())) {
                 let newParents: Schema[] = !parents ? [] : [...parents];
@@ -107,7 +108,7 @@ export class ObjectValidator {
             if (apt.getBooleanValue() === false && keys.size) {
                 throw new SchemaValidationException(
                     SchemaValidator.path(parents),
-                    keys.toString() + ' are additional properties which are not allowed.',
+                    Array.from(keys) + ' is/are additional properties which are not allowed.',
                 );
             }
         }
@@ -154,7 +155,11 @@ export class ObjectValidator {
     ) {
         for (const each of Array.from(schema.getProperties()!)) {
             let value: any = jsonObject[each[0]];
-            if (isNullValue(value)) continue;
+
+            if (!jsonObject.hasOwnProperty(each[0]) && isNullValue(value)) {
+                const defValue = SchemaUtil.getDefaultValue(each[1], repository);
+                if (isNullValue(defValue)) continue;
+            }
 
             let newParents: Schema[] = !parents ? [] : [...parents];
             let element: any = SchemaValidator.validate(newParents, each[1], repository, value);

package/src/engine/model/Event.ts

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
@@ -21,7 +21,7 @@ export class Event {
                 [
                     'parameters',
                     Schema.ofObject('parameter').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Schema.SCHEMA),
+                        new AdditionalType().setSchemaValue(Schema.SCHEMA),
                     ),
                 ],
             ]),

package/src/engine/model/FunctionDefinition.ts

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { FunctionSignature } from './FunctionSignature';
@@ -18,13 +18,13 @@ const IN_SCHEMA = new Schema()
             [
                 'events',
                 Schema.ofObject('events').setAdditionalProperties(
-                    new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                    new AdditionalType().setSchemaValue(Event.SCHEMA),
                 ),
             ],
             [
                 'steps',
                 Schema.ofObject('steps').setAdditionalProperties(
-                    new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
+                    new AdditionalType().setSchemaValue(Statement.SCHEMA),
                 ),
             ],
         ]),

package/src/engine/model/FunctionSignature.ts

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { Parameter } from './Parameter';
@@ -15,13 +15,13 @@ export class FunctionSignature {
                 [
                     'parameters',
                     Schema.ofObject('parameters').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Parameter.SCHEMA),
+                        new AdditionalType().setSchemaValue(Parameter.SCHEMA),
                     ),
                 ],
                 [
                     'events',
                     Schema.ofObject('events').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                        new AdditionalType().setSchemaValue(Event.SCHEMA),
                     ),
                 ],
             ]),
@@ -74,4 +74,7 @@ export class FunctionSignature {
         this.events = events;
         return this;
     }
+    public getFullName(): string {
+        return this.namespace + '.' + this.name;
+    }
 }

package/src/engine/model/Statement.ts

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
@@ -22,7 +22,7 @@ export class Statement extends AbstractStatement {
                 [
                     'dependentStatements',
                     Schema.ofObject('dependentstatement').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Schema.ofBoolean('exists')),
+                        new AdditionalType().setSchemaValue(Schema.ofBoolean('exists')),
                     ),
                 ],
                 [
@@ -30,11 +30,9 @@ export class Statement extends AbstractStatement {
                     new Schema()
                         .setName('parameterMap')
                         .setAdditionalProperties(
-                            new AdditionalPropertiesType().setSchemaValue(
+                            new AdditionalType().setSchemaValue(
                                 Schema.ofObject('parameterReference').setAdditionalProperties(
-                                    new AdditionalPropertiesType().setSchemaValue(
-                                        ParameterReference.SCHEMA,
-                                    ),
+                                    new AdditionalType().setSchemaValue(ParameterReference.SCHEMA),
                                 ),
                             ),
                         ),

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -26,6 +26,10 @@ const map: Map<string, Map<string, Function>> = new Map([
     ],
 ]);
 
+const filterableNames = Array.from(map.values())
+    .flatMap((e) => Array.from(e.values()))
+    .map((e) => e.getSignature().getFullName());
+
 export class KIRunFunctionRepository extends HybridRepository<Function> {
     public constructor() {
         super(
@@ -33,6 +37,11 @@ export class KIRunFunctionRepository extends HybridRepository<Function> {
                 find(namespace: string, name: string): Function | undefined {
                     return map.get(namespace)?.get(name);
                 },
+                filter(name: string): string[] {
+                    return Array.from(filterableNames).filter(
+                        (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
+                    );
+                },
             },
             new MathFunctionRepository(),
             new StringFunctionRepository(),