vrack2-core 0.0.1 → 1.0.1

package/lib/validator/Validator.d.ts

@@ -3,12 +3,57 @@ import CoreError from "../errors/CoreError";
 import IValidationProblem from './IValidationProblem';
 import IValidationRule from "./IValidationRule";
 export default class Validator {
+    /**
+     * Validation of the object by rule.
+     * You cannot validate a specific value.
+     * You can only validate an object property.
+     *
+     * For validation you need to create an object with rules
+     *
+     * ```ts
+     * const rules = {
+     *    bool: Rule.boolean().require().default(true).description('Boolean checkbox')
+     * }
+     * ```
+     *
+     * After validating the object with the same properties
+     *
+     * ```
+     * Validator.validate(rules, { bool: 'not a boolean value?'})
+     * ```
+     *
+     * @param rules List of rules like a associate object
+     * @param data Data object for validate
+    */
     static validate(rules: {
         [key: string]: BasicType;
     }, data: {
         [key: string]: any;
     }): boolean;
-    private static makeError;
-    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule): IValidationProblem;
-    private static getClass;
+    /**
+     * Creates a top-level error for validation problems
+     *
+     * @param eList List of validation errors
+    */
+    protected static makeError(eList: Array<IValidationProblem>): void;
+    /**
+     * Create validation problem
+     *
+     * @param err Validation exception
+     * @param key key for getting value from object
+     * @param rule Checked rule
+    */
+    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule, value: any): IValidationProblem;
+    /**
+     * Make message use message template
+     *
+     * If you want to change the default message, you can use a template in the message parameter
+     *
+     * @example
+     * ```js
+     *  Rule.number().description('My number').message('{description} must by 1,2,3,4,5,6... not {value}')
+     * ```
+    */
+    protected static makeMessage(rule: IValidationRule, value: any): string;
+    protected static toInspect(value: any): any;
 }

package/lib/validator/Validator.js

@@ -7,51 +7,103 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
 const ErrorManager_1 = __importDefault(require("../errors/ErrorManager"));
-const ArrayType_1 = __importDefault(require("./types/ArrayType"));
-const NumberType_1 = __importDefault(require("./types/NumberType"));
-const ObjectType_1 = __importDefault(require("./types/ObjectType"));
-const StringType_1 = __importDefault(require("./types/StringType"));
 const CoreError_1 = __importDefault(require("../errors/CoreError"));
 ErrorManager_1.default.register('Validator', 'VXLeMLVnIXGf', 'VR_TYPE_NOT_EXISTS', 'Type not exists', {});
 ErrorManager_1.default.register('Validator', 'X1UP4P2HRHWd', 'VR_NOT_PASS', 'Validation error - data not pass', {});
 class Validator {
+    /**
+     * Validation of the object by rule.
+     * You cannot validate a specific value.
+     * You can only validate an object property.
+     *
+     * For validation you need to create an object with rules
+     *
+     * ```ts
+     * const rules = {
+     *    bool: Rule.boolean().require().default(true).description('Boolean checkbox')
+     * }
+     * ```
+     *
+     * After validating the object with the same properties
+     *
+     * ```
+     * Validator.validate(rules, { bool: 'not a boolean value?'})
+     * ```
+     *
+     * @param rules List of rules like a associate object
+     * @param data Data object for validate
+    */
     static validate(rules, data) {
         const problems = [];
         for (const key of Object.keys(rules)) {
             const rule = rules[key];
-            const ruleRaw = rule.export();
-            const cs = Validator.getClass(ruleRaw.type);
             try {
-                cs.validate(data, key, ruleRaw);
+                rule.validate(data, key);
             }
             catch (err) {
                 if (err instanceof CoreError_1.default)
-                    problems.push(Validator.makeProblem(err, key, ruleRaw));
+                    problems.push(Validator.makeProblem(err, key, rule.export(), data[key]));
             }
         }
         if (problems.length)
             Validator.makeError(problems);
         return true;
     }
+    /**
+     * Creates a top-level error for validation problems
+     *
+     * @param eList List of validation errors
+    */
     static makeError(eList) {
         throw ErrorManager_1.default.make('VR_NOT_PASS', {
             problems: eList
         });
     }
-    static makeProblem(err, key, rule) {
-        return {
-            type: err.vShort, code: err.vCode, description: err.message, rule, arg: err.vAdd
+    /**
+     * Create validation problem
+     *
+     * @param err Validation exception
+     * @param key key for getting value from object
+     * @param rule Checked rule
+    */
+    static makeProblem(err, key, rule, value) {
+        if (rule.message)
+            err.message = this.makeMessage(rule, value);
+        const nvp = {
+            type: err.vShort, code: err.vCode, fieldKey: key, description: err.message, rule, arg: {}
         };
+        for (const sk of err.vAdd)
+            nvp.arg[sk] = err[sk];
+        return nvp;
     }
-    static getClass(cn) {
-        switch (cn) {
-            case 'string': return StringType_1.default;
-            case 'number': return NumberType_1.default;
-            case 'object': return ObjectType_1.default;
-            case 'array': return ArrayType_1.default;
+    /**
+     * Make message use message template
+     *
+     * If you want to change the default message, you can use a template in the message parameter
+     *
+     * @example
+     * ```js
+     *  Rule.number().description('My number').message('{description} must by 1,2,3,4,5,6... not {value}')
+     * ```
+    */
+    static makeMessage(rule, value) {
+        let message = rule.message;
+        const val = Validator.toInspect(value);
+        const example = Validator.toInspect(rule.example);
+        const def = Validator.toInspect(rule.default);
+        message.replace('{value}', val);
+        message.replace('{example}', example);
+        message.replace('{default}', def);
+        message.replace('{description}', rule.description);
+        return message;
+    }
+    static toInspect(value) {
+        if (typeof value === "object" || typeof value === "function") {
+            return util_1.default.inspect(value, { showHidden: false, depth: null, compact: false });
         }
-        throw ErrorManager_1.default.make('VR_TYPE_NOT_EXISTS', { type: cn });
+        return value;
     }
 }
 exports.default = Validator;

package/lib/validator/types/AnyType.d.ts

@@ -0,0 +1,17 @@
+import BasicType from "./BasicType";
+export default class AnyType extends BasicType {
+    constructor();
+    /**
+     * Setting the default value
+    */
+    default(def: any): this;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
+        [key: string]: any;
+    }, key: string): boolean;
+}

package/lib/validator/types/AnyType.js

@@ -0,0 +1,34 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+class AnyType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'any';
+    }
+    /**
+     * Setting the default value
+    */
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
+        return true;
+    }
+}
+exports.default = AnyType;

