@fincity/kirun-js 2.5.0 → 2.8.2

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/repository/KIRunSchemaRepository.ts

@@ -1,7 +1,8 @@
-import { Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { Parameter } from '../model/Parameter';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Repository } from '../Repository';
+import { MapUtil } from '../util/MapUtil';
 
 const map: Map<string, Schema> = new Map([
     ['any', Schema.ofAny('any').setNamespace(Namespaces.SYSTEM)],
@@ -12,7 +13,59 @@ const map: Map<string, Schema> = new Map([
     ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
     ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
     ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
-    ['Date.timeStamp', Schema.ofString('timeStamp').setNamespace(Namespaces.DATE)],
+    ['Timestamp', Schema.ofString('Timestamp').setNamespace(Namespaces.DATE)],
+    [
+        'Timeunit',
+        Schema.ofString('Timeunit')
+            .setNamespace(Namespaces.DATE)
+            .setEnums([
+                'YEARS',
+                'QUARTERS',
+                'MONTHS',
+                'WEEKS',
+                'DAYS',
+                'HOURS',
+                'MINUTES',
+                'SECONDS',
+                'MILLISECONDS',
+            ]),
+    ],
+    [
+        'Duration',
+        Schema.ofObject('Duration')
+            .setNamespace(Namespaces.DATE)
+            .setProperties(
+                MapUtil.ofArrayEntries(
+                    ['years', Schema.ofInteger('years')],
+                    ['quarters', Schema.ofInteger('quarters')],
+                    ['months', Schema.ofInteger('months')],
+                    ['weeks', Schema.ofInteger('weeks')],
+                    ['days', Schema.ofInteger('days')],
+                    ['hours', Schema.ofInteger('hours')],
+                    ['minutes', Schema.ofInteger('minutes')],
+                    ['seconds', Schema.ofLong('seconds')],
+                    ['milliseconds', Schema.ofLong('milliseconds')],
+                ),
+            )
+            .setAdditionalItems(AdditionalType.from(false)!),
+    ],
+    [
+        'TimeObject',
+        Schema.ofObject('TimeObject')
+            .setNamespace(Namespaces.DATE)
+            .setProperties(
+                MapUtil.ofArrayEntries(
+                    ['year', Schema.ofInteger('year')],
+                    ['month', Schema.ofInteger('month')],
+                    ['day', Schema.ofInteger('day')],
+                    ['hour', Schema.ofInteger('hour')],
+                    ['minute', Schema.ofInteger('minute')],
+                    ['second', Schema.ofLong('second')],
+                    ['millisecond', Schema.ofLong('millisecond')],
+                ),
+            )
+            .setAdditionalItems(AdditionalType.from(false)!),
+    ],
     [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
     [Schema.NULL.getName()!, Schema.NULL],
     [Schema.SCHEMA.getName()!, Schema.SCHEMA],
@@ -22,7 +75,8 @@ const filterableNames = Array.from(map.values()).map((e) => e.getFullName());
 
 export class KIRunSchemaRepository implements Repository<Schema> {
     public async find(namespace: string, name: string): Promise<Schema | undefined> {
-        if (Namespaces.SYSTEM != namespace) return Promise.resolve(undefined);
+        if (Namespaces.SYSTEM != namespace && Namespaces.DATE != namespace)
+            return Promise.resolve(undefined);
 
         return Promise.resolve(map.get(name));
     }

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/src/engine/util/string/StringUtil.ts

@@ -42,6 +42,18 @@ export class StringUtil {
         return [str.substring(0, index), str.substring(index + 1)];
     }
 
+    public static splitAtLastOccurance(
+        str: string,
+        c: string,
+    ): [string | undefined, string | undefined] {
+        if (!str) return [undefined, undefined];
+
+        let index: number = str.lastIndexOf(c);
+        if (index == -1) return [str, undefined];
+
+        return [str.substring(0, index), str.substring(index + 1)];
+    }
+
     public static isNullOrBlank(str: string | undefined): boolean {
         return !str || str.trim() == '';
     }

package/__tests__/engine/function/system/date/AddTimeTest.ts

@@ -1,115 +0,0 @@
-import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from "../../../../../src";
-import { AbstractDateFunction } from "../../../../../src/engine/function/system/date/AbstractDateFunction";
-import { DateFunctionRepository } from "../../../../../src/engine/function/system/date/DateFunctionRepository";
-
-
-const dfr : DateFunctionRepository = new DateFunctionRepository();
-
-const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
-    new KIRunFunctionRepository(),
-    new KIRunSchemaRepository());
-
-test('check for invalid dates', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-   
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-05T06:04:18.073Z'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
-    ]));
-
-    await expect( () => addTimeFunction.execute(fep)).rejects.toThrow();
-});
-
-test('Add Time 1', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MINUTE']
-    ]));
-    
-    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-14T00:02:34.633-05:30');
-})
-
-test('Add Time 2', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 13],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
-    ]));
-    
-    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2025-10-13T23:52:34.633-05:30');
-})
-
-
-test('Add Time 2', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 3],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
-    ]));
-    
-    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-12-13T23:52:34.633-05:30');
-})
-
-test('Add Time 3', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
-    ]));
-    
-    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:52:44.633-05:30');
-    
-})
-
-
-test('Add Time 4', async () => {
-
-    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
-
-    if (!addTimeFunction) {
-        throw new Error("Function not found");
-    }
-
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 5],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'YEAR']
-    ]));
-    
-    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2029-09-13T23:52:34.633-05:30');
-})