vrack2-core 0.0.1 → 1.0.0

package/src/validator/Validator.ts

@@ -3,14 +3,10 @@
  * Licensed under the Apache License, Version 2.0
 */
 
-import ErrorManager from "../errors/ErrorManager";
+import util from "util"
 
-import ArrayType from "./types/ArrayType";
+import ErrorManager from "../errors/ErrorManager";
 import BasicType from "./types/BasicType";
-import NumberType from "./types/NumberType";
-import ObjectType from "./types/ObjectType";
-import StringType from "./types/StringType";
-
 import CoreError from "../errors/CoreError";
 import IValidationProblem from './IValidationProblem';
 import IValidationRule from "./IValidationRule";
@@ -26,42 +22,97 @@ ErrorManager.register(
 })
 
 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 {
         const problems: Array<IValidationProblem> = []
         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) problems.push(Validator.makeProblem(err, key, ruleRaw))
+                if (err instanceof CoreError) problems.push(Validator.makeProblem(err, key, rule.export(), data[key]))
             }
         }
         if (problems.length) Validator.makeError(problems)
         return true;
     }
 
-    private static makeError(eList: Array<IValidationProblem>){
+    /**
+     * Creates a top-level error for validation problems
+     * 
+     * @param eList List of validation errors
+    */
+    protected static makeError(eList: Array<IValidationProblem>){
         throw ErrorManager.make('VR_NOT_PASS', {
             problems: eList
         })
     }
-
-    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule) : IValidationProblem {
-        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
+    */
+    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule, value: any) : IValidationProblem {
+        if (rule.message) err.message = this.makeMessage(rule, value)
+        const nvp:IValidationProblem = {
+            type: err.vShort, code: err.vCode, fieldKey: key, description: err.message, rule, arg: {}
         }
+        for (const sk of err.vAdd) nvp.arg[sk] = err[sk as keyof CoreError]
+        return nvp
+    }
+
+    /**
+     * 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 {
+        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
     }
 
-    private static getClass(cn : string){
-        switch (cn){
-            case 'string': return StringType
-            case 'number': return NumberType
-            case 'object': return ObjectType
-            case 'array': return ArrayType
+    protected static toInspect(value:any){
+        if (typeof value === "object" || typeof value === "function"){
+            return util.inspect(value, { showHidden: false, depth: null, compact: false }) 
         }
-        throw ErrorManager.make('VR_TYPE_NOT_EXISTS', { type: cn })
+        return value
     }
 }

package/src/validator/types/AnyType.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "./BasicType"
+
+export default class AnyType  extends BasicType {
+    constructor() {
+        super()
+        this.rule.type = 'any'
+    }
+
+    /**
+     * Setting the default value
+    */
+    default(def: any) {
+        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: string]: any; }, key: string): boolean {
+        this.basicValidate(obj, key)
+        return true
+    }
+}

package/src/validator/types/ArrayType.ts

@@ -3,7 +3,6 @@
  * Licensed under the Apache License, Version 2.0
 */
 
-import IValidationRule from "../IValidationRule";
 import BasicType from "./BasicType";
 import ErrorManager from "../../errors/ErrorManager"
 import IValidationSubrule from "../IValidationSubrule";
@@ -16,30 +15,67 @@ export default class ArrayType extends BasicType {
         this.rule.type = 'array'
     }
 
+    /**
+     * Setting the default value
+    */
     default(def: Array<any>) {
         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: BasicType) {
         this.rule.rules.push({ name: 'contain', args: t })
         return this
     }
 
-    static validate(obj: { [key: string]: any; }, key: string, rule: IValidationRule): boolean {
-        BasicType.validate(obj, key, rule)
+    /**
+     * Example of a valid value for this rule
+     * 
+     * @param ex Example valid value 
+    */
+    example(ex: Array<any>){
+        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: string]: any; }, key: string): boolean {
+        this.basicValidate(obj, key)
         if (!Array.isArray(obj[key])) throw ErrorManager.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
     }
 
