@fincity/kirun-js 2.5.0 → 2.8.2

package/src/engine/json/schema/convertor/NullConvertor.ts

@@ -0,0 +1,31 @@
+import { Schema } from '../Schema';
+import { ConversionMode } from './enums/ConversionMode';
+import { isNullValue } from '../../../util/NullCheck';
+import { ConvertorUtil } from '../../../util/json/ConvertorUtil';
+
+export class NullConvertor {
+    public static convert(
+        parents: Schema[],
+        schema: Schema,
+        mode: ConversionMode,
+        element: any,
+    ): null {
+        if (isNullValue(element)) {
+            return element;
+        }
+
+        if ('string' === typeof element && element.toLowerCase() === 'null') {
+            return null;
+        }
+
+        return ConvertorUtil.handleUnConvertibleValueWithDefault(
+            parents,
+            mode,
+            element,
+            null,
+            'Unable to convert to null',
+        );
+    }
+
+    private constructor() {}
+}

package/src/engine/json/schema/convertor/NumberConvertor.ts

@@ -0,0 +1,117 @@
+import { Schema } from '../Schema';
+import { SchemaType } from '../type/SchemaType';
+import { ConversionMode } from './enums/ConversionMode';
+import { isNullValue } from '../../../util/NullCheck';
+import { ConvertorUtil } from '../../../util/json/ConvertorUtil';
+
+export class NumberConvertor {
+    public static convert(
+        parents: Schema[],
+        type: SchemaType,
+        schema: Schema,
+        mode: ConversionMode,
+        element: any,
+    ): number | null {
+        if (isNullValue(element)) {
+            return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                parents,
+                mode,
+                element,
+                this.getDefault(schema),
+                'Expected a number but found null',
+            );
+        }
+
+        if (typeof element === 'object' || typeof element === 'boolean' || Array.isArray(element)) {
+            return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                parents,
+                mode,
+                element,
+                this.getDefault(schema),
+                element + ' is not a ' + type,
+            );
+        }
+
+        if (typeof element === 'string') {
+            element = Number(element);
+            if (isNaN(element)) {
+                return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                    parents,
+                    mode,
+                    element,
+                    this.getDefault(schema),
+                    element + ' is not a ' + type,
+                );
+            }
+        }
+
+        const number: number | null = this.extractNumber(type, element, mode);
+
+        if (number === null) {
+            return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                parents,
+                mode,
+                element,
+                this.getDefault(schema),
+                element + ' is not a ' + type,
+            );
+        }
+
+        return number;
+    }
+
+    private static extractNumber(
+        schemaType: SchemaType,
+        element: number,
+        mode: ConversionMode,
+    ): number | null {
+        if (typeof element !== 'number') {
+            return null;
+        }
+
+        switch (schemaType) {
+            case SchemaType.INTEGER:
+                return this.isInteger(element, mode) ? Math.floor(element) : null;
+            case SchemaType.LONG:
+                return this.isLong(element, mode) ? Math.floor(element) : null;
+            case SchemaType.DOUBLE:
+                return element;
+            case SchemaType.FLOAT:
+                return this.isFloat(element, mode) ? element : null;
+            default:
+                return null;
+        }
+    }
+
+    private static isInteger(value: number, mode: ConversionMode): boolean {
+        if (mode !== ConversionMode.STRICT) {
+            return typeof value === 'number';
+        }
+        return Number.isInteger(value);
+    }
+
+    private static isLong(value: number, mode: ConversionMode): boolean {
+        if (mode !== ConversionMode.STRICT) {
+            return typeof value === 'number';
+        }
+        return (
+            Number.isInteger(value) &&
+            value >= Number.MIN_SAFE_INTEGER &&
+            value <= Number.MAX_SAFE_INTEGER
+        );
+    }
+
+    private static isFloat(value: number, mode: ConversionMode): boolean {
+        if (mode !== ConversionMode.STRICT) {
+            return typeof value === 'number';
+        }
+        return value >= -Number.MAX_VALUE && value <= Number.MAX_VALUE;
+    }
+
+    private static getDefault(schema: Schema): number | null {
+        if (typeof schema.getDefaultValue() === 'number') {
+            return Number(schema.getDefaultValue);
+        }
+        return null;
+    }
+}

package/src/engine/json/schema/convertor/StringConvertor.ts

