@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,115 @@
+import { isNullValue } from '../../../util/NullCheck';
+import { Schema } from '../Schema';
+import { SchemaType } from '../type/SchemaType';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class NumberValidator {
+    public static validate(type: SchemaType, parents: Schema[], schema: Schema, element: any): any {
+        if (isNullValue(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected a number but found null',
+            );
+
+        if (typeof element !== 'number')
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not a ' + type,
+            );
+
+        let n: number = NumberValidator.extractNumber(type, parents, schema, element);
+
+        NumberValidator.checkRange(parents, schema, element, n);
+
+        NumberValidator.checkMultipleOf(parents, schema, element, n);
+
+        return element;
+    }
+
+    private static extractNumber(
+        type: SchemaType,
+        parents: Schema[],
+        schema: Schema,
+        element: any,
+    ): number {
+        let n = element;
+
+        try {
+            if (type == SchemaType.LONG || type == SchemaType.INTEGER) n = Math.round(n);
+        } catch (err: any) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element + ' is not a number of type ' + type,
+                err,
+            );
+        }
+
+        if (
+            isNullValue(n) ||
+            ((type == SchemaType.LONG || type == SchemaType.INTEGER) && n != element)
+        ) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not a number of type ' + type,
+            );
+        }
+
+        return n;
+    }
+
+    private static checkMultipleOf(parents: Schema[], schema: Schema, element: any, n: number) {
+        if (schema.getMultipleOf()) {
+            let l1: number = n;
+            let l2: number = schema.getMultipleOf()!;
+
+            if (l1 % l2 != 0)
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    element.toString() + ' is not multiple of ' + schema.getMultipleOf(),
+                );
+        }
+    }
+
+    private static checkRange(parents: Schema[], schema: Schema, element: any, n: number) {
+        if (schema.getMinimum() && NumberValidator.numberCompare(n, schema.getMinimum()!) < 0) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' should be greater than or equal to ' + schema.getMinimum(),
+            );
+        }
+
+        if (schema.getMaximum() && NumberValidator.numberCompare(n, schema.getMaximum()!) > 0) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' should be less than or equal to ' + schema.getMaximum(),
+            );
+        }
+
+        if (
+            schema.getExclusiveMinimum() &&
+            NumberValidator.numberCompare(n, schema.getExclusiveMinimum()!) <= 0
+        ) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' should be greater than ' + schema.getExclusiveMinimum(),
+            );
+        }
+
+        if (
+            schema.getExclusiveMaximum() &&
+            NumberValidator.numberCompare(n, schema.getExclusiveMaximum()!) > 0
+        ) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' should be less than ' + schema.getExclusiveMaximum(),
+            );
+        }
+    }
+
+    private static numberCompare(n1: number, n2: number): number {
+        return n1 - n2;
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,184 @@
+import { Repository } from '../../../Repository';
+import { isNullValue } from '../../../util/NullCheck';
+import { AdditionalPropertiesType } from '../object/AdditionalPropertiesType';
+import { Schema } from '../Schema';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class ObjectValidator {
+    public static validate(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+    ) {
+        if (isNullValue(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected an object but found null',
+            );
+
+        if (typeof element !== 'object' || Array.isArray(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not an Object',
+            );
+
+        let jsonObject: any = element;
+        let keys: Set<string> = new Set<string>(Object.keys(jsonObject));
+
+        ObjectValidator.checkMinMaxProperties(parents, schema, keys);
+
+        if (schema.getPropertyNames()) {
+            ObjectValidator.checkPropertyNameSchema(parents, schema, repository, keys);
+        }
+
+        if (schema.getRequired()) {
+            ObjectValidator.checkRequired(parents, schema, jsonObject);
+        }
+
+        if (schema.getProperties()) {
+            ObjectValidator.checkProperties(parents, schema, repository, jsonObject, keys);
+        }
+
+        if (schema.getPatternProperties()) {
+            ObjectValidator.checkPatternProperties(parents, schema, repository, jsonObject, keys);
+        }
+
+        if (schema.getAdditionalProperties()) {
+            ObjectValidator.checkAddtionalProperties(parents, schema, repository, jsonObject, keys);
+        }
+    }
+
+    private static checkPropertyNameSchema(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        keys: Set<String>,
+    ) {
+        for (let key of Array.from(keys.values())) {
+            try {
+                SchemaValidator.validate(
+                    parents,
+                    schema.getPropertyNames() as Schema,
+                    repository,
+                    key,
+                );
+            } catch (err) {
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    "Property name '" + key + "' does not fit the property schema",
+                );
+            }
+        }
+    }
+
+    private static checkRequired(parents: Schema[], schema: Schema, jsonObject: any) {
+        for (const key of schema.getRequired() ?? []) {
+            if (isNullValue(jsonObject[key])) {
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    key + ' is mandatory',
+                );
+            }
+        }
+    }
+
+    private static checkAddtionalProperties(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        jsonObject: any,
+        keys: Set<string>,
+    ) {
+        let apt: AdditionalPropertiesType = schema.getAdditionalProperties()!;
+        if (apt.getSchemaValue()) {
+            for (let key of Array.from(keys.values())) {
+                let newParents: Schema[] = !parents ? [] : [...parents];
+
+                let element: any = SchemaValidator.validate(
+                    newParents,
+                    apt.getSchemaValue(),
+                    repository,
+                    jsonObject.get(key),
+                );
+                jsonObject[key] = element;
+            }
+        } else {
+            if (apt.getBooleanValue() === false && keys.size) {
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    keys.toString() + ' are additional properties which are not allowed.',
+                );
+            }
+        }
+    }
+
+    private static checkPatternProperties(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        jsonObject: any,
+        keys: Set<string>,
+    ) {
+        const compiledPatterns: Map<string, RegExp> = new Map<string, RegExp>();
+        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 = SchemaValidator.validate(
+                        newParents,
+                        schema.getPatternProperties()!.get(e[0]),
+                        repository,
+                        jsonObject[key],
+                    );
+                    jsonObject[key] = element;
+                    keys.delete(key);
+                    break;
+                }
+            }
+        }
+    }
+
+    private static checkProperties(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        jsonObject: any,
+        keys: Set<string>,
+    ) {
+        for (const each of Array.from(schema.getProperties()!)) {
+            let value: any = jsonObject[each[0]];
+            if (isNullValue(value)) continue;
+
+            let newParents: Schema[] = !parents ? [] : [...parents];
+            let element: any = SchemaValidator.validate(newParents, each[1], repository, value);
+            jsonObject[each[0]] = element;
+            keys.delete(each[0]);
+        }
+    }
+
+    private static checkMinMaxProperties(parents: Schema[], schema: Schema, keys: Set<string>) {
+        if (schema.getMinProperties() && keys.size < schema.getMinProperties()!) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Object should have minimum of ' + schema.getMinProperties() + ' properties',
+            );
+        }
+
+        if (schema.getMaxProperties() && keys.size > schema.getMaxProperties()!) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Object can have maximum of ' + schema.getMaxProperties() + ' properties',
+            );
+        }
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,141 @@
+import { Repository } from '../../../Repository';
+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';
+
+export class SchemaValidator {
+    public static path(parents: Schema[] | undefined): string {
+        if (!parents) return '';
+
+        return parents
+            .map((e) => e.getTitle() ?? '')
+            .filter((e) => !!e)
+            .reduce((a, c, i) => a + (i === 0 ? '' : '.') + c, '');
+    }
+
+    public static validate(
+        parents: Schema[] | undefined,
+        schema: Schema | undefined,
+        repository: Repository<Schema> | undefined,
+        element: any,
+    ): any {
+        if (!schema) {
+            return element;
+        }
+
+        if (!parents) {
+            parents = new Array();
+        }
+        parents.push(schema);
+
+        if (isNullValue(element) && !isNullValue(schema.getDefaultValue())) {
+            return JSON.parse(JSON.stringify(schema.getDefaultValue()));
+        }
+
+        if (schema.getConstant()) {
+            return SchemaValidator.constantValidation(parents, schema, element);
+        }
+
+        if (schema.getEnums() && !schema.getEnums()?.length) {
+            return SchemaValidator.enumCheck(parents, schema, element);
+        }
+
+        if (schema.getType()) {
+            SchemaValidator.typeValidation(parents, schema, repository, element);
+        }
+
+        if (!StringUtil.isNullOrBlank(schema.getRef())) {
+            return SchemaValidator.validate(
+                parents,
+                SchemaUtil.getSchemaFromRef(parents[0], repository, schema.getRef()),
+                repository,
+                element,
+            );
+        }
+
+        if (schema.getOneOf() || schema.getAllOf() || schema.getAnyOf()) {
+            AnyOfAllOfOneOfValidator.validate(parents, schema, repository, element);
+        }
+
+        if (schema.getNot()) {
+            let flag: boolean = false;
+            try {
+                SchemaValidator.validate(parents, schema.getNot(), repository, element);
+                flag = true;
+            } catch (err) {
+                flag = false;
+            }
+            if (flag)
+                throw new SchemaValidationException(
+                    SchemaValidator.path(parents),
+                    'Schema validated value in not condition.',
+                );
+        }
+
+        return element;
+    }
+
+    public static constantValidation(parents: Schema[], schema: Schema, element: any): any {
+        if (!schema.getConstant().equals(element)) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expecting a constant value : ' + element,
+            );
+        }
+        return element;
+    }
+
+    public static enumCheck(parents: Schema[], schema: Schema, element: any): any {
+        let x: boolean = false;
+        for (let e of schema.getEnums() ?? []) {
+            if (e === element) {
+                x = true;
+                break;
+            }
+        }
+
+        if (x) return element;
+        else {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Value is not one of ' + schema.getEnums(),
+            );
+        }
+    }
+
+    public static typeValidation(
+        parents: Schema[],
+        schema: Schema,
+        repository: Repository<Schema> | undefined,
+        element: any,
+    ) {
+        let valid: boolean = false;
+        let list: SchemaValidationException[] = [];
+
+        for (const type of Array.from(schema.getType()?.getAllowedSchemaTypes()?.values() ?? [])) {
+            try {
+                TypeValidator.validate(parents, type, schema, repository, element);
+                valid = true;
+                break;
+            } catch (err: any) {
+                valid = false;
+                list.push(err);
+            }
+        }
+
+        if (!valid) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Value ' + JSON.stringify(element) + ' is not of valid type(s)',
+                list,
+            );
+        }
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,97 @@
+import { isNullValue } from '../../../util/NullCheck';
+import { Schema } from '../Schema';
+import { StringFormat } from '../string/StringFormat';
+import { SchemaValidationException } from './exception/SchemaValidationException';
+import { SchemaValidator } from './SchemaValidator';
+
+export class StringValidator {
+    private static readonly TIME: RegExp =
+        /^([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?([+-][01][0-9]:[0-5][0-9])?$/;
+
+    private static readonly DATE: RegExp =
+        /^[0-9]{4,4}-([0][0-9]|[1][0-2])-(0[1-9]|[1-2][1-9]|3[01])$/;
+
+    private static readonly DATETIME: RegExp =
+        /^[0-9]{4,4}-([0][0-9]|[1][0-2])-(0[1-9]|[1-2][1-9]|3[01])T([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?([+-][01][0-9]:[0-5][0-9])?$/;
+
+    public static validate(parents: Schema[], schema: Schema, element: any): any {
+        if (isNullValue(element))
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected a string but found null',
+            );
+
+        if (typeof element !== 'string')
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not String',
+            );
+
+        if (schema.getFormat() == StringFormat.TIME) {
+            StringValidator.patternMatcher(
+                parents,
+                schema,
+                element,
+                StringValidator.TIME,
+                'time pattern',
+            );
+        } else if (schema.getFormat() == StringFormat.DATE) {
+            StringValidator.patternMatcher(
+                parents,
+                schema,
+                element,
+                StringValidator.DATE,
+                'date pattern',
+            );
+        } else if (schema.getFormat() == StringFormat.DATETIME) {
+            StringValidator.patternMatcher(
+                parents,
+                schema,
+                element,
+                StringValidator.DATETIME,
+                'date time pattern',
+            );
+        } else if (schema.getPattern()) {
+            StringValidator.patternMatcher(
+                parents,
+                schema,
+                element,
+                new RegExp(schema.getPattern()!),
+                'pattern ' + schema.getPattern(),
+            );
+        }
+
+        let length: number = element.length;
+        if (schema.getMinLength() && length < schema.getMinLength()!) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected a minimum of ' + schema.getMinLength() + ' characters',
+            );
+        } else if (schema.getMaxLength() && length > schema.getMinLength()!) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'Expected a maximum of ' + schema.getMaxLength() + ' characters',
+            );
+        }
+
+        return element;
+    }
+
+    private static patternMatcher(
+        parents: Schema[],
+        schema: Schema,
+        element: any,
+        pattern: RegExp,
+        message: string,
+    ) {
+        let matched: boolean = pattern.test(element);
+        if (!matched) {
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                element.toString() + ' is not matched with the ' + message,
+            );
+        }
+    }
+
+    private constructor() {}
+}

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

