@fincity/kirun-js 2.5.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/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"
     }
 }