@@ -0,0 +1,41 @@
+import { Schema } from '../Schema';
+import { ConversionMode } from './enums/ConversionMode';
+import { isNullValue } from '../../../util/NullCheck';
+import { ConvertorUtil } from '../../../util/json/ConvertorUtil';
+
+export class StringConvertor {
+    public static convert(
+        parents: Schema[],
+        schema: Schema,
+        mode: ConversionMode,
+        element: any,
+    ): string | null {
+        if (isNullValue(element)) {
+            return ConvertorUtil.handleUnConvertibleValueWithDefault(
+                parents,
+                mode,
+                element,
+                this.getDefault(schema),
+                'Expected a string but found null',
+            );
+        }
+
+        const value =
+            element ?? (typeof element === 'object' ? JSON.stringify(element) : String(element));
+
+        return this.getConvertedString(value, mode);
+    }
+
+    private static getConvertedString(value: string, mode: ConversionMode): string {
+        if (mode === ConversionMode.STRICT) {
+            return value.toString();
+        }
+        return value.trim();
+    }
+
+    private static getDefault(schema: Schema): any {
+        return schema.getDefaultValue() ?? null;
+    }
+
+    private constructor() {}
+}

package/src/engine/json/schema/convertor/enums/ConversionMode.ts

@@ -0,0 +1,11 @@
+export enum ConversionMode {
+    STRICT = 'STRICT',
+    LENIENT = 'LENIENT',
+    USE_DEFAULT = 'USE_DEFAULT',
+    SKIP = 'SKIP',
+}
+
+export const genericValueOf = (mode: string): ConversionMode =>
+    ConversionMode[mode.toUpperCase() as keyof typeof ConversionMode];
+
+export const getConversionModes = (): string[] => Object.values(ConversionMode);

package/src/engine/json/schema/convertor/exception/SchemaConversionException.ts

@@ -0,0 +1,39 @@
+import { ConversionMode } from '../enums/ConversionMode';
+
+export class SchemaConversionException extends Error {
+    private readonly schemaPath: string;
+    private readonly source?: string | null;
+    private readonly mode?: ConversionMode | null;
+    cause?: Error;
+
+    constructor(
+        schemaPath: string,
+        source: string,
+        message: string,
+        mode?: ConversionMode,
+        sce: SchemaConversionException[] = [],
+        err?: Error,
+    ) {
+        super(message + (sce ? sce.map((e) => e.message).reduce((a, c) => a + '\n' + c, '') : ''));
+        this.schemaPath = schemaPath;
+        this.source = source ?? null;
+        this.mode = mode ?? null;
+        this.cause = err;
+    }
+
+    public getSchemaPath(): string {
+        return this.schemaPath;
+    }
+
+    public getSource(): string | null {
+        return this.source ?? null;
+    }
+
+    public getMode(): ConversionMode | null {
+        return this.mode ?? null;
+    }
+
+    public getCause(): Error | undefined {
+        return this.cause;
+    }
+}

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

@@ -2,37 +2,73 @@ import { Repository } from '../../../Repository';
 import { Schema } from '../Schema';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