@@ -0,0 +1,49 @@
+import { Repository } from '../../../Repository';
+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';
+
+export class TypeValidator {
+    public static validate(
+        parents: Schema[],
+        type: SchemaType,
+        schema: Schema,
+        repository: Repository<Schema> |undefined,
+        element: any,
+    ): 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) {
+            ObjectValidator.validate(parents, schema, repository, element);
+        } else if (type == SchemaType.ARRAY) {
+            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 element;
+    }
+
+    private constructor() {}
+}

package/src/engine/json/schema/validator/exception/SchemaReferenceException.ts

@@ -0,0 +1,19 @@
+export class SchemaReferenceException extends Error {
+    private schemaPath: string;
+    private cause?: Error;
+
+    constructor(schemaPath: string, message: string, err?: Error) {
+        super(schemaPath.trim() ? schemaPath + '-' + message : message);
+
+        this.schemaPath = schemaPath;
+        this.cause = err;
+    }
+
+    public getSchemaPath(): string {
+        return this.schemaPath;
+    }
+
+    public getCause(): Error | undefined {
+        return this.cause;
+    }
+}

package/src/engine/json/schema/validator/exception/SchemaValidationException.ts

@@ -0,0 +1,22 @@
+export class SchemaValidationException extends Error {
+    private schemaPath: string;
+    private cause?: Error;
+    constructor(
+        schemaPath: string,
+        message: string,
+        sve: SchemaValidationException[] = [],
+        err?: Error,
+    ) {
+        super(message + (sve ? sve.map((e) => e.message).reduce((a, c) => a + '\n' + c, '') : ''));
+        this.schemaPath = schemaPath;
+        this.cause = err;
+    }
+
+    public getSchemaPath(): string {
+        return this.schemaPath;
+    }
+
+    public getCause(): Error | undefined {
+        return this.cause;
+    }
+}