package/lib/validator/types/ArrayType.d.ts

@@ -1,14 +1,47 @@
-import IValidationRule from "../IValidationRule";
 import BasicType from "./BasicType";
 import IValidationSubrule from "../IValidationSubrule";
 export default class ArrayType extends BasicType {
     constructor();
+    /**
+     * Setting the default value
+    */
     default(def: Array<any>): this;
+    /**
+     * Sets the rule to be applied to each element of the array
+     *
+     * @example
+     *
+     * ```
+     * Rule.array().require().content(
+     *    Rule.string().default('').maxLength(24).description('Element of list')
+     * )
+     * ```
+     *
+    */
     content(t: BasicType): this;
-    static validate(obj: {
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex: Array<any>): this;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): boolean;
-    protected static checkContent(obj: {
+    }, key: string): boolean;
+    /**
+     * Checks the rules for content inside the array
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+     * @param sub Sub rule for check array content
+    */
+    protected checkContent(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
 }

package/lib/validator/types/ArrayType.js

@@ -16,28 +16,64 @@ class ArrayType extends BasicType_1.default {
         super();
         this.rule.type = 'array';
     }
+    /**
+     * Setting the default value
+    */
     default(def) {
         this.rule.default = def;
         return this;
     }
+    /**
+     * Sets the rule to be applied to each element of the array
+     *
+     * @example
+     *
+     * ```
+     * Rule.array().require().content(
+     *    Rule.string().default('').maxLength(24).description('Element of list')
+     * )
+     * ```
+     *
+    */
     content(t) {
         this.rule.rules.push({ name: 'contain', args: t });
         return this;
     }
-    static validate(obj, key, rule) {
-        BasicType_1.default.validate(obj, key, rule);
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
         if (!Array.isArray(obj[key]))
             throw ErrorManager_1.default.make('VR_IS_NOT_ARRAY', {});
-        for (const subrule of rule.rules) {
+        for (const subrule of this.rule.rules) {
             switch (subrule.name) {
                 case 'fields':
-                    ArrayType.checkContent(obj, key, subrule);
-                    break;
+                    this.checkContent(obj, key, subrule);
             }
         }
         return true;
     }
-    static checkContent(obj, key, sub) {
+    /**
+     * Checks the rules for content inside the array
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+     * @param sub Sub rule for check array content
+    */
+    checkContent(obj, key, sub) {
         const sw = { value: undefined };
         const tr = { value: sub.args };
         for (const index of obj[key]) {

package/lib/validator/types/BasicType.d.ts

@@ -3,16 +3,76 @@ export default class BasicType {
     protected rule: IValidationRule;
     constructor();
     require(): this;
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
     example(ex: any): this;
+    /**
+     * Description of the validated object property
+     *
+     * @param desc
+    */
     description(desc: string): this;
-    export(): IValidationRule;
-    static validate(obj: {
+    /**
+      * Make message use message template
+      *
+      * If you want to change the default message, you can use a template in the message parameter
+      *
+      * @example
+      * ```js
+      *  Rule.number().description('My number').message('{description} must by 1,2,3,4,5,6... not {value}')
+      * ```
+      * Use {description} {value} {default} {example} in template
+     */
+    message(mess: string): this;
+    /**
+     * Exporting a rule for use
+     * Typically used within VRack or VRack-Core
+     *
+     * !!! hide for external users !!!
+     * @private
+    */
+    export(): any;
+    /**
+     * This method will be executed when converting a Rule object to JSON
+    */
+    toJSON(): IValidationRule;
+    /**
+     * Performs general validation rules
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    protected basicValidate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): boolean;
-    protected static checkDefault(obj: {
+    }, key: string): boolean;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): void;
-    protected static checkRequire(obj: {
+    }, key: string): boolean;
+    /**
+     * Sets the default value if it has not been set
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    protected checkDefault(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): void;
+    }, key: string): void;
+    /**
+     * Checks if the initialized property of an object
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    protected checkRequire(obj: {
+        [key: string]: any;
+    }, key: string): void;
 }

package/lib/validator/types/BasicType.js

@@ -16,36 +16,102 @@ class BasicType {
             default: undefined,
             rules: [],
             example: undefined,
-            description: ''
+            description: '',
+            message: '',
         };
     }
     require() {
         this.rule.require = true;
         return this;
     }
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
     example(ex) {
         this.rule.example = ex;
         return this;
     }
+    /**
+     * Description of the validated object property
+     *
+     * @param desc
+    */
     description(desc) {
         this.rule.description = desc;
         return this;
     }
+    /**
+      * Make message use message template
+      *
+      * If you want to change the default message, you can use a template in the message parameter
+      *
+      * @example
+      * ```js
+      *  Rule.number().description('My number').message('{description} must by 1,2,3,4,5,6... not {value}')
+      * ```
+      * Use {description} {value} {default} {example} in template
+     */
+    message(mess) {
+        this.rule.message = mess;
+        return this;
+    }
+    /**
+     * Exporting a rule for use
+     * Typically used within VRack or VRack-Core
+     *
+     * !!! hide for external users !!!
+     * @private
+    */
     export() {
+        return JSON.parse(JSON.stringify(this.rule));
+    }
+    /**
+     * This method will be executed when converting a Rule object to JSON
+    */
+    toJSON() {
         return this.rule;
     }
-    static validate(obj, key, rule) {
-        BasicType.checkDefault(obj, key, rule);
-        BasicType.checkRequire(obj, key, rule);
+    /**
+     * Performs general validation rules
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    basicValidate(obj, key) {
+        this.checkDefault(obj, key);
+        this.checkRequire(obj, key);
+        return true;
+    }
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
         return true;
     }
-    static checkDefault(obj, key, rule) {
-        if (rule.default === undefined)
+    /**
+     * Sets the default value if it has not been set
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    checkDefault(obj, key) {
+        if (this.rule.default === undefined)
             return;
         if (obj[key] === undefined)
-            obj[key] = rule.default;
+            obj[key] = this.rule.default;
     }
-    static checkRequire(obj, key, rule) {
+    /**
+     * Checks if the initialized property of an object
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    checkRequire(obj, key) {
         if (obj[key] === undefined)
             throw ErrorManager_1.default.make('VR_ERROR_REQUAERED', { key });
     }

package/lib/validator/types/BooleanType.d.ts

@@ -0,0 +1,23 @@
+import BasicType from "./BasicType";
+export default class BooleanType extends BasicType {
+    constructor();
+    /**
+     * Setting the default value
+    */
+    default(def: boolean): this;
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex: boolean): this;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
+        [key: string]: any;
+    }, key: string): boolean;
+}

package/lib/validator/types/BooleanType.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+class BooleanType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'boolean';
+    }
+    /**
+     * Setting the default value
+    */
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
+        if (typeof obj[key] !== 'boolean')
+            throw ErrorManager_1.default.make('VR_IS_NOT_BOOLEAN', { key });
+        return true;
+    }
+}
+exports.default = BooleanType;
+ErrorManager_1.default.register('Validator', 'Fr7BvAlZyZPm', 'VR_IS_NOT_BOOLEAN', 'Value must be a number', {});

package/lib/validator/types/FunctionType.d.ts

@@ -0,0 +1,17 @@
+import BasicType from "./BasicType";
+export default class FunctionType extends BasicType {
+    constructor();
+    /**
+     * Setting the default value
+    */
+    default(def: () => any): this;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
+        [key: string]: any;
+    }, key: string): boolean;
+}

package/lib/validator/types/FunctionType.js

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+class FunctionType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'function';
+    }
+    /**
+     * Setting the default value
+    */
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
+        if (typeof obj[key] !== 'function')
+            throw ErrorManager_1.default.make('VR_IS_NOT_FUNCTION', { key });
+        return true;
+    }
+}
+exports.default = FunctionType;
+ErrorManager_1.default.register('Validator', 'P2K7PE7C3JRU', 'VR_IS_NOT_FUNCTION', 'Value must be a function', {});