-    protected static checkContent(obj: { [key: string]: any }, key: string, sub: IValidationSubrule) {
+    /**
+     * 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) {
         const sw = { value: undefined }
         const tr = { value: sub.args }
         for (const index of obj[key]) {

package/src/validator/types/BasicType.ts

@@ -16,7 +16,8 @@ export default class BasicType {
             default: undefined,
             rules: [],
             example: undefined,
-            description: ''
+            description: '',
+            message: '',
         }
     }
 
@@ -24,33 +25,101 @@ export default class BasicType {
         this.rule.require = true
         return this
     }
-
+    
+    /**
+     * Example of a valid value for this rule
+     * 
+     * @param ex Example valid value 
+    */
     example(ex: any){
         this.rule.example = ex
         return this
     }
 
+    /**
+     * Description of the validated object property
+     * 
+     * @param desc 
+    */
     description(desc: string){
         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: string){
+        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:string]: any}, key: string, rule: IValidationRule) :boolean {
-        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
+    */
+    protected basicValidate(obj: {[key:string]: any}, key: string) :boolean {
+        this.checkDefault(obj, key)
+        this.checkRequire(obj, key)
         return true;
     }
 
-    protected static checkDefault(obj: {[key:string]: any}, key: string, rule: IValidationRule) {
-        if (rule.default === undefined) return 
-        if (obj[key] === undefined) obj[key] = rule.default
+    /**
+     * 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){
+        return true
+    }
+
+    /**
+     * 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) {
+        if (this.rule.default === undefined) return 
+        if (obj[key] === undefined) obj[key] = this.rule.default
     }
 
-    protected static checkRequire(obj: {[key:string]: any}, key: string, rule: IValidationRule) {
+    /**
+     * 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) {
         if (obj[key] === undefined) throw ErrorManager.make('VR_ERROR_REQUAERED', { key })
     }
 }

package/src/validator/types/BooleanType.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "./BasicType"
+import ErrorManager from "../../errors/ErrorManager"
+
+export default class BooleanType  extends BasicType {
+    constructor() {
+        super()
+        this.rule.type = 'boolean'
+    }
+    
+    /**
+     * Setting the default value
+    */
+    default(def: boolean) {
+        this.rule.default = def
+        return this
+    }
+
+    /**
+     * Example of a valid value for this rule
+     * 
+     * @param ex Example valid value 
+    */
+    example(ex: boolean){
+        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: string]: any; }, key: string): boolean {
+        this.basicValidate(obj, key)
+        if (typeof obj[key] !== 'boolean') throw ErrorManager.make('VR_IS_NOT_BOOLEAN', { key })
+        return true
+    }
+}
+
+ErrorManager.register(
+    'Validator', 'Fr7BvAlZyZPm', 'VR_IS_NOT_BOOLEAN',
+    'Value must be a number', {
+})

package/src/validator/types/FunctionType.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "./BasicType"
+import ErrorManager from "../../errors/ErrorManager"
+
+export default class FunctionType extends BasicType {
+    constructor() {
+        super()
+        this.rule.type = 'function'
+    }
+    
+    /**
+     * Setting the default value
+    */
+    default(def: () => any) {
+        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: string]: any; }, key: string): boolean {
+        this.basicValidate(obj, key)
+        if (typeof obj[key] !== 'function') throw ErrorManager.make('VR_IS_NOT_FUNCTION', { key })
+        return true
+    }
+}
+
+ErrorManager.register(
+    'Validator', 'P2K7PE7C3JRU', 'VR_IS_NOT_FUNCTION',
+    'Value must be a function', {
+})

package/src/validator/types/NumberType.ts

@@ -4,7 +4,6 @@
 */
 
 import BasicType from "./BasicType"
-import IValidationRule from "../IValidationRule";
 import ErrorManager from "../../errors/ErrorManager"
 import IValidationSubrule from "../IValidationSubrule"
 
@@ -14,53 +13,92 @@ export default class NumberType  extends BasicType {
         this.rule.type = 'number'
     }
 
+    /**
+     * Example of a valid value for this rule
+     * 
+     * @param ex Example valid value 
+    */
+    example(ex: number){
+        this.rule.example = ex
+        return this
+    }
+
+    /**
+     * Setting the default value
+    */
     default(def: number) {
         this.rule.default = def
         return this
     }
 
+    /**
+     * Adds an integer check
+    */
     integer(){
         this.rule.rules.push({ name: 'integer', args: {} })
         return this;
     }
 
+    /**
+     * Defines the maximum value for the rule
+    */
     max(max: number) {
         this.rule.rules.push({ name: 'max', args: max })
         return this
     }
 
+    /**
+     * Defines the minimal value for the rule
+    */
     min(min: number) {
-        this.rule.rules.push({ name: 'max', args: min })
+        this.rule.rules.push({ name: 'min', args: min })
         return this
     }
 
