@fincity/kirun-js 2.4.0 → 2.7.0

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

@@ -7,8 +7,22 @@ import { SchemaUtil } from '../SchemaUtil';
 import { AnyOfAllOfOneOfValidator } from './AnyOfAllOfOneOfValidator';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { TypeValidator } from './TypeValidator';
+import { ConversionMode } from '../convertor/enums/ConversionMode';
+import { SchemaType } from '../type/SchemaType';
 
 export class SchemaValidator {
+    private static readonly ORDER: Record<SchemaType, number> = {
+        [SchemaType.OBJECT]: 0,
+        [SchemaType.ARRAY]: 1,
+        [SchemaType.DOUBLE]: 2,
+        [SchemaType.FLOAT]: 3,
+        [SchemaType.LONG]: 4,
+        [SchemaType.INTEGER]: 5,
+        [SchemaType.STRING]: 6,
+        [SchemaType.BOOLEAN]: 7,
+        [SchemaType.NULL]: 8,
+    };
+
     public static path(parents: Schema[] | undefined): string {
         if (!parents) return '';
 
@@ -23,6 +37,8 @@ export class SchemaValidator {
         schema: Schema | undefined,
         repository: Repository<Schema> | undefined,
         element: any,
+        convert?: boolean,
+        mode?: ConversionMode,
     ): Promise<any> {
         if (!schema) {
             throw new SchemaValidationException(
@@ -32,7 +48,7 @@ export class SchemaValidator {
         }
 
         if (!parents) {
-            parents = new Array();
+            parents = [];
         }
         parents.push(schema);
 
@@ -56,8 +72,22 @@ export class SchemaValidator {
                     ' format.',
             );
 
+        if (convert === true && isNullValue(schema.getType())) {
+            throw new SchemaValidationException(
+                this.path(parents),
+                'Type is missing in schema for declared ' + mode,
+            );
+        }
+
         if (schema.getType()) {
-            await SchemaValidator.typeValidation(parents, schema, repository, element);
+            element = await SchemaValidator.typeValidation(
+                parents,
+                schema,
+                repository,
+                element,
+                convert,
+                mode,
+            );
         }
 
         if (!StringUtil.isNullOrBlank(schema.getRef())) {
@@ -66,21 +96,32 @@ export class SchemaValidator {
                 await SchemaUtil.getSchemaFromRef(parents[0], repository, schema.getRef()),
                 repository,
                 element,
+                convert,
+                mode,
             );
         }
 
         if (schema.getOneOf() || schema.getAllOf() || schema.getAnyOf()) {
-            AnyOfAllOfOneOfValidator.validate(parents, schema, repository, element);
+            element = await AnyOfAllOfOneOfValidator.validate(
+                parents,
+                schema,
+                repository,
+                element,
+                convert,
+                mode,
+            );
         }
 
         if (schema.getNot()) {
-            let flag: boolean = false;
+            let flag: boolean;
             try {
-                let x = await SchemaValidator.validate(
+                await SchemaValidator.validate(
                     parents,
                     schema.getNot(),
                     repository,
                     element,
+                    convert,
+                    mode,
                 );
                 flag = true;
             } catch (err) {
@@ -129,28 +170,39 @@ export class SchemaValidator {
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
-    ) {
-        let valid: boolean = false;
-        let list: SchemaValidationException[] = [];
-        let type;
-        for (type of Array.from(schema.getType()?.getAllowedSchemaTypes()?.values() ?? [])) {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
+        const allowedTypes: SchemaType[] = Array.from(
+            schema.getType()?.getAllowedSchemaTypes()?.values() ?? [],
+        ).sort(
+            (a: SchemaType, b: SchemaType) =>
+                (this.ORDER[a] ?? Infinity) - (this.ORDER[b] ?? Infinity),
+        );
+
+        let errors: SchemaValidationException[] = [];
+
+        for (const type of allowedTypes) {
             try {
-                await TypeValidator.validate(parents, type, schema, repository, element);
-                valid = true;
-                break;
+                return await TypeValidator.validate(
+                    parents,
+                    type,
+                    schema,
+                    repository,
+                    element,
+                    convert,
+                    mode,
+                );
             } catch (err: any) {
-                valid = false;
-                list.push(err);
+                errors.push(err);
             }
         }
 
-        if (!valid) {
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                'Value ' + JSON.stringify(element) + ' is not of valid type(s)',
-                list,
-            );
-        }
+        throw new SchemaValidationException(
+            SchemaValidator.path(parents),
+            'Value ' + JSON.stringify(element) + ' is not of valid type(s)',
+            errors,
+        );
     }
 
     private constructor() {}

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

@@ -3,12 +3,19 @@ import { Schema } from '../Schema';
 import { SchemaType } from '../type/SchemaType';
 import { ArrayValidator } from './ArrayValidator';
 import { BooleanValidator } from './BooleanValidator';
-import { SchemaValidationException } from './exception/SchemaValidationException';
 import { NullValidator } from './NullValidator';
 import { NumberValidator } from './NumberValidator';
 import { ObjectValidator } from './ObjectValidator';
-import { SchemaValidator } from './SchemaValidator';
 import { StringValidator } from './StringValidator';
+import { ConversionMode } from '../convertor/enums/ConversionMode';
+import { ConvertorUtil } from '../../../util/json/ConvertorUtil';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { StringConvertor } from '../convertor/StringConvertor';
+import { NumberConvertor } from '../convertor/NumberConvertor';
+import { BooleanConvertor } from '../convertor/BooleanConvertor';
+import { NullConvertor } from '../convertor/NullConvertor';
+import { isNullValue } from '../../../util/NullCheck';
+import { ValidatorUtil } from '../../../util/json/ValidatorUtil';
 
 export class TypeValidator {
     public static async validate(
@@ -17,32 +24,138 @@ export class TypeValidator {
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
+        convert?: boolean,
+        mode?: ConversionMode,
     ): Promise<any> {
-        if (type == SchemaType.STRING) {
-            StringValidator.validate(parents, schema, element);
-        } else if (
-            type == SchemaType.LONG ||
-            type == SchemaType.INTEGER ||
-            type == SchemaType.DOUBLE ||
-            type == SchemaType.FLOAT
-        ) {
-            NumberValidator.validate(type, parents, schema, element);
-        } else if (type == SchemaType.BOOLEAN) {
-            BooleanValidator.validate(parents, schema, element);
-        } else if (type == SchemaType.OBJECT) {
-            await ObjectValidator.validate(parents, schema, repository, element);
+        if (type == SchemaType.OBJECT) {
+            return await ObjectValidator.validate(
+                parents,
+                schema,
+                repository,
+                element,
+                convert,
+                mode,
+            );
         } else if (type == SchemaType.ARRAY) {
-            await ArrayValidator.validate(parents, schema, repository, element);
-        } else if (type == SchemaType.NULL) {
-            NullValidator.validate(parents, schema, element);
-        } else {
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                type + ' is not a valid type.',
+            return await ArrayValidator.validate(
+                parents,
+                schema,
+                repository,
+                element,
+                convert,
+                mode,
             );
         }
 
-        return element;
+        return this.handleTypeValidationAndConversion(
+            parents,
+            type,
+            schema,
+            element,
+            convert,
+            mode,
+        );
+    }
+
+    private static async handleTypeValidationAndConversion(
+        parents: Schema[],
+        type: SchemaType,
+        schema: Schema,
+        element: any,
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
+        const cElement = convert
+            ? this.convertElement(parents, type, schema, element, mode ?? ConversionMode.STRICT)
+            : element;
+
+        return await this.validateElement(
+            parents,
+            type,
+            schema,
+            cElement,
+            mode ?? ConversionMode.STRICT,
+        );
+    }
+
+    private static convertElement(
+        parents: Schema[],
+        type: SchemaType,
+        schema: Schema,
+        element: any,
+        mode: ConversionMode,
+    ): any | null {
+        if (isNullValue(type)) {
+            return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                parents,
+                mode,
+                element,
+                schema.getDefaultValue() ?? null,
+                StringFormatter.format('$ is not a valid type for conversion.', type),
+            );
+        }
+
+        switch (type) {
+            case SchemaType.STRING:
+                return StringConvertor.convert(parents, schema, mode, element);
+            case SchemaType.INTEGER:
+            case SchemaType.LONG:
+            case SchemaType.DOUBLE:
+            case SchemaType.FLOAT:
+                return NumberConvertor.convert(parents, type, schema, mode, element);
+            case SchemaType.BOOLEAN:
+                return BooleanConvertor.convert(parents, schema, mode, element);
+            case SchemaType.NULL:
+                return NullConvertor.convert(parents, schema, mode, element);
+            default:
+                return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                    parents,
+                    mode,
+                    element,
+                    schema.getDefaultValue() ?? null,
+                    StringFormatter.format('$ is not a valid type for conversion.', type),
+                );
+        }
+    }
+
+    private static validateElement(
+        parents: Schema[],
+        type: SchemaType,
+        schema: Schema,
+        element: any,
+        mode: ConversionMode,
+    ): any | null {
+        if (isNullValue(type)) {
+            return ValidatorUtil.handleValidationError(
+                parents,
+                mode,
+                element,
+                schema.getDefaultValue() ?? null,
+                StringFormatter.format('$ is not a valid type.', type),
+            );
+        }
+
+        switch (type) {
+            case SchemaType.STRING:
+                return StringValidator.validate(parents, schema, element);
+            case SchemaType.INTEGER:
+            case SchemaType.LONG:
+            case SchemaType.DOUBLE:
+            case SchemaType.FLOAT:
+                return NumberValidator.validate(type, parents, schema, element);
+            case SchemaType.BOOLEAN:
+                return BooleanValidator.validate(parents, schema, element);
+            case SchemaType.NULL:
+                return NullValidator.validate(parents, schema, element);
+            default:
+                return ValidatorUtil.handleValidationError(
+                    parents,
+                    mode,
+                    element,
+                    schema.getDefaultValue() ?? null,
+                    StringFormatter.format('$ is not a valid type.', type),
+                );
+        }
     }
 
     private constructor() {}

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -52,8 +52,8 @@ export abstract class TokenValueExtractor {
             .map((e) => e.trim())
             .filter((e) => !StringUtil.isNullOrBlank(e))
             .reduce(
-                (a, c, i) =>
-                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a, i),
+                (a, c) =>
+                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a),
                 jsonElement,
             );
 
@@ -64,74 +64,78 @@ export abstract class TokenValueExtractor {
         token: string,
         parts: string[],
         partNumber: number,
-        c: string,
-        a: any,
-        i: any,
+        cPart: string,
+        cElement: any
     ): any {
-        if (isNullValue(a)) return undefined;
+        if (isNullValue(cElement)) return undefined;
 
-        if (i === 0) {
-            if (c === 'length') {
-                const type = typeof a;
-                if (type === 'string' || Array.isArray(a)) return a.length;
-                if (type === 'object') return Object.keys(a).length;
-            }
-            if (Array.isArray(a)) {
-                try {
-                    let index: number = parseInt(c);
-                    if (isNaN(index)) {
-                        throw new Error(StringFormatter.format('$ is not a number', index));
-                    }
-                    if (index >= a.length) return undefined;
-
-                    return a[index];
-                } catch (err: any) {
-                    throw new ExpressionEvaluationException(
-                        token,
-                        StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
-                        err,
-                    );
-                }
-            }
+        if (cPart === 'length') return this.getLength(token, cElement);
 
-            this.checkIfObject(token, parts, partNumber, a);
-            return a[c];
-        } else if (c?.startsWith('"')) {
-            if (!c.endsWith('"') || c.length == 1 || c.length == 2)
-                throw new ExpressionEvaluationException(
-                    token,
-                    StringFormatter.format('$ is missing a double quote or empty key found', token),
-                );
+        if (Array.isArray(cElement)) return this.handleArrayAccess(token, cPart, cElement);
+
+        return this.handleObjectAccess(token, parts, partNumber, cPart, cElement);
+    }
+
+    private getLength(
+        token: string,
+        cElement: any
+    ): any {
+        const type = typeof cElement;
 
-            this.checkIfObject(token, parts, partNumber, a);
-            return a[c.substring(1, c.length - 1)];
+        if (type === 'string' || Array.isArray(cElement)) return cElement.length;
+        if (type === 'object') {
+            if ('length' in cElement) return cElement['length'];
+            else return Object.keys(cElement).length;
         }
 
-        try {
-            let index: number = parseInt(c);
-            if (isNaN(index)) {
-                throw new Error(StringFormatter.format('$ is not a number', index));
-            }
-            if (!Array.isArray(a))
-                throw new ExpressionEvaluationException(
-                    token,
-                    StringFormatter.format(
-                        'Expecting an array with index $ while processing the expression',
-                        index,
-                        token,
-                    ),
-                );
+        throw new ExpressionEvaluationException(token,
+            StringFormatter.format('Length can\'t be found in token $', token))
+    }
+
+    private handleArrayAccess(
+        token: string,
+        cPart: string,
+        cArray: any[]
+    ): any {
+        const index: number = parseInt(cPart);
 
-            if (index >= a.length) return undefined;
+        if (isNaN(index)) {
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format('$ is not a number', cPart)
+            );
+        }
 
-            return a[index];
-        } catch (err: any) {
+        if (index < 0 || index >= cArray.length) {
             throw new ExpressionEvaluationException(
                 token,
-                StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
-                err,
+                StringFormatter.format('Index $ is out of bounds for array of length $', index, cArray.length)
             );
         }
+
+        return cArray[index];
+    }
+
+    private handleObjectAccess(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        cPart: string,
+        cObject: any
+    ): any {
+        if (cPart.startsWith("\"")) {
+            if (!cPart.endsWith("\"") || cPart.length == 1 || cPart.length == 2) {
+                throw new ExpressionEvaluationException(
+                    token,
+                    StringFormatter.format("$ is missing a double quote or empty key found", token))
+            }
+
+            cPart = cPart.substring(1, parts.length - 2);
+        }
+
+        this.checkIfObject(token, parts, partNumber, cObject);
+
+        return cObject[cPart];
     }
 
     protected checkIfObject(
@@ -144,7 +148,7 @@ export abstract class TokenValueExtractor {
             throw new ExpressionEvaluationException(
                 token,
                 StringFormatter.format(
-                    'Unable to retrive $ from $ in the path $',
+                    'Unable to retrieve $ from $ in the path $',
                     parts[partNumber],
                     jsonElement.toString(),
                     token,

package/src/engine/util/json/ConvertorUtil.ts

@@ -0,0 +1,51 @@
+import { Schema } from '../../json/schema/Schema';
+import { ConversionMode } from '../../json/schema/convertor/enums/ConversionMode';
+import { SchemaConversionException } from '../../json/schema/convertor/exception/SchemaConversionException';
+import { SchemaValidator } from '../../json/schema/validator/SchemaValidator';
+
+export class ConvertorUtil {
+    public static handleUnConvertibleValue(
+        parents: Schema[],
+        mode: ConversionMode | null,
+        element: any,
+        errorMessage: string,
+    ): any | null {
+        return this.handleUnConvertibleValueWithDefault(parents, mode, element, null, errorMessage);
+    }
+
+    public static handleUnConvertibleValueWithDefault(
+        parents: Schema[],
+        mode: ConversionMode | null,
+        element: any,
+        defaultValue: any,
+        errorMessage: string,
+    ): any | null {
+        if (mode === null) {
+            mode = ConversionMode.STRICT;
+        }
+
+        switch (mode) {
+            case ConversionMode.STRICT:
+                throw new SchemaConversionException(
+                    SchemaValidator.path(parents),
+                    element,
+                    errorMessage,
+                    mode,
+                );
+            case ConversionMode.LENIENT:
+                return null;
+            case ConversionMode.USE_DEFAULT:
+                return defaultValue;
+            case ConversionMode.SKIP:
+                return element;
+            default:
+                throw new SchemaConversionException(
+                    SchemaValidator.path(parents),
+                    element,
+                    'Invalid conversion mode',
+                );
+        }
+    }
+
+    private constructor() {}
+}

package/src/engine/util/json/ValidatorUtil.ts

@@ -0,0 +1,29 @@
+import { Schema } from '../../json/schema/Schema';
+import { ConversionMode } from '../../json/schema/convertor/enums/ConversionMode';
+import { SchemaValidationException } from '../../json/schema/validator/exception/SchemaValidationException';
+import { SchemaValidator } from '../../json/schema/validator/SchemaValidator';
+
+export class ValidatorUtil {
+    public static handleValidationError(
+        parents: Schema[],
+        mode: ConversionMode,
+        element: any,
+        defaultValue: any,
+        errorMessage: string,
+    ): any | null {
+        mode = mode ?? ConversionMode.STRICT;
+
+        switch (mode) {
+            case ConversionMode.STRICT:
+                throw new SchemaValidationException(SchemaValidator.path(parents), errorMessage);
+            case ConversionMode.LENIENT:
+                return null;
+            case ConversionMode.USE_DEFAULT:
+                return defaultValue;
+            case ConversionMode.SKIP:
+                return element;
+        }
+    }
+
+    private constructor() {}
+}

package/tsconfig.json

@@ -5,6 +5,7 @@
         "esModuleInterop": true,
         "skipLibCheck": true,
         "forceConsistentCasingInFileNames": true,
-        "lib": ["ES2022"]
+        "lib": ["ES2022"],
+        "target": "ES2022"
     }
 }