kodzero-schema-parser 0.0.1

package/dist/KodzeroToValidnoParser.d.ts

@@ -0,0 +1,46 @@
+import type { TableField, TableFieldAny } from './kz-schema-factory/types.js';
+import type TableFieldString from './kz-schema-factory/types-constructors/string.js';
+import type TableFieldNumber from './kz-schema-factory/types-constructors/number.js';
+import type TableFieldBoolean from './kz-schema-factory/types-constructors/boolean.js';
+import type TableFieldDate from './kz-schema-factory/types-constructors/date.js';
+import type TableFieldJson from './kz-schema-factory/types-constructors/json.js';
+import type TableFieldEmail from './kz-schema-factory/types-constructors/email.js';
+import type TableFieldUrl from './kz-schema-factory/types-constructors/url.js';
+import type TableFieldSelect from './kz-schema-factory/types-constructors/select.js';
+declare class KodzeroToValidnoParser {
+    static parseString(field: TableField<TableFieldString>): {
+        type: StringConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseNumber(field: TableField<TableFieldNumber>): {
+        type: NumberConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseBoolean(field: TableField<TableFieldBoolean>): {
+        type: BooleanConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseDate(field: TableField<TableFieldDate>): {
+        type: DateConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseJson(field: TableField<TableFieldJson>): {
+        type: StringConstructor;
+        rules: Record<string, unknown>;
+    };
+    static parseEmail(field: TableField<TableFieldEmail>): {
+        type: StringConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseUrl(field: TableField<TableFieldUrl>): {
+        type: StringConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseSelect(field: TableField<TableFieldSelect>): {
+        type: StringConstructor | ArrayConstructor;
+        rules?: Record<string, unknown>;
+    };
+    static parseSchema(schemaDb: TableField<TableFieldAny>[]): unknown;
+}
+export default KodzeroToValidnoParser;
+//# sourceMappingURL=KodzeroToValidnoParser.d.ts.map

package/dist/KodzeroToValidnoParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KodzeroToValidnoParser.d.ts","sourceRoot":"","sources":["../src/KodzeroToValidnoParser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAC7E,OAAO,KAAK,gBAAgB,MAAM,kDAAkD,CAAA;AACpF,OAAO,KAAK,gBAAgB,MAAM,kDAAkD,CAAA;AACpF,OAAO,KAAK,iBAAiB,MAAM,mDAAmD,CAAA;AACtF,OAAO,KAAK,cAAc,MAAM,gDAAgD,CAAA;AAChF,OAAO,KAAK,cAAc,MAAM,gDAAgD,CAAA;AAChF,OAAO,KAAK,eAAe,MAAM,iDAAiD,CAAA;AAClF,OAAO,KAAK,aAAa,MAAM,+CAA+C,CAAA;AAC9E,OAAO,KAAK,gBAAgB,MAAM,kDAAkD,CAAA;AAIpF,cAAM,sBAAsB;IAC1B,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,gBAAgB,CAAC;cAC9B,iBAAiB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAkC1E,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,gBAAgB,CAAC;cAC9B,iBAAiB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IA6B1E,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,iBAAiB,CAAC;cAChC,kBAAkB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAmB3E,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,cAAc,CAAC;cAC1B,eAAe;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAkDxE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,cAAc,CAAC;cAC1B,iBAAiB;eAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAuBzE,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC;cAC5B,iBAAiB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAyE1E,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,aAAa,CAAC;cACxB,iBAAiB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IAuE1E,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,gBAAgB,CAAC;cAC9B,iBAAiB,GAAG,gBAAgB;gBAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IA6C7F,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,UAAU,CAAC,aAAa,CAAC,EAAE,GAAG,OAAO;CA0CnE;AAED,eAAe,sBAAsB,CAAA"}

package/dist/KodzeroToValidnoParser.js

@@ -0,0 +1,306 @@
+import { validations } from 'validno';
+import isValidJSON from './utils/is-valid-json.js';
+const defaultKeys = ['_id', 'createdAt', 'updatedAt'];
+class KodzeroToValidnoParser {
+    static parseString(field) {
+        const output = { type: String };
+        const specs = {
+            lengthMax: field.item.specs.lengthMax !== null,
+            lengthMin: field.item.specs.lengthMin !== null,
+            pattern: field.item.specs.pattern !== null,
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        const hasSpecs = Object.values(specs).some((v) => v === true);
+        if (hasSpecs) {
+            output.rules = {};
+            if (specs.lengthMax) {
+                output.rules.maxlength = field.item.specs.lengthMax;
+            }
+            if (specs.lengthMin) {
+                output.rules.minlength = field.item.specs.lengthMin;
+            }
+            if (specs.pattern && typeof field.item.specs.pattern === 'string') {
+                output.rules.regex = new RegExp(field.item.specs.pattern);
+            }
+            if (specs.mayBeEmpty) {
+                output.rules.lengthNot = 0;
+            }
+        }
+        return output;
+    }
+    static parseNumber(field) {
+        const output = { type: Number };
+        const specs = {
+            min: field.item.specs.min !== null,
+            max: field.item.specs.max !== null,
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        const hasSpecs = Object.values(specs).some((v) => v === true);
+        if (hasSpecs) {
+            output.rules = {};
+            if (specs.min) {
+                output.rules.min = field.item.specs.min;
+            }
+            if (specs.max) {
+                output.rules.max = field.item.specs.max;
+            }
+            if (specs.mayBeEmpty) {
+                output.rules.isNot = 0;
+            }
+        }
+        return output;
+    }
+    static parseBoolean(field) {
+        const output = { type: Boolean };
+        const specs = {
+            onlyTrue: field.item.specs.onlyTrue === true,
+        };
+        const hasSpecs = Object.values(specs).some((v) => v === true);
+        if (hasSpecs) {
+            output.rules = {};
+            if (specs.onlyTrue) {
+                output.rules.is = true;
+            }
+        }
+        return output;
+    }
+    static parseDate(field) {
+        const output = { type: Date };
+        const specs = {
+            min: field.item.specs.min !== null,
+            max: field.item.specs.max !== null,
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        const hasSpecs = Object.values(specs).some((v) => v === true);
+        if (hasSpecs) {
+            output.rules = {};
+            if (specs.mayBeEmpty) {
+                output.rules.isNot = null;
+            }
+            if (specs.min || specs.max) {
+                output.rules.custom = (value, {}) => {
+                    const checks = { min: true, max: true };
+                    const dateValue = new Date(value).getTime();
+                    if (specs.min) {
+                        const minDate = new Date(field.item.specs.min).getTime();
+                        if (dateValue < minDate) {
+                            checks.min = false;
+                        }
+                    }
+                    if (specs.max) {
+                        const maxDate = new Date(field.item.specs.max).getTime();
+                        if (dateValue > maxDate) {
+                            checks.max = false;
+                        }
+                    }
+                    const passed = Object.values(checks).every((v) => v === true);
+                    return {
+                        result: passed,
+                        details: passed ? '' : 'Date is out of allowed range',
+                    };
+                };
+            }
+        }
+        return output;
+    }
+    static parseJson(field) {
+        const output = {
+            type: String,
+            rules: {},
+        };
+        const specs = {
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        if (specs.mayBeEmpty) {
+            output.rules.isNot = '';
+        }
+        output.rules.custom = (value, {}) => {
+            return {
+                result: isValidJSON(value),
+                details: isValidJSON(value) ? '' : 'Invalid JSON format',
+            };
+        };
+        return output;
+    }
+    static parseEmail(field) {
+        const output = { type: String };
+        const hasSpecs = {
+            allowedDomains: Array.isArray(field.item.specs.allowedDomains) &&
+                field.item.specs.allowedDomains.length > 0,
+            exceptDomains: Array.isArray(field.item.specs.exceptDomains) && field.item.specs.exceptDomains.length > 0,
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        output.rules = {};
+        if (hasSpecs.mayBeEmpty) {
+            output.rules.isNot = '';
+        }
+        if (hasSpecs.allowedDomains || hasSpecs.exceptDomains || !hasSpecs.mayBeEmpty) {
+            output.rules.custom = (value, {}) => {
+                if (field.item.specs.mayBeEmpty === true && value === '') {
+                    return {
+                        result: true,
+                        details: '',
+                    };
+                }
+                if (field.item.specs.mayBeEmpty && typeof value === 'string' && value.trim() === '') {
+                    return {
+                        result: true,
+                        details: '',
+                    };
+                }
+                const emailParts = value.split('@');
+                const formatCheck = validations.isEmail(value);
+                if (!formatCheck) {
+                    return {
+                        result: false,
+                        details: 'Invalid email format',
+                    };
+                }
+                const domain = emailParts[1].toLowerCase();
+                let allowed = true;
+                if (hasSpecs.allowedDomains) {
+                    const allowedDomainsLower = field.item.specs.allowedDomains.map((d) => d.toLowerCase());
+                    if (!allowedDomainsLower.includes(domain)) {
+                        allowed = false;
+                    }
+                }
+                if (hasSpecs.exceptDomains) {
+                    const exceptDomainsLower = field.item.specs.exceptDomains.map((d) => d.toLowerCase());
+                    if (exceptDomainsLower.includes(domain)) {
+                        allowed = false;
+                    }
+                }
+                return {
+                    result: allowed,
+                    details: allowed ? '' : 'Email domain is not allowed',
+                };
+            };
+        }
+        return output;
+    }
+    static parseUrl(field) {
+        const output = { type: String };
+        const specs = {
+            allowedDomains: Array.isArray(field.item.specs.allowedDomains) &&
+                field.item.specs.allowedDomains.length > 0,
+            exceptDomains: Array.isArray(field.item.specs.exceptDomains) && field.item.specs.exceptDomains.length > 0,
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        const hasSpecs = Object.values(specs).some((v) => v === true);
+        if (hasSpecs) {
+            output.rules = {};
+            if (specs.mayBeEmpty) {
+                output.rules.isNot = '';
+            }
+            if (specs.allowedDomains || specs.exceptDomains) {
+                output.rules.custom = (value, {}) => {
+                    if (field.item.specs.mayBeEmpty && typeof value === 'string' && value.trim() === '') {
+                        return {
+                            result: true,
+                            details: '',
+                        };
+                    }
+                    const urlPattern = /^(https?:\/\/)?(www\.)?([^\/]+)/i;
+                    const match = value.match(urlPattern);
+                    if (!match || match.length < 3) {
+                        return {
+                            result: false,
+                            details: 'Invalid URL format',
+                        };
+                    }
+                    const domain = match[3].toLowerCase();
+                    let allowed = true;
+                    if (specs.allowedDomains) {
+                        const allowedDomainsLower = field.item.specs.allowedDomains.map((d) => d.toLowerCase());
+                        if (!allowedDomainsLower.includes(domain)) {
+                            allowed = false;
+                        }
+                    }
+                    if (specs.exceptDomains) {
+                        const exceptDomainsLower = field.item.specs.exceptDomains.map((d) => d.toLowerCase());
+                        if (exceptDomainsLower.includes(domain)) {
+                            allowed = false;
+                        }
+                    }
+                    return {
+                        result: allowed,
+                        details: allowed ? '' : 'URL domain is not allowed',
+                    };
+                };
+            }
+        }
+        return output;
+    }
+    static parseSelect(field) {
+        const output = {
+            type: String,
+        };
+        const specs = {
+            mayBeEmpty: field.item.specs.mayBeEmpty === false,
+        };
+        output.rules = {};
+        if (specs.mayBeEmpty) {
+            output.rules.isNot = '';
+        }
+        if (field.item.specs.multiple) {
+            output.type = Array;
+            output.rules.eachType = String;
+            if (Array.isArray(field.item.specs.allowedValues) &&
+                field.item.specs.allowedValues.length > 0) {
+                output.rules.enum = field.item.specs.allowedValues;
+            }
+        }
+        else {
+            if (Array.isArray(field.item.specs.allowedValues) &&
+                field.item.specs.allowedValues.length > 0) {
+                output.rules.enum = field.item.specs.allowedValues;
+            }
+            if (field.item.specs.mayBeEmpty === true) {
+                if (!output.rules.enum) {
+                    output.rules.enum = [];
+                }
+                ;
+                output.rules.enum.push('');
+            }
+        }
+        return output;
+    }
+    static parseSchema(schemaDb) {
+        const schema = {};
+        const schemaFiltered = schemaDb.filter((field) => field.item.key && !defaultKeys.includes(field.item.key));
+        for (const field of schemaFiltered) {
+            const key = field.item.key;
+            const type = field.item.type;
+            switch (type) {
+                case 'string':
+                    schema[key] = KodzeroToValidnoParser.parseString(field);
+                    break;
+                case 'number':
+                    schema[key] = KodzeroToValidnoParser.parseNumber(field);
+                    break;
+                case 'boolean':
+                    schema[key] = KodzeroToValidnoParser.parseBoolean(field);
+                    break;
+                case 'date':
+                    schema[key] = KodzeroToValidnoParser.parseDate(field);
+                    break;
+                case 'json':
+                    schema[key] = KodzeroToValidnoParser.parseJson(field);
+                    break;
+                case 'email':
+                    schema[key] = KodzeroToValidnoParser.parseEmail(field);
+                    break;
+                case 'url':
+                    schema[key] = KodzeroToValidnoParser.parseUrl(field);
+                    break;
+                case 'select':
+                    schema[key] = KodzeroToValidnoParser.parseSelect(field);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return schema;
+    }
+}
+export default KodzeroToValidnoParser;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import KodzeroToValidnoParser from "./KodzeroToValidnoParser.js";
+export default KodzeroToValidnoParser;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,MAAM,6BAA6B,CAAC;AAEjE,eAAe,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import KodzeroToValidnoParser from "./KodzeroToValidnoParser.js";
+export default KodzeroToValidnoParser;

package/dist/kz-schema-factory/FieldValidator.d.ts

@@ -0,0 +1,18 @@
+import { TableField, TableFieldAny } from "./types.js";
+declare class FieldValidator {
+    constructor();
+    static validateString(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateBoolean(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateDate(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateEmail(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateJson(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateNumber(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateSelect(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateUrl(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateBase(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateWrapper(input: Record<string, any>): import("validno").ValidnoResult;
+    static validateSpecsAuto(type: string, specs: Record<string, any>): import("validno").ValidnoResult;
+    static validateAllFields(fields: TableField<TableFieldAny>[]): boolean;
+}
+export default FieldValidator;
+//# sourceMappingURL=FieldValidator.d.ts.map

package/dist/kz-schema-factory/FieldValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldValidator.d.ts","sourceRoot":"","sources":["../../src/kz-schema-factory/FieldValidator.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2FvD,cAAM,cAAc;;IAGhB,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIhD,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIjD,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI9C,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI/C,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI9C,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIhD,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIhD,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI7C,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI9C,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIjD,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAuBjE,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,aAAa,CAAC,EAAE;CAgB/D;AAED,eAAe,cAAc,CAAC"}

package/dist/kz-schema-factory/FieldValidator.js

@@ -0,0 +1,153 @@
+import Schema from "validno";
+import { booleanSpecsSchema } from "./types-constructors/boolean.js";
+import { dateSpecsSchema } from "./types-constructors/date.js";
+import { emailSpecsSchema } from "./types-constructors/email.js";
+import { stringSpecsSchema } from "./types-constructors/string.js";
+import { jsonSpecsSchema } from "./types-constructors/json.js";
+import { numberSpecsSchema } from "./types-constructors/number.js";
+import { selectSpecsSchema } from "./types-constructors/select.js";
+import { urlSpecsSchema } from "./types-constructors/url.js";
+const Checks = {
+    'ok': {
+        description: 'Summary of validations',
+        error: 'Field is invalid'
+    },
+    'unique': {
+        description: 'Enserues that key name is unique across the schema',
+        error: 'Field key is not unique'
+    },
+    'wrapper': {
+        description: 'Validates field wrapper',
+        error: 'Field wrapper failed validation'
+    },
+    'base': {
+        description: 'Validates base field parameters',
+        error: 'Base settings failed validation'
+    },
+    'specs': {
+        description: 'Validates type-specific field parameters',
+        error: 'Specifications failed validation'
+    }
+};
+const getCheckErrorText = (checkId) => {
+    return Checks[checkId].error;
+};
+const baseSchema = new Schema({
+    key: { type: String },
+    type: { type: String },
+    title: { type: String },
+});
+const wrapperSchema = new Schema({
+    id: { type: String },
+    order: { type: Number },
+    isAuto: { type: Boolean, required: false },
+    item: { type: Object },
+});
+const handleKey = (field, allKeys) => {
+    const output = {};
+    const keyName = field.item.key;
+    const isUnique = allKeys.filter(k => k === keyName).length === 1;
+    const wrapperResult = FieldValidator.validateWrapper(field);
+    const baseResult = FieldValidator.validateBase(field.item);
+    const specsResult = FieldValidator.validateSpecsAuto(field.item.type, field.item.specs);
+    output['unique'] = isUnique;
+    output['wrapper'] = wrapperResult.ok || false;
+    output['base'] = baseResult.ok || false;
+    output['specs'] = specsResult.ok || false;
+    output['ok'] = [
+        isUnique,
+        wrapperResult.ok,
+        baseResult.ok,
+        specsResult.ok
+    ].every(el => el === true);
+    return output;
+};
+const getFinalResult = (results) => {
+    const errors = {};
+    let errorsString = '';
+    for (const [key, result] of Object.entries(results)) {
+        if (!result.ok) {
+            const failed = Object.entries(result)
+                .filter(([k, v]) => k !== 'ok' && v === false)
+                .map(([k]) => getCheckErrorText(k));
+            if (failed.length) {
+                errors[key] = failed;
+                errorsString += `"${key}": ${failed.join(',')};`;
+            }
+        }
+    }
+    const finalResult = {
+        ok: !Object.keys(errors).length,
+        errors,
+        errorsString
+    };
+    return finalResult;
+};
+class FieldValidator {
+    constructor() { }
+    static validateString(input) {
+        return stringSpecsSchema.validate(input);
+    }
+    static validateBoolean(input) {
+        return booleanSpecsSchema.validate(input);
+    }
+    static validateDate(input) {
+        return dateSpecsSchema.validate(input);
+    }
+    static validateEmail(input) {
+        return emailSpecsSchema.validate(input);
+    }
+    static validateJson(input) {
+        return jsonSpecsSchema.validate(input);
+    }
+    static validateNumber(input) {
+        return numberSpecsSchema.validate(input);
+    }
+    static validateSelect(input) {
+        return selectSpecsSchema.validate(input);
+    }
+    static validateUrl(input) {
+        return urlSpecsSchema.validate(input);
+    }
+    static validateBase(input) {
+        return baseSchema.validate(input);
+    }
+    static validateWrapper(input) {
+        return wrapperSchema.validate(input);
+    }
+    static validateSpecsAuto(type, specs) {
+        switch (String(type)) {
+            case 'string':
+                return this.validateString(specs);
+            case 'boolean':
+                return this.validateBoolean(specs);
+            case 'date':
+                return this.validateDate(specs);
+            case 'email':
+                return this.validateEmail(specs);
+            case 'json':
+                return this.validateJson(specs);
+            case 'number':
+                return this.validateNumber(specs);
+            case 'select':
+                return this.validateSelect(specs);
+            case 'url':
+                return this.validateUrl(specs);
+            default:
+                throw new Error(`Unknown field type: ${type}`);
+        }
+    }
+    static validateAllFields(fields) {
+        const results = {};
+        const allKeys = fields.map((field) => field.item.key);
+        fields.forEach((field) => results[field.item.key] = handleKey(field, allKeys));
+        const finalResult = getFinalResult(results);
+        if (!finalResult.ok) {
+            const err = new Error(`Schema validation failed. ${finalResult.errorsString}`);
+            err.code = 400;
+            throw err;
+        }
+        return true;
+    }
+}
+export default FieldValidator;

package/dist/kz-schema-factory/SchemaFactory.d.ts

@@ -0,0 +1,46 @@
+import TableFieldBoolean from './types-constructors/boolean.js';
+import TableFieldDate from './types-constructors/date.js';
+import TableFieldEmail from './types-constructors/email.js';
+import TableFieldJson from './types-constructors/json.js';
+import TableFieldNumber from './types-constructors/number.js';
+import TableFieldSelect from './types-constructors/select.js';
+import TableFieldString from './types-constructors/string.js';
+import TableFieldUrl from './types-constructors/url.js';
+import type { BooleanSpecs, DateSpecs, EmailSpecs, JsonSpecs, NumberSpecs, SelectSpecs, StringSpecs, UrlSpecs } from './types.js';
+export type TableFieldAny = TableFieldBoolean | TableFieldDate | TableFieldEmail | TableFieldJson | TableFieldNumber | TableFieldSelect | TableFieldString | TableFieldUrl;
+type IndexItem = {
+    key: string;
+    isUnique: boolean;
+};
+export type TableField<T> = {
+    id: string;
+    order: number;
+    isAuto?: boolean;
+    item: T;
+};
+declare class CollectionConfig {
+    items: TableField<TableFieldAny>[];
+    totalQty: number;
+    indexes: Array<IndexItem>;
+    constructor(items?: TableField<TableFieldAny>[]);
+    add(item: TableFieldAny): void;
+    copyById(id: string): void;
+    remove(order: number): void;
+    removeById(id: string): void;
+    updateNameById(id: string, name: string): void;
+    updateSpecsById(id: string, newSpecs: TableFieldAny['specs']): void;
+    move(from: number, to: number): void;
+}
+export declare class TableFieldCreator {
+    static create(key: string, type: string, settings?: unknown): TableFieldBoolean | TableFieldDate | TableFieldEmail | TableFieldJson | TableFieldNumber | TableFieldSelect | TableFieldString | TableFieldUrl;
+    static createBoolean(key: string, settings: Partial<BooleanSpecs>): TableFieldBoolean;
+    static createString(key: string, settings?: Partial<StringSpecs>): TableFieldString;
+    static createNumber(key: string, settings?: Partial<NumberSpecs>): TableFieldNumber;
+    static createDate(key: string, settings?: Partial<DateSpecs>): TableFieldDate;
+    static createEmail(key: string, settings?: Partial<EmailSpecs>): TableFieldEmail;
+    static createJson(key: string, settings?: Partial<JsonSpecs>): TableFieldJson;
+    static createSelect(key: string, settings?: Partial<SelectSpecs>): TableFieldSelect;
+    static createUrl(key: string, settings?: Partial<UrlSpecs>): TableFieldUrl;
+}
+export default CollectionConfig;
+//# sourceMappingURL=SchemaFactory.d.ts.map

package/dist/kz-schema-factory/SchemaFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaFactory.d.ts","sourceRoot":"","sources":["../../src/kz-schema-factory/SchemaFactory.ts"],"names":[],"mappings":"AACA,OAAO,iBAAiB,MAAM,iCAAiC,CAAA;AAC/D,OAAO,cAAc,MAAM,8BAA8B,CAAA;AACzD,OAAO,eAAe,MAAM,+BAA+B,CAAA;AAC3D,OAAO,cAAc,MAAM,8BAA8B,CAAA;AACzD,OAAO,gBAAgB,MAAM,gCAAgC,CAAA;AAC7D,OAAO,gBAAgB,MAAM,gCAAgC,CAAA;AAC7D,OAAO,gBAAgB,MAAM,gCAAgC,CAAA;AAC7D,OAAO,aAAa,MAAM,6BAA6B,CAAA;AACvD,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,QAAQ,EACT,MAAM,YAAY,CAAA;AAGnB,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB,cAAc,GACd,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,aAAa,CAAA;AAEjB,KAAK,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAA;AAEnD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,CAAC,CAAA;CACR,CAAA;AAED,cAAM,gBAAgB;IACpB,KAAK,EAAE,UAAU,CAAC,aAAa,CAAC,EAAE,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;gBAEb,KAAK,GAAE,UAAU,CAAC,aAAa,CAAC,EAAO;IAMnD,GAAG,CAAC,IAAI,EAAE,aAAa;IAOvB,QAAQ,CAAC,EAAE,EAAE,MAAM;IAcnB,MAAM,CAAC,KAAK,EAAE,MAAM;IAKpB,UAAU,CAAC,EAAE,EAAE,MAAM;IAKrB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAKvC,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC;IAK5D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;CAuB9B;AAED,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAY;IAuB/D,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC;IAIjE,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,WAAW,CAAM;IAIpE,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,WAAW,CAAM;IAIpE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,SAAS,CAAM;IAIhE,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,UAAU,CAAM;IAIlE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,SAAS,CAAM;IAIhE,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,WAAW,CAAM;IAIpE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM;CAG/D;AAED,eAAe,gBAAgB,CAAA"}