package/src/engine/model/AbstractStatement.ts

@@ -0,0 +1,29 @@
+import { Position } from './Position';
+
+export class AbstractStatement {
+    private comment?: string;
+    private description?: string;
+    private position?: Position;
+
+    public getComment(): string | undefined {
+        return this.comment;
+    }
+    public setComment(comment: string): AbstractStatement {
+        this.comment = comment;
+        return this;
+    }
+    public getDescription(): string | undefined {
+        return this.description;
+    }
+    public setDescription(description: string): AbstractStatement {
+        this.description = description;
+        return this;
+    }
+    public getPosition(): Position | undefined {
+        return this.position;
+    }
+    public setPosition(position: Position): AbstractStatement {
+        this.position = position;
+        return this;
+    }
+}

package/src/engine/model/Argument.ts

@@ -0,0 +1,36 @@
+export class Argument {
+    private argumentIndex: number = 0;
+    private name: string;
+    private value: any;
+
+    public constructor(argumentIndex: number, name: string, value?: any) {
+        this.argumentIndex = argumentIndex;
+        this.name = name;
+        this.value = value;
+    }
+    public getArgumentIndex(): number {
+        return this.argumentIndex;
+    }
+    public setArgumentIndex(argumentIndex: number): Argument {
+        this.argumentIndex = argumentIndex;
+        return this;
+    }
+    public getName(): string {
+        return this.name;
+    }
+    public setName(name: string): Argument {
+        this.name = name;
+        return this;
+    }
+    public getValue(): any {
+        return this.value;
+    }
+    public setValue(value: any): Argument {
+        this.value = value;
+        return this;
+    }
+
+    public static of(name: string, value: any): Argument {
+        return new Argument(0, name, value);
+    }
+}