+import { ConversionMode } from '../convertor/enums/ConversionMode';
 
 export class AnyOfAllOfOneOfValidator {
-    public static validate(
+    public static async validate(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
-    ): any {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
         let list: SchemaValidationException[] = [];
         if (schema.getOneOf() && !schema.getOneOf()) {
-            AnyOfAllOfOneOfValidator.oneOf(parents, schema, repository, element, list);
+            return await AnyOfAllOfOneOfValidator.oneOf(
+                parents,
+                schema,
+                repository,
+                element,
+                list,
+                convert,
+                mode,
+            );
         } else if (schema.getAllOf() && !schema.getAllOf()) {
-            AnyOfAllOfOneOfValidator.allOf(parents, schema, repository, element, list);
+            return await AnyOfAllOfOneOfValidator.allOf(
+                parents,
+                schema,
+                repository,
+                element,
+                list,
+                convert,
+                mode,
+            );
         } else if (schema.getAnyOf() && !schema.getAnyOf()) {
-            AnyOfAllOfOneOfValidator.anyOf(parents, schema, repository, element, list);
+            return await AnyOfAllOfOneOfValidator.anyOf(
+                parents,
+                schema,
+                repository,
+                element,
+                list,
+                convert,
+                mode,
+            );
         }
 
         return element;
     }
 
-    private static anyOf(
+    private static async anyOf(
         parents: Schema[],
         schema: Schema,
-        repository: Repository<Schema> |undefined,
+        repository: Repository<Schema> | undefined,
         element: any,
         list: SchemaValidationException[],
-    ) {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
         let flag: boolean = false;
         for (let s of schema.getAnyOf() ?? []) {
             try {
-                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                await AnyOfAllOfOneOfValidator.validate(
+                    parents,
+                    s,
+                    repository,
+                    element,
+                    convert,
+                    mode,
+                );
                 flag = true;
                 break;
             } catch (err: any) {
@@ -41,67 +77,91 @@ export class AnyOfAllOfOneOfValidator {
             }
         }
 
-        if (!flag) {
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                "The value don't satisfy any of the schemas.",
-                list,
-            );
+        if (flag) {
+            return element;
         }
+
+        throw new SchemaValidationException(
+            SchemaValidator.path(parents),
+            "The value don't satisfy any of the schemas.",
+            list,
+        );
     }
 
-    private static allOf(
+    private static async allOf(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
         list: SchemaValidationException[],
-    ) {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
         let flag: number = 0;
         for (let s of schema.getAllOf() ?? []) {
             try {
-                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                await AnyOfAllOfOneOfValidator.validate(
+                    parents,
+                    s,
+                    repository,
+                    element,
+                    convert,
+                    mode,
+                );
                 flag++;
             } catch (err: any) {
                 list.push(err);
             }
         }
 
-        if (flag !== schema.getAllOf()?.length) {
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                "The value doesn't satisfy some of the schemas.",
-                list,
-            );
+        if (flag === schema.getAllOf()?.length) {
+            return element;
         }
+
+        throw new SchemaValidationException(
+            SchemaValidator.path(parents),
+            "The value doesn't satisfy some of the schemas.",
+            list,
+        );
     }
 
-    private static oneOf(
+    private static async oneOf(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
         list: SchemaValidationException[],
-    ) {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
         let flag: number = 0;
         for (let s of schema.getOneOf() ?? []) {
             try {
-                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                await AnyOfAllOfOneOfValidator.validate(
+                    parents,
+                    s,
+                    repository,
+                    element,
+                    convert,
+                    mode,
+                );
                 flag++;
-            } catch (err : any) {
+            } catch (err: any) {
                 list.push(err);
             }
         }
 
-        if (flag != 1) {
-            throw new SchemaValidationException(
-                SchemaValidator.path(parents),
-                flag == 0
-                    ? 'The value does not satisfy any schema'
-                    : 'The value satisfy more than one schema',
-                list,
-            );
+        if (flag === 1) {
+            return element;
         }
+
+        throw new SchemaValidationException(
+            SchemaValidator.path(parents),
+            flag == 0
+                ? 'The value does not satisfy any schema'
+                : 'The value satisfy more than one schema',
+            list,
+        );
     }
 
     private constructor() {}

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

@@ -4,6 +4,7 @@ import { ArraySchemaType } from '../array/ArraySchemaType';
 import { Schema } from '../Schema';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
+import { ConversionMode } from '../convertor/enums/ConversionMode';
 
 export class ArrayValidator {
     public static async validate(
@@ -11,6 +12,8 @@ export class ArrayValidator {
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
+        convert?: boolean,
+        mode?: ConversionMode,
     ): Promise<any> {
         if (isNullValue(element))
             throw new SchemaValidationException(
@@ -28,7 +31,7 @@ export class ArrayValidator {
 
         ArrayValidator.checkMinMaxItems(parents, schema, array);
 
-        await ArrayValidator.checkItems(parents, schema, repository, array);
+        await ArrayValidator.checkItems(parents, schema, repository, array, convert, mode);
 
         ArrayValidator.checkUniqueItems(parents, schema, array);
 
@@ -137,6 +140,8 @@ export class ArrayValidator {
         schema: Schema,
         repository: Repository<Schema> | undefined,
         array: any[],
+        convert?: boolean,
+        mode?: ConversionMode,
     ) {
         if (!schema.getItems()) return;
 
@@ -145,13 +150,14 @@ export class ArrayValidator {
         if (type.getSingleSchema()) {
             for (let i = 0; i < array.length; i++) {
                 let newParents: Schema[] = !parents ? [] : [...parents];
-                let element: any = await SchemaValidator.validate(
+                array[i] = await SchemaValidator.validate(
                     newParents,
                     type.getSingleSchema(),
                     repository,
                     array[i],
+                    convert,
+                    mode,
                 );
-                array[i] = element;
             }
         }
 
@@ -180,16 +186,19 @@ export class ArrayValidator {
         repository: Repository<Schema> | undefined,
         array: any[],
         type: ArraySchemaType,
+        convert?: boolean,
+        mode?: ConversionMode,
     ) {
         for (let i = 0; i < type.getTupleSchema()?.length!; i++) {
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = await SchemaValidator.validate(
+            array[i] = await SchemaValidator.validate(
                 newParents,
                 type.getTupleSchema()![i],
                 repository,
                 array[i],
+                convert,
+                mode,
             );
-            array[i] = element;
         }
     }
 
@@ -246,13 +255,12 @@ export class ArrayValidator {
     ) {
         for (let i = type.getTupleSchema()?.length!; i < array.length; i++) {
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = await SchemaValidator.validate(
+            array[i] = await SchemaValidator.validate(
                 newParents,
                 schemaType!,
                 repository,
                 array[i],
             );
-            array[i] = element;
         }
         return;
     }

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

@@ -4,6 +4,7 @@ import { AdditionalType, Schema } from '../Schema';
 import { SchemaUtil } from '../SchemaUtil';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
+import { ConversionMode } from '../convertor/enums/ConversionMode';
 
 export class ObjectValidator {
     public static async validate(
@@ -11,7 +12,9 @@ export class ObjectValidator {
         schema: Schema,
         repository: Repository<Schema> | undefined,
         element: any,
-    ) {
+        convert?: boolean,
+        mode?: ConversionMode,
+    ): Promise<any> {
         if (isNullValue(element))
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
@@ -38,7 +41,15 @@ export class ObjectValidator {
         }
 
         if (schema.getProperties()) {
-            await ObjectValidator.checkProperties(parents, schema, repository, jsonObject, keys);
+            await ObjectValidator.checkProperties(
+                parents,
+                schema,
+                repository,
+                jsonObject,
+                keys,
+                convert,
+                mode,
+            );
         }
 
         if (schema.getPatternProperties()) {
@@ -52,7 +63,7 @@ export class ObjectValidator {
         }
 
         if (schema.getAdditionalProperties()) {
-            await ObjectValidator.checkAddtionalProperties(
+            await ObjectValidator.checkAdditionalProperties(
                 parents,
                 schema,
                 repository,
@@ -60,6 +71,8 @@ export class ObjectValidator {
                 keys,
             );
         }
+
+        return jsonObject;
     }
 
     private static async checkPropertyNameSchema(
@@ -96,7 +109,7 @@ export class ObjectValidator {
         }
     }
 
-    private static async checkAddtionalProperties(
+    private static async checkAdditionalProperties(
         parents: Schema[],
         schema: Schema,
         repository: Repository<Schema> | undefined,
@@ -108,13 +121,12 @@ export class ObjectValidator {
             for (let key of Array.from(keys.values())) {
                 let newParents: Schema[] = !parents ? [] : [...parents];
 
-                let element: any = await SchemaValidator.validate(
+                jsonObject[key] = await SchemaValidator.validate(
                     newParents,
                     apt.getSchemaValue(),
                     repository,
                     jsonObject[key],
                 );
-                jsonObject[key] = element;
             }
         } else {
             if (apt.getBooleanValue() === false && keys.size) {
@@ -137,20 +149,17 @@ export class ObjectValidator {
         for (const keyPattern of Array.from(schema.getPatternProperties()!.keys()))
             compiledPatterns.set(keyPattern, new RegExp(keyPattern));
 
-        let goodKeys: string[] = [];
-
         for (const key of Array.from(keys.values())) {
             const newParents: Schema[] = !parents ? [] : [...parents];
 
             for (const e of Array.from(compiledPatterns.entries())) {
                 if (e[1].test(key)) {
-                    const element: any = await SchemaValidator.validate(
+                    jsonObject[key] = await SchemaValidator.validate(
                         newParents,
                         schema.getPatternProperties()!.get(e[0]),
                         repository,
                         jsonObject[key],
                     );
-                    jsonObject[key] = element;
                     keys.delete(key);
                     break;
                 }
@@ -164,6 +173,8 @@ export class ObjectValidator {
         repository: Repository<Schema> | undefined,
         jsonObject: any,
         keys: Set<string>,
+        convert?: boolean,
+        mode?: ConversionMode,
     ) {
         for (const each of Array.from(schema.getProperties()!)) {
             let value: any = jsonObject[each[0]];
@@ -174,14 +185,14 @@ export class ObjectValidator {
             }
 
             let newParents: Schema[] = !parents ? [] : [...parents];
-            let element: any = await SchemaValidator.validate(
+            jsonObject[each[0]] = await SchemaValidator.validate(
                 newParents,
                 each[1],
                 repository,
                 value,
+                convert,
+                mode,
             );
-
-            jsonObject[each[0]] = element;
             keys.delete(each[0]);
         }
     }