@fincity/kirun-js 1.9.0 → 2.0.0

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

@@ -13,10 +13,10 @@ export class SchemaUtil {
 
     private static readonly CYCLIC_REFERENCE_LIMIT_COUNTER: number = 20;
 
-    public static getDefaultValue(
+    public static async getDefaultValue(
         s: Schema | undefined,
         sRepository: Repository<Schema> | undefined,
-    ): any {
+    ): Promise<any> {
         if (!s) return undefined;
 
         if (s.getConstant()) return s.getConstant();
@@ -24,45 +24,46 @@ export class SchemaUtil {
         if (!isNullValue(s.getDefaultValue())) return s.getDefaultValue();
 
         return SchemaUtil.getDefaultValue(
-            SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
+            await SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
             sRepository,
         );
     }
 
-    public static hasDefaultValueOrNullSchemaType(
+    public static async hasDefaultValueOrNullSchemaType(
         s: Schema | undefined,
         sRepository: Repository<Schema> | undefined,
-    ): boolean {
-        if (!s) return false;
-        if (s.getConstant()) return true;
+    ): Promise<boolean> {
+        if (!s) return Promise.resolve(false);
+        if (s.getConstant()) return Promise.resolve(true);
 
-        if (!isNullValue(s.getDefaultValue())) return true;
+        if (!isNullValue(s.getDefaultValue())) return Promise.resolve(true);
 
         if (isNullValue(s.getRef())) {
-            if (s.getType()?.getAllowedSchemaTypes().has(SchemaType.NULL)) return true;
-            return false;
+            if (s.getType()?.getAllowedSchemaTypes().has(SchemaType.NULL))
+                return Promise.resolve(true);
+            return Promise.resolve(false);
         }
 
         return this.hasDefaultValueOrNullSchemaType(
-            SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
+            await SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
             sRepository,
         );
     }
 
-    public static getSchemaFromRef(
+    public static async getSchemaFromRef(
         schema: Schema,
         sRepository: Repository<Schema> | undefined,
         ref: string | undefined,
         iteration: number = 0,
-    ): Schema | undefined {
+    ): Promise<Schema | undefined> {
         iteration++;
         if (iteration == SchemaUtil.CYCLIC_REFERENCE_LIMIT_COUNTER)
             throw new SchemaValidationException(ref ?? '', 'Schema has a cyclic reference');
 
-        if (!schema || !ref || StringUtil.isNullOrBlank(ref)) return undefined;
+        if (!schema || !ref || StringUtil.isNullOrBlank(ref)) return Promise.resolve(undefined);
 
         if (!ref.startsWith('#')) {
-            var tuple = SchemaUtil.resolveExternalSchema(schema, sRepository, ref);
+            var tuple = await SchemaUtil.resolveExternalSchema(schema, sRepository, ref);
             if (tuple) {
                 schema = tuple.getT1();
                 ref = tuple.getT2();
@@ -72,19 +73,21 @@ export class SchemaUtil {
         let parts: string[] = ref.split('/');
         let i: number = 1;
 
-        if (i === parts.length) return schema;
+        if (i === parts.length) return Promise.resolve(schema);
 
-        return SchemaUtil.resolveInternalSchema(schema, sRepository, ref, iteration, parts, i);
+        return Promise.resolve(
+            SchemaUtil.resolveInternalSchema(schema, sRepository, ref, iteration, parts, i),
+        );
     }
 
-    private static resolveInternalSchema(
+    private static async resolveInternalSchema(
         inSchema: Schema,
         sRepository: Repository<Schema> | undefined,
         ref: string,
         iteration: number,
         parts: string[],
         i: number,
-    ): Schema | undefined {
+    ): Promise<Schema | undefined> {
         let schema: Schema | undefined = inSchema;
         if (i === parts.length) return undefined;
         while (i < parts.length) {
@@ -120,7 +123,7 @@ export class SchemaUtil {
                 );
 
             if (!StringUtil.isNullOrBlank(schema.getRef())) {
-                schema = SchemaUtil.getSchemaFromRef(
+                schema = await SchemaUtil.getSchemaFromRef(
                     schema,
                     sRepository,
                     schema.getRef(),
@@ -133,25 +136,25 @@ export class SchemaUtil {
                     );
             }
         }
-        return schema;
+        return Promise.resolve(schema);
     }
 
-    private static resolveExternalSchema(
+    private static async resolveExternalSchema(
         inSchem: Schema,
         sRepository: Repository<Schema> | undefined,
         ref: string,
-    ): Tuple2<Schema, string> | undefined {
-        if (!sRepository) return undefined;
+    ): Promise<Tuple2<Schema, string> | undefined> {
+        if (!sRepository) return Promise.resolve(undefined);
 
         let nms = StringUtil.splitAtFirstOccurance(ref ?? '', '/');
-        if (!nms[0]) return undefined;
+        if (!nms[0]) return Promise.resolve(undefined);
 
         let nmspnm = StringUtil.splitAtFirstOccurance(nms[0], '.');
-        if (!nmspnm[0] || !nmspnm[1]) return undefined;
+        if (!nmspnm[0] || !nmspnm[1]) return Promise.resolve(undefined);
 
-        let schema = sRepository.find(nmspnm[0], nmspnm[1]);
-        if (!schema) return undefined;
-        if (!nms[1] || nms[1] === '') return new Tuple2(schema, ref);
+        let schema = await sRepository.find(nmspnm[0], nmspnm[1]);
+        if (!schema) return Promise.resolve(undefined);
+        if (!nms[1] || nms[1] === '') return Promise.resolve(new Tuple2(schema, ref));
 
         ref = '#/' + nms[1];
 
@@ -161,7 +164,7 @@ export class SchemaUtil {
                 SchemaUtil.UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH,
             );
 
-        return new Tuple2(schema, ref);
+        return Promise.resolve(new Tuple2(schema, ref));
     }
 
     private constructor() {}

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

@@ -6,12 +6,12 @@ import { SchemaValidationException } from './exception/SchemaValidationException
 import { SchemaValidator } from './SchemaValidator';
 
 export class ArrayValidator {
-    public static validate(
+    public static async validate(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
-    ): any {
+    ): Promise<any> {
         if (isNullValue(element))
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
@@ -28,16 +28,16 @@ export class ArrayValidator {
 
         ArrayValidator.checkMinMaxItems(parents, schema, array);
 
-        ArrayValidator.checkItems(parents, schema, repository, array);
+        await ArrayValidator.checkItems(parents, schema, repository, array);
 
         ArrayValidator.checkUniqueItems(parents, schema, array);
 
-        ArrayValidator.checkContains(schema, parents, repository, array);
+        await ArrayValidator.checkContains(schema, parents, repository, array);
 
         return element;
     }
 
-    private static checkContains(
+    private static async checkContains(
         schema: Schema,
         parents: Schema[],
         repository: Repository<Schema> | undefined,
@@ -45,7 +45,7 @@ export class ArrayValidator {
     ) {
         if (isNullValue(schema.getContains())) return;
 
-        let count = ArrayValidator.countContains(
+        let count = await ArrayValidator.countContains(
             parents,
             schema,
             repository,
@@ -79,19 +79,24 @@ export class ArrayValidator {
             );
     }
 
-    public static countContains(
+    public static async countContains(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
         array: any[],
         stopOnFirst?: boolean,
-    ): number {
+    ): Promise<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]);
+                await SchemaValidator.validate(
+                    newParents,
+                    schema.getContains(),
+                    repository,
+                    array[i],
+                );
                 count++;
                 if (stopOnFirst) break;
             } catch (err) {}
@@ -127,7 +132,7 @@ export class ArrayValidator {
         }
     }
 
-    public static checkItems(
+    public static async checkItems(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -140,7 +145,7 @@ export class ArrayValidator {
         if (type.getSingleSchema()) {
             for (let i = 0; i < array.length; i++) {
                 let newParents: Schema[] = !parents ? [] : [...parents];
-                let element: any = SchemaValidator.validate(
+                let element: any = await SchemaValidator.validate(
                     newParents,
                     type.getSingleSchema(),
                     repository,
@@ -164,13 +169,13 @@ export class ArrayValidator {
                 );
             }
 
-            this.checkItemsInTupleSchema(parents, repository, array, type);
+            await this.checkItemsInTupleSchema(parents, repository, array, type);
 
-            this.checkAdditionalItems(parents, schema, repository, array, type);
+            await this.checkAdditionalItems(parents, schema, repository, array, type);
         }
     }
 
-    private static checkItemsInTupleSchema(
+    private static async checkItemsInTupleSchema(
         parents: Schema[],
         repository: Repository<Schema> | undefined,
         array: any[],
@@ -178,7 +183,7 @@ export class ArrayValidator {
     ) {
         for (let i = 0; i < type.getTupleSchema()?.length!; i++) {
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = SchemaValidator.validate(
+            let element: any = await SchemaValidator.validate(
                 newParents,
                 type.getTupleSchema()![i],
                 repository,
@@ -188,7 +193,7 @@ export class ArrayValidator {
         }
     }
 
-    private static checkAdditionalItems(
+    private static async checkAdditionalItems(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -209,7 +214,7 @@ export class ArrayValidator {
                         'No Additional Items are defined',
                     );
 
-                this.checkEachItemInAdditionalItems(
+                await this.checkEachItemInAdditionalItems(
                     parents,
                     schema,
                     repository,
@@ -219,7 +224,7 @@ export class ArrayValidator {
                 );
             } else if (additionalSchemaType?.getSchemaValue()) {
                 let schemaType = additionalSchemaType.getSchemaValue();
-                this.checkEachItemInAdditionalItems(
+                await this.checkEachItemInAdditionalItems(
                     parents,
                     schema,
                     repository,
@@ -231,7 +236,7 @@ export class ArrayValidator {
         }
     }
 
-    private static checkEachItemInAdditionalItems(
+    private static async checkEachItemInAdditionalItems(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -241,7 +246,7 @@ export class ArrayValidator {
     ) {
         for (let i = type.getTupleSchema()?.length!; i < array.length; i++) {
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = SchemaValidator.validate(
+            let element: any = await SchemaValidator.validate(
                 newParents,
                 schemaType!,
                 repository,

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

@@ -1,16 +1,15 @@
+import { isNullValue } from '../../../util/NullCheck';
 import { Schema } from '../Schema';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
 
 export class NullValidator {
     public static validate(parents: Schema[], schema: Schema, element: any): any {
-        if (element)
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                'Expected a null but found ' + element,
-            );
-
-        return element;
+        if (isNullValue(element)) return element;
+        throw new SchemaValidationException(
+            SchemaValidator.path(parents),
+            'Expected a null but found ' + element,
+        );
     }
 
     private constructor() {}

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

@@ -6,7 +6,7 @@ import { SchemaValidationException } from './exception/SchemaValidationException
 import { SchemaValidator } from './SchemaValidator';
 
 export class ObjectValidator {
-    public static validate(
+    public static async validate(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -30,7 +30,7 @@ export class ObjectValidator {
         ObjectValidator.checkMinMaxProperties(parents, schema, keys);
 
         if (schema.getPropertyNames()) {
-            ObjectValidator.checkPropertyNameSchema(parents, schema, repository, keys);
+            await ObjectValidator.checkPropertyNameSchema(parents, schema, repository, keys);
         }
 
         if (schema.getRequired()) {
@@ -38,19 +38,31 @@ export class ObjectValidator {
         }
 
         if (schema.getProperties()) {
-            ObjectValidator.checkProperties(parents, schema, repository, jsonObject, keys);
+            await ObjectValidator.checkProperties(parents, schema, repository, jsonObject, keys);
         }
 
         if (schema.getPatternProperties()) {
-            ObjectValidator.checkPatternProperties(parents, schema, repository, jsonObject, keys);
+            await ObjectValidator.checkPatternProperties(
+                parents,
+                schema,
+                repository,
+                jsonObject,
+                keys,
+            );
         }
 
         if (schema.getAdditionalProperties()) {
-            ObjectValidator.checkAddtionalProperties(parents, schema, repository, jsonObject, keys);
+            await ObjectValidator.checkAddtionalProperties(
+                parents,
+                schema,
+                repository,
+                jsonObject,
+                keys,
+            );
         }
     }
 
-    private static checkPropertyNameSchema(
+    private static async checkPropertyNameSchema(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -58,7 +70,7 @@ export class ObjectValidator {
     ) {
         for (let key of Array.from(keys.values())) {
             try {
-                SchemaValidator.validate(
+                await SchemaValidator.validate(
                     parents,
                     schema.getPropertyNames() as Schema,
                     repository,
@@ -84,7 +96,7 @@ export class ObjectValidator {
         }
     }
 
-    private static checkAddtionalProperties(
+    private static async checkAddtionalProperties(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -96,7 +108,7 @@ export class ObjectValidator {
             for (let key of Array.from(keys.values())) {
                 let newParents: Schema[] = !parents ? [] : [...parents];
 
-                let element: any = SchemaValidator.validate(
+                let element: any = await SchemaValidator.validate(
                     newParents,
                     apt.getSchemaValue(),
                     repository,
@@ -114,7 +126,7 @@ export class ObjectValidator {
         }
     }
 
-    private static checkPatternProperties(
+    private static async checkPatternProperties(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -132,7 +144,7 @@ export class ObjectValidator {
 
             for (const e of Array.from(compiledPatterns.entries())) {
                 if (e[1].test(key)) {
-                    const element: any = SchemaValidator.validate(
+                    const element: any = await SchemaValidator.validate(
                         newParents,
                         schema.getPatternProperties()!.get(e[0]),
                         repository,
@@ -146,7 +158,7 @@ export class ObjectValidator {
         }
     }
 
-    private static checkProperties(
+    private static async checkProperties(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -157,12 +169,18 @@ export class ObjectValidator {
             let value: any = jsonObject[each[0]];
 
             if (!jsonObject.hasOwnProperty(each[0]) && isNullValue(value)) {
-                const defValue = SchemaUtil.getDefaultValue(each[1], repository);
+                const defValue = await SchemaUtil.getDefaultValue(each[1], repository);
                 if (isNullValue(defValue)) continue;
             }
 
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = SchemaValidator.validate(newParents, each[1], repository, value);
+            let element: any = await SchemaValidator.validate(
+                newParents,
+                each[1],
+                repository,
+                value,
+            );
+
             jsonObject[each[0]] = element;
             keys.delete(each[0]);
         }

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

@@ -4,7 +4,6 @@ import { isNullValue } from '../../../util/NullCheck';
 import { StringUtil } from '../../../util/string/StringUtil';
 import { Schema } from '../Schema';
 import { SchemaUtil } from '../SchemaUtil';
-import { SchemaType } from '../type/SchemaType';
 import { AnyOfAllOfOneOfValidator } from './AnyOfAllOfOneOfValidator';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { TypeValidator } from './TypeValidator';
@@ -19,12 +18,12 @@ export class SchemaValidator {
             .reduce((a, c, i) => a + (i === 0 ? '' : '.') + c, '');
     }
 
-    public static validate(
+    public static async validate(
         parents: Schema[] | undefined,
         schema: Schema | undefined,
         repository: Repository<Schema> | undefined,
         element: any,
-    ): any {
+    ): Promise<any> {
         if (!schema) {
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
@@ -58,13 +57,13 @@ export class SchemaValidator {
             );
 
         if (schema.getType()) {
-            SchemaValidator.typeValidation(parents, schema, repository, element);
+            await SchemaValidator.typeValidation(parents, schema, repository, element);
         }
 
         if (!StringUtil.isNullOrBlank(schema.getRef())) {
-            return SchemaValidator.validate(
+            return await SchemaValidator.validate(
                 parents,
-                SchemaUtil.getSchemaFromRef(parents[0], repository, schema.getRef()),
+                await SchemaUtil.getSchemaFromRef(parents[0], repository, schema.getRef()),
                 repository,
                 element,
             );
@@ -77,7 +76,12 @@ export class SchemaValidator {
         if (schema.getNot()) {
             let flag: boolean = false;
             try {
-                SchemaValidator.validate(parents, schema.getNot(), repository, element);
+                let x = await SchemaValidator.validate(
+                    parents,
+                    schema.getNot(),
+                    repository,
+                    element,
+                );
                 flag = true;
             } catch (err) {
                 flag = false;
@@ -120,7 +124,7 @@ export class SchemaValidator {
         }
     }
 
-    public static typeValidation(
+    public static async typeValidation(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -128,10 +132,10 @@ export class SchemaValidator {
     ) {
         let valid: boolean = false;
         let list: SchemaValidationException[] = [];
-
-        for (const type of Array.from(schema.getType()?.getAllowedSchemaTypes()?.values() ?? [])) {
+        let type;
+        for (type of Array.from(schema.getType()?.getAllowedSchemaTypes()?.values() ?? [])) {
             try {
-                TypeValidator.validate(parents, type, schema, repository, element);
+                await TypeValidator.validate(parents, type, schema, repository, element);
                 valid = true;
                 break;
             } catch (err: any) {

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

@@ -11,13 +11,13 @@ import { SchemaValidator } from './SchemaValidator';
 import { StringValidator } from './StringValidator';
 
 export class TypeValidator {
-    public static validate(
+    public static async validate(
         parents: Schema[],
         type: SchemaType,
         schema: Schema,
-        repository: Repository<Schema> |undefined,
+        repository: Repository<Schema> | undefined,
         element: any,
-    ): any {
+    ): Promise<any> {
         if (type == SchemaType.STRING) {
             StringValidator.validate(parents, schema, element);
         } else if (
@@ -30,9 +30,9 @@ export class TypeValidator {
         } else if (type == SchemaType.BOOLEAN) {
             BooleanValidator.validate(parents, schema, element);
         } else if (type == SchemaType.OBJECT) {
-            ObjectValidator.validate(parents, schema, repository, element);
+            await ObjectValidator.validate(parents, schema, repository, element);
         } else if (type == SchemaType.ARRAY) {
-            ArrayValidator.validate(parents, schema, repository, element);
+            await ArrayValidator.validate(parents, schema, repository, element);
         } else if (type == SchemaType.NULL) {
             NullValidator.validate(parents, schema, element);
         } else {

package/src/engine/model/Statement.ts

@@ -21,9 +21,19 @@ export class Statement extends AbstractStatement {
                 ['name', Schema.ofString('name')],
                 [
                     'dependentStatements',
-                    Schema.ofObject('dependentstatement').setAdditionalProperties(
-                        new AdditionalType().setSchemaValue(Schema.ofBoolean('exists')),
-                    ),
+                    Schema.ofObject('dependentstatement')
+                        .setAdditionalProperties(
+                            new AdditionalType().setSchemaValue(Schema.ofBoolean('exists')),
+                        )
+                        .setDefaultValue({}),
+                ],
+                [
+                    'executeIftrue',
+                    Schema.ofObject('executeIftrue')
+                        .setAdditionalProperties(
+                            new AdditionalType().setSchemaValue(Schema.ofBoolean('exists')),
+                        )
+                        .setDefaultValue({}),
                 ],
                 [
                     'parameterMap',

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -45,10 +45,11 @@ export class KIRunFunctionRepository extends HybridRepository<Function> {
     public constructor() {
         super(
             {
-                find(namespace: string, name: string): Function | undefined {
+                async find(namespace: string, name: string): Promise<Function | undefined> {
                     return map.get(namespace)?.get(name);
                 },
-                filter(name: string): string[] {
+
+                async filter(name: string): Promise<string[]> {
                     return Array.from(filterableNames).filter(
                         (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
                     );

package/src/engine/repository/KIRunSchemaRepository.ts

@@ -20,13 +20,15 @@ const map: Map<string, Schema> = new Map([
 const filterableNames = Array.from(map.values()).map((e) => e.getFullName());
 
 export class KIRunSchemaRepository implements Repository<Schema> {
-    public find(namespace: string, name: string): Schema | undefined {
-        if (Namespaces.SYSTEM != namespace) return undefined;
+    public async find(namespace: string, name: string): Promise<Schema | undefined> {
+        if (Namespaces.SYSTEM != namespace) return Promise.resolve(undefined);
 
-        return map.get(name);
+        return Promise.resolve(map.get(name));
     }
 
-    public filter(name: string): string[] {
-        return filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1);
+    public async filter(name: string): Promise<string[]> {
+        return Promise.resolve(
+            filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1),
+        );
     }
 }