@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,145 @@
+import { Repository } from '../../Repository';
+import { StringUtil } from '../../util/string/StringUtil';
+import { Tuple2 } from '../../util/Tuples';
+import { Schema } from './Schema';
+import { SchemaType } from './type/SchemaType';
+import { SchemaReferenceException } from './validator/exception/SchemaReferenceException';
+import { SchemaValidationException } from './validator/exception/SchemaValidationException';
+
+export class SchemaUtil {
+    private static readonly UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH: string =
+        'Unable to retrive schema from referenced path';
+
+    private static readonly CYCLIC_REFERENCE_LIMIT_COUNTER: number = 20;
+
+    public static getDefaultValue(s: Schema | undefined, sRepository: Repository<Schema>): any {
+        if (!s) return undefined;
+
+        if (s.getConstant()) return s.getConstant();
+
+        if (s.getDefaultValue()) return s.getDefaultValue();
+
+        return SchemaUtil.getDefaultValue(
+            SchemaUtil.getSchemaFromRef(s, sRepository, s.getRef()),
+            sRepository,
+        );
+    }
+
+    public static getSchemaFromRef(
+        schema: Schema,
+        sRepository: Repository<Schema> | undefined,
+        ref: string | undefined,
+        iteration: number = 0,
+    ): 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 (!ref.startsWith('#')) {
+            var tuple = SchemaUtil.resolveExternalSchema(schema, sRepository, ref);
+            if (tuple) {
+                schema = tuple.getT1();
+                ref = tuple.getT2();
+            }
+        }
+
+        let parts: string[] = ref.split('/');
+        let i: number = 1;
+
+        schema = SchemaUtil.resolveInternalSchema(schema, sRepository, ref, iteration, parts, i);
+
+        return schema;
+    }
+
+    private static resolveInternalSchema(
+        inSchema: Schema,
+        sRepository: Repository<Schema> | undefined,
+        ref: string,
+        iteration: number,
+        parts: string[],
+        i: number,
+    ): Schema {
+        let schema: Schema | undefined = inSchema;
+        while (i < parts.length) {
+            if (parts[i] === '$defs') {
+                i++;
+
+                if (i >= parts.length || !schema.get$defs())
+                    throw new SchemaReferenceException(
+                        ref,
+                        SchemaUtil.UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH,
+                    );
+
+                schema = schema.get$defs()?.get(parts[i]);
+            } else {
+                if (
+                    schema &&
+                    (!schema.getType()?.contains(SchemaType.OBJECT) || !schema.getProperties())
+                )
+                    throw new SchemaReferenceException(
+                        ref,
+                        'Cannot retrievie schema from non Object type schemas',
+                    );
+
+                schema = schema.getProperties()?.get(parts[i]);
+            }
+
+            i++;
+
+            if (!schema)
+                throw new SchemaReferenceException(
+                    ref,
+                    SchemaUtil.UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH,
+                );
+
+            if (!StringUtil.isNullOrBlank(schema.getRef())) {
+                schema = SchemaUtil.getSchemaFromRef(
+                    schema,
+                    sRepository,
+                    schema.getRef(),
+                    iteration,
+                );
+                if (!schema)
+                    throw new SchemaReferenceException(
+                        ref,
+                        SchemaUtil.UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH,
+                    );
+            }
+        }
+        return schema;
+    }
+
+    private static resolveExternalSchema(
+        inSchem: Schema,
+        sRepository: Repository<Schema> | undefined,
+        ref: string,
+    ): Tuple2<Schema, string> | undefined {
+
+        if (!sRepository) return undefined;
+
+        let nms = StringUtil.splitAtFirstOccurance(inSchem?.getRef() ?? '', '/');
+        if (!nms[0]) return undefined;
+
+        let nmspnm = StringUtil.splitAtFirstOccurance(nms[0], '.');
+        if (!nmspnm[0] || !nmspnm[1]) return undefined;
+
+        let schema = sRepository.find(nmspnm[0], nmspnm[1]);
+        if (!schema) return undefined;
+        if (!nms[1] || nms[1] === '') return new Tuple2(schema, ref);
+
+        ref = '#/' + nms[1];
+
+        if (!schema)
+            throw new SchemaReferenceException(
+                ref,
+                SchemaUtil.UNABLE_TO_RETRIVE_SCHEMA_FROM_REFERENCED_PATH,
+            );
+
+        return new Tuple2(schema, ref);
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,44 @@
+import { isNullValue } from '../../../util/NullCheck';
+import { Schema } from '../Schema';
+
+export class ArraySchemaType {
+    private singleSchema: Schema | undefined;
+    private tupleSchema: Schema[] | undefined;
+
+    public setSingleSchema(schema: Schema): ArraySchemaType {
+        this.singleSchema = schema;
+        return this;
+    }
+
+    public setTupleSchema(schemas: Schema[]): ArraySchemaType {
+        this.tupleSchema = schemas;
+        return this;
+    }
+
+    public getSingleSchema(): Schema | undefined {
+        return this.singleSchema;
+    }
+
+    public getTupleSchema(): Schema[] | undefined {
+        return this.tupleSchema;
+    }
+
+    public isSingleType(): boolean {
+        return !isNullValue(this.singleSchema);
+    }
+
+    public static of(...schemas: Schema[]): ArraySchemaType {
+        if (schemas.length == 1) return new ArraySchemaType().setSingleSchema(schemas[0]);
+
+        return new ArraySchemaType().setTupleSchema(schemas);
+    }
+
+    public static from(obj: any): ArraySchemaType | undefined {
+        if (!obj) return undefined;
+        if (Array.isArray(obj)) ArraySchemaType.of(...Schema.fromListOfSchemas(obj));
+
+        let x = Schema.from(obj);
+        if (!x) return undefined;
+        return ArraySchemaType.of(x);
+    }
+}

package/src/engine/json/schema/object/AdditionalPropertiesType.ts

@@ -0,0 +1,32 @@
+import { Schema } from '../Schema';
+
+export class AdditionalPropertiesType {
+    private booleanValue?: boolean;
+    private schemaValue?: Schema;
+
+    public getBooleanValue(): boolean | undefined {
+        return this.booleanValue;
+    }
+
+    public getSchemaValue(): Schema | undefined {
+        return this.schemaValue;
+    }
+
+    public setBooleanValue(booleanValue: boolean): AdditionalPropertiesType {
+        this.booleanValue = booleanValue;
+        return this;
+    }
+
+    public setSchemaValue(schemaValue: Schema): AdditionalPropertiesType {
+        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;
+        return ad;
+    }
+}

package/src/engine/json/schema/string/StringFormat.ts

@@ -0,0 +1,7 @@
+export enum StringFormat {
+    DATETIME = 'DATETIME',
+    TIME = 'TIME',
+    DATE = 'DATE',
+    EMAIL = 'EMAIL',
+    REGEX = 'REGEX',
+}

package/src/engine/json/schema/type/MultipleType.ts

@@ -0,0 +1,28 @@
+import { SchemaType } from './SchemaType';
+import { Type } from './Type';
+
+export class MultipleType extends Type {
+    private type: Set<SchemaType>;
+
+    constructor(type: Set<SchemaType>) {
+        super();
+        this.type = type;
+    }
+
+    public getType(): Set<SchemaType> {
+        return this.type;
+    }
+
+    public setType(type: Set<SchemaType>): MultipleType {
+        this.type = type;
+        return this;
+    }
+
+    public getAllowedSchemaTypes(): Set<SchemaType> {
+        return this.type;
+    }
+
+    public contains(type: SchemaType): boolean {
+        return this.type?.has(type);
+    }
+}

package/src/engine/json/schema/type/SchemaType.ts

@@ -0,0 +1,11 @@
+export enum SchemaType {
+    INTEGER = 'Integer',
+    LONG = 'Long',
+    FLOAT = 'Float',
+    DOUBLE = 'Double',
+    STRING = 'String',
+    OBJECT = 'Object',
+    ARRAY = 'Array',
+    BOOLEAN = 'Boolean',
+    NULL = 'Null',
+}

package/src/engine/json/schema/type/SingleType.ts

@@ -0,0 +1,23 @@
+import { SchemaType } from './SchemaType';
+import { Type } from './Type';
+
+export class SingleType extends Type {
+    private type: SchemaType;
+
+    constructor(type: SchemaType) {
+        super();
+        this.type = type;
+    }
+
+    public getType(): SchemaType {
+        return this.type;
+    }
+
+    public getAllowedSchemaTypes(): Set<SchemaType> {
+        return new Set([this.type]);
+    }
+
+    public contains(type: SchemaType): boolean {
+        return this.type == type;
+    }
+}

package/src/engine/json/schema/type/Type.ts

@@ -0,0 +1,6 @@
+import { SchemaType } from './SchemaType';
+
+export abstract class Type {
+    public abstract getAllowedSchemaTypes(): Set<SchemaType>;
+    public abstract contains(type: SchemaType): boolean;
+}

package/src/engine/json/schema/type/TypeUtil.ts

@@ -0,0 +1,25 @@
+import { MultipleType } from './MultipleType';
+import { SchemaType } from './SchemaType';
+import { SingleType } from './SingleType';
+import { Type } from './Type';
+
+export class TypeUtil {
+    public static of(...types: SchemaType[]): Type {
+        if (types.length == 1) return new SingleType(types[0]);
+
+        return new MultipleType(new Set(types));
+    }
+
+    public static from(types: any): Type | undefined {
+        if (typeof types === 'string') {
+            return TypeUtil.of(types as SchemaType);
+        } else if (Array.isArray(types)) {
+            return TypeUtil.of(
+                ...Array.of(types)
+                    .map((e) => e as any)
+                    .map((e) => e as SchemaType),
+            );
+        }
+        return undefined;
+    }
+}

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

@@ -0,0 +1,108 @@
+import { Repository } from '../../../Repository';
+import { Schema } from '../Schema';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class AnyOfAllOfOneOfValidator {
+    public static validate(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+    ): any {
+        let list: SchemaValidationException[] = [];
+        if (schema.getOneOf() && !schema.getOneOf()) {
+            AnyOfAllOfOneOfValidator.oneOf(parents, schema, repository, element, list);
+        } else if (schema.getAllOf() && !schema.getAllOf()) {
+            AnyOfAllOfOneOfValidator.allOf(parents, schema, repository, element, list);
+        } else if (schema.getAnyOf() && !schema.getAnyOf()) {
+            AnyOfAllOfOneOfValidator.anyOf(parents, schema, repository, element, list);
+        }
+
+        return element;
+    }
+
+    private static anyOf(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> |undefined,
+        element: any,
+        list: SchemaValidationException[],
+    ) {
+        let flag: boolean = false;
+        for (let s of schema.getAnyOf() ?? []) {
+            try {
+                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                flag = true;
+                break;
+            } catch (err: any) {
+                flag = false;
+                list.push(err);
+            }
+        }
+
+        if (!flag) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                "The value don't satisfy any of the schemas.",
+                list,
+            );
+        }
+    }
+
+    private static allOf(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+        list: SchemaValidationException[],
+    ) {
+        let flag: number = 0;
+        for (let s of schema.getAllOf() ?? []) {
+            try {
+                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                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,
+            );
+        }
+    }
+
+    private static oneOf(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+        list: SchemaValidationException[],
+    ) {
+        let flag: number = 0;
+        for (let s of schema.getOneOf() ?? []) {
+            try {
+                AnyOfAllOfOneOfValidator.validate(parents, s, repository, element);
+                flag++;
+            } 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,
+            );
+        }
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,145 @@
+import { Repository } from '../../../Repository';
+import { isNullValue } from '../../../util/NullCheck';
+import { ArraySchemaType } from '../array/ArraySchemaType';
+import { Schema } from '../Schema';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class ArrayValidator {
+    public static validate(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+    ): any {
+        if (isNullValue(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected an array but found null',
+            );
+
+        if (!Array.isArray(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not an Array',
+            );
+
+        let array: any[] = element as any[];
+
+        ArrayValidator.checkMinMaxItems(parents, schema, array);
+
+        ArrayValidator.checkItems(parents, schema, repository, array);
+
+        ArrayValidator.checkUniqueItems(parents, schema, array);
+
+        ArrayValidator.checkContains(parents, schema, repository, array);
+
+        return element;
+    }
+
+    public static checkContains(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        array: any[],
+    ) {
+        if (!schema.getContains()) return;
+
+        let flag: boolean = false;
+        for (let i = 0; i < array.length; i++) {
+            let newParents: Schema[] = !parents ? [] : [...parents];
+
+            try {
+                SchemaValidator.validate(newParents, schema.getContains(), repository, array[i]);
+                flag = true;
+                break;
+            } catch (err) {
+                flag = false;
+            }
+        }
+
+        if (!flag) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'None of the items are of type contains schema',
+            );
+        }
+    }
+
+    public static checkUniqueItems(parents: Schema[], schema: Schema, array: any[]): void {
+        if (schema.getUniqueItems() && schema.getUniqueItems()) {
+            let set: Set<any> = new Set<any>(array);
+
+            if (set.size !== array.length)
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    'Items on the array are not unique',
+                );
+        }
+    }
+
+    public static checkMinMaxItems(parents: Schema[], schema: Schema, array: any[]): void {
+        if (schema.getMinItems() && schema.getMinItems()! > array.length) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Array should have minimum of ' + schema.getMinItems() + ' elements',
+            );
+        }
+
+        if (schema.getMaxItems() && schema.getMaxItems()! < array.length) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Array can have  maximum of ' + schema.getMaxItems() + ' elements',
+            );
+        }
+    }
+
+    public static checkItems(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        array: any[],
+    ) {
+        if (!schema.getItems()) return;
+
+        let type: ArraySchemaType = schema.getItems()!;
+
+        if (type.getSingleSchema()) {
+            for (let i = 0; i < array.length; i++) {
+                let newParents: Schema[] = !parents ? [] : [...parents];
+                let element: any = SchemaValidator.validate(
+                    newParents,
+                    type.getSingleSchema(),
+                    repository,
+                    array[i],
+                );
+                array[i] = element;
+            }
+        }
+
+        if (type.getTupleSchema()) {
+            if (type.getTupleSchema()!.length !== array.length) {
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    'Expected an array with only ' +
+                        type.getTupleSchema()!.length +
+                        ' but found ' +
+                        array.length,
+                );
+            }
+
+            for (let i = 0; i < array.length; i++) {
+                let newParents: Schema[] = !parents ? [] : [...parents];
+                let element: any = SchemaValidator.validate(
+                    newParents,
+                    type.getTupleSchema()![i],
+                    repository,
+                    array[i],
+                );
+                array[i] = element;
+            }
+        }
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,24 @@
+import { isNullValue } from '../../../util/NullCheck';
+import { Schema } from '../Schema';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class BooleanValidator {
+    public static validate(parents: Schema[], schema: Schema, element: any): any {
+        if (isNullValue(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected a boolean but found null',
+            );
+
+        if (typeof element !== 'boolean')
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not a boolean',
+            );
+
+        return element;
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,17 @@
+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;
+    }
+
+    private constructor() {}
+}