-
-    static validate(obj: { [key: string]: any; }, key: string, rule: IValidationRule): boolean {
-        BasicType.validate(obj, key, rule)
+    /**
+     * 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 {
+        this.basicValidate(obj, key)
         if (typeof obj[key] !== 'number') throw ErrorManager.make('VR_IS_NOT_NUMBER', { key })
-        if (!Number.isInteger(obj[key])) throw ErrorManager.make('VR_NUMBER_INTEGER', {})
-        for (const subrule of rule.rules){
+        for (const subrule of this.rule.rules){
             switch (subrule.name){
+                case 'integer':
+                    this.checkInteger(obj, key)
+                    break
                 case 'max':
-                    NumberType.checkMax(obj, key, subrule)
+                    this.checkMax(obj, key, subrule)
                     break
                 case 'min':
-                    NumberType.checkMin(obj, key, subrule)
+                    this.checkMin(obj, key, subrule)
                     break
             }
         }
         return true
     }
 
+    /**
+     *  Checking the maximum value
+    */
+    protected checkMax(obj: {[key:string]: any}, key: string, sub: IValidationSubrule){
+        if (obj[key] > sub.args) throw ErrorManager.make('VR_NUMBER_MAX', { limit: sub.args })
+    }
 
-    protected static checkMax(obj: {[key:string]: any}, key: string, sub: IValidationSubrule){
-        const val = obj[key]
-        if (val.length > sub.args) throw ErrorManager.make('VR_NUMBER_MAX', { limit: sub.args })
+    /**
+     *  Checking the minimal value
+    */
+    protected checkMin(obj: {[key:string]: any}, key: string, sub: IValidationSubrule){
+        if (obj[key] < sub.args) throw ErrorManager.make('VR_NUMBER_MIN', { limit: sub.args })
     }
 
-    protected static checkMin(obj: {[key:string]: any}, key: string, sub: IValidationSubrule){
-        const val = obj[key]
-        if (val.length < sub.args) throw ErrorManager.make('VR_NUMBER_MIN', { limit: sub.args })
+    /**
+     * Integer check
+    */
+    protected checkInteger(obj: {[key:string]: any}, key: string){
+        if (!Number.isInteger(obj[key])) throw ErrorManager.make('VR_NUMBER_INTEGER', {})
     }
 }
 

package/src/validator/types/ObjectType.ts

@@ -4,29 +4,67 @@
 */
 
 import BasicType from "./BasicType"
-import IValidationRule from "../IValidationRule";
 import ErrorManager from "../../errors/ErrorManager"
 import Validator from "../Validator";
 import IValidationSubrule from "../IValidationSubrule";
 import CoreError from "../../errors/CoreError";
 
-export default class ObjectType  extends BasicType {
+export default class ObjectType extends BasicType {
     constructor() {
         super()
         this.rule.type = 'object'
     }
 
-    fields (obj: {[key:string]: BasicType}) {
-        return this.rule.rules.push({ name: 'fields', args: obj })
+
+    /**
+     * Example of a valid value for this rule
+     * 
+     * @param ex Example valid value 
+    */
+    example(ex: any) {
+        this.rule.example = ex
+        return this
+    }
+
+
+    /**
+     * Setting the default value
+    */
+    default(def: object) {
+        this.rule.default = def
+        return this
     }
 
-    static validate(obj: { [key: string]: any; }, key: string, rule: IValidationRule): boolean {
-        BasicType.validate(obj, key, rule)
-        if (typeof obj[key] !== 'object') throw ErrorManager.make('VR_IS_NOT_OBJECT', { })
-        for (const subrule of rule.rules){
-            switch (subrule.name){
+    /**
+     * Rule object for defining properties 
+     *
+     * Allows you to describe the fields of the required object
+     * 
+     * @example
+     * ```ts
+     *  obj: Rule.object().fields({
+     *       bool: Rule.boolean().require().default(true).description('Boolean checkbox')
+     *  }).description('TEst ibject description'),
+     * ```
+    */
+    fields(obj: { [key: string]: BasicType }) {
+        this.rule.rules.push({ name: 'fields', args: obj })
+        return 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 {
+        this.basicValidate(obj, key)
+        if (typeof obj[key] !== 'object') throw ErrorManager.make('VR_IS_NOT_OBJECT', {})
+        for (const subrule of this.rule.rules) {
+            switch (subrule.name) {
                 case 'fields':
-                    ObjectType.subValidate(obj, key, subrule)
+                    this.subValidate(obj, key, subrule)
                     break
             }
         }
@@ -36,11 +74,11 @@ export default class ObjectType  extends BasicType {
     /**
      * Validate object fields 
     */
-    protected static subValidate(obj: {[key:string]: any}, key: string, sub: IValidationSubrule){
+    protected subValidate(obj: { [key: string]: any }, key: string, sub: IValidationSubrule) {
         try {
             Validator.validate(sub.args, obj[key])
-        }catch(error){
-            if (error instanceof CoreError) {
+        } catch (error) {
+            if (error instanceof Error) {
                 throw ErrorManager.make('VR_ERROR_OBJECT_FIELDS', { key }).add(error)
             }
         }
@@ -55,4 +93,4 @@ ErrorManager.register(
 ErrorManager.register(
     'Validator', 'p7qSfRGixV0M', 'VR_ERROR_OBJECT_FIELDS',
     'Error of validation of fields inside the object', {}
-    )
+)