validator.js

/**
 * Validator
 *
 * @module      :: Validator
 * @description :: Contains helper for validation.
 * @requires Validator https://github.com/chriso/node-validator
 */
var validator = require('validator');

module.exports = {
    /**
     * @name        check
     * @desc        Check an entire object using Validator module.
     * @param       params {Object|Array} Rules to checks. If required doesn't exists then params is used like the required array. (
                        required {Array} Contains all arrays of rules which are REQUIRED and must not be empty or null.
                        optional {Array} Contains all arrays of rules which are OPTIONAL and can be empty or null. One of them array is described below: (Use the same array than the [required] field)
                            value {*} The value to check.
                            key {string} The key in the model. If you don't want to link the field to a model, set it to FALSE. (Can be used for group errors on the same field too)
                            rules {Array} Array of Objects:
                                function {string} Function to execute. See https://github.com/chriso/node-validator for the entire list.
                                message {string} Message to send if one error appends on this rule.
                                args {Array} Array of values which contains all parameters. Useful only for methods which need parameters like len, regex, min, max, etc.
     * @param       callback {Function} Function to execute after validation, if you don't then the script will return the validation object.
     * @param       res {Result object} If res is provides and if at least one error appends then an automatic response will be send using res.json method. If it doesn't you have to manage error message return by your own.
     * @returns     {{errors: {messages: Array, status: boolean}, typeError: 'V', keysModelChecked: {}, keysChecked: {}}} Return or data passed in the callback:
                        errors {Array}
                            messages {Array} Contains an array of all errors found.
                                key {string|false} Key of the error, could be one key of the database model. (Useful for dynamic create/update)
                                message {string} Message to display.
                            status {boolean} If true, at least one error occurred.
                        keysModelChecked {Object} Contains [key: value] which belong to a model and were checked.
                        keysChecked {Object} Contains all [key: value] other checked keys.

     * @author      Vadorequest
     *
     * @example     Callback and res provided
                        __validator.check([
                            __validator.rulesUserEmail(req.params.email),
                            __validator.rulesUserPasswordProtected(req.params.password)
                        ], function(errors, keysModelChecked, keysChecked){
                            // Do what you want, it's secure because if error appends there will be automatic response. (res provided and auto return if it error occurred)
                        }, res);

     * @example     Callback and res don't provided
                        __validator.check([
                            __validator.rulesUserEmail(req.params.email),
                            __validator.rulesUserPasswordProtected(req.params.password)
                        ], function(errors, keysModelChecked, keysChecked){
                            // You have to check for errors by your own.
                            if(errors.status){
                                // No error occurred.
                            }else{
                                // Error occurred.
                            }
                        });

     * @example     No callback - You shouldn't use this way
                        var validation = __validator.check([
                            __validator.rulesUserEmail(req.params.email),
                            __validator.rulesUserPasswordProtected(req.params.password)
                        ]);

     * @example     Use optional field check with res provided
                        __validator.check({
                            required: [
                                __validator.rulesUserSessionId(req.session.user.id)
                            ],
                            optional: [
                                __validator.rulesUserEmail(req.param('email')),
                                __validator.rulesUserPasswordProtected(req.param('password'))
                            ]
                        }, function(errors, keysModelChecked, keysChecked){
                            // No error occurred. (res provided and auto return if it error occurred)
                            // keysModelChecked will contains password and email, but only if they wasn't null or empty.
                            // You can use [!_.isEmpty(keysModelChecked)] for be sure at least one value was passed.
                            // You can use [dbHelper.merge(model, keysModelChecked)] for merge the keysModelChecked with a model dynamically without check for each field if you have to update it.
                        }, res);
     */
    check: function(params, callback, res){
        // Contains params checked with values, useful for insert/update queries.
        var keysModelChecked = {};

        // Contains all other non model keys checked.
        var keysChecked = {};

        // Contains only params to check.
        var paramsToCheck = params.required ? params.required : params;

        // Add not null params to paramsToCheck if wanted.
        if(params.optional){
            for (var i = 0; i < params.optional.length; i++){
                // If the value is not null or undefined
                if(params.optional[i].value && params.optional[i].value != null && params.optional[i].value != undefined){
                    paramsToCheck.push(params.optional[i])
                }
            }
        }

        // Errors handler.
        var validatorMessage = new __validatorMessage();

        // Check each rule.
        for(var i = 0; i < paramsToCheck.length; i++){
            var value = paramsToCheck[i].value;
            var key = (paramsToCheck[i].key !== false ? (paramsToCheck[i].key ? paramsToCheck[i].key : 'undefined'+i) : false);// If false, keep false, else try to get the defined value, if no one then create a dynamic key.
            var rule = paramsToCheck[i].rules;
            var model = paramsToCheck[i].model;

            // Check every rules.
            for(var j = 0; j < rule.length; j++){
                try{
                    var validation = validator.check(value, rule[j].message);

                    // If we use our custom object, use it instead of the default Validator message. (Their lib will replace our object by the default message)
                    if(validation.msg == null && typeof rule[j].message !== 'string'){
                        validation.msg = rule[j].message;
                    }

                    // Apply parameters if exist.
                    if(rule[j].args){
                        validation[rule[j].function].apply(validation, rule[j].args);
                    }else{
                        validation[rule[j].function]();
                    }
                }catch(e){
                    // When an exception is raise that means there is a validation error. (Or real exception!)
                    validatorMessage.addError( e.message ? e.message : e, key, rule[j].args);
                }
            }

            // Add the key=>value to the keys that belong to a model.
            if(key !== false && model === true){
                keysModelChecked[key] = value;
            }else if(key !== false){
                // Add the key=>value to the other keys, that don't belong to a model.
                keysChecked[key] = value;
            }
        }

        // If res is provided, callback has to be call and if an error appends then we don't do it! Use res for send a response with errors.
        if(res && !validatorMessage.getStatus() && callback){
            return res.json(__format.response(validatorMessage));
        }else{
            // Bind the data into the validatorMessage anyway.
            validatorMessage.addData('keysModelChecked', keysModelChecked);
            validatorMessage.addData('keysChecked', keysChecked);

            // Do callback or return results.
            if(callback){
                // Send also the keys avoid a request on the validatorMessage each time to get them.
                return callback(validatorMessage, keysModelChecked, keysChecked);
            }else{
                return validatorMessage;
            }
        }
    },

    /**
     * ********************************************************************************
     * ********************************* Default rules ********************************
     * ********************************************************************************
     */

    /**
     * Default comportment for Folder name field.
     */
    rulesFolderName: function(value){
        var minLength = 4;
        var maxLength = 16;

        return {
            value: value,
            key: 'folderName',
            model: false,
            rules: [{
                function: 'notEmpty',
                message: 'Folder Name is required.'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: {
                    "m": "__10_11",
                    "a": [minLength, maxLength]
                }
            },{
                function: 'regex',
                args: ['^[a-zA-Z0-9 _-]{'+minLength+','+maxLength+'}$', 'i'],
                message: 'The folder name must be contains only letters, numbers and "-". Nothing else.'
            }]
        };
    },

    /**
     * Default comportment for Resource name field.
     * @param       value {string}
     */
    rulesResourceName: function(value){
        var minLength = 4;
        var maxLength = 20;

        return {
            value: value,
            key: 'resourceName',
            model: false,
            rules: [{
                function: 'notEmpty',
                message: 'Folder Name is required.'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: {
                    "m": "__10_11",
                    "a": [minLength, maxLength]
                }
            },{
                function: 'regex',
                args: ['^[a-zA-Z0-9 _-]{'+minLength+','+maxLength+'}$', 'i'],
                message: 'The folder name must be contains only letters, numbers and "-". Nothing else.'
            }]
        };
    },

    /**
     * Default comportment for World name field.
     */
    rulesWorldName: function(value){
        var minLength = 4;
        var maxLength = 20;

        return {
            value: value,
            key: 'worldName',
            model: false,
            rules: [{
                function: 'notEmpty',
                message: 'Folder Name is required.'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: {
                    "m": "__10_11",
                    "a": [minLength, maxLength]
                }
            },{
                function: 'regex',
                args: ['^[a-zA-Z0-9 _-]{'+minLength+','+maxLength+'}$', 'i'],
                message: 'The World name must be contains only letters, numbers and "-". Nothing else.'
            }]
        };
    },

    /**
     * Default comportment for user session ID.
     * @param       value {*}
     * @returns     {{value: *, key: *, rules: Array}}
     */
    rulesUserSessionId: function(value){
        return {
            value: value,
            key: 'userSessionId',
            model: false,
            rules: [{
                function: 'notEmpty',
                message: 'Your user session id is empty.'
            }]
        };
    },

    /**
     * Default comportment for Database auto-generated ID field.
     * @param       value {*}
     * @param       key {string} Key to use for auto bind the field to a model field.
     * @param       messageEmpty {string} Message to display if the value is empty.
     * @returns     {{value: *, key: string, rules: Array}}
     */
    rulesId: function(value, key, messageEmpty){
        var minLength = 24;
        var maxLength = 30;

        return {
            value: value,
            key: key ? key : false,// Don't link to the model if the key is not defined.
            model: true,
            rules: [{
                function: 'notEmpty',
                message: messageEmpty ? messageEmpty : 'An ID is empty.'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: 'The length of an ID must be more than '+minLength+' characters.'
            }]
        };
    },

    /**
     * Default comportment for Database auto-query limit field.
     * @param       value {int}
     * @returns     {{value: *, key: *, rules: Array}}
     */
    rulesLimit: function(value){
        var min = 1;

        return {
            value: value,
            key: 'limit',
            model: true,
            rules: [{
                function: 'isInt',
                message: 'The limit must be an integer.'
            }, {
                function: 'min',
                args: [min],
                message: 'The min limit value is '+min+'.'
            }]
        };
    },

    /**
     * Useful in some cases for add a field without check.
     * @param       value {*}
     * @param       key {string} Key to use for auto bind the field to a model field.
     * @param       model {boolean} Key to use for auto bind the field to a model field.
     * @returns     {{value: *, key: *, rules: Array}}
     */
    rulesEmpty: function(value, key, model){
        return {
            value: value,
            key: key ? key : false,// Don't link to the model if the key is not defined.
            model: model ? model : false,
            rules: []
        };
    },

    /**
     * ********************************************************************************
     * ********************** Custom your own default rules ***************************
     * ********************************************************************************
     */

    /**
     * Default comportment for Login field.
     * @param       value {string}
     * @returns     {{value: *, key: string, rules: Array}}
     */
    rulesUserLogin: function(value){
        var minLength = __Dao.getSchema('user').login.check.minLength;
        var maxLength = __Dao.getSchema('user').login.check.maxLength;

        return {
            value: value,
            key: 'login',
            model: true,
            rules: [{
                function: 'notEmpty',
                message: '__2'
            },{
                function: 'regex',
                args: ['^[a-zA-Z0-9_-]{'+minLength+','+maxLength+'}$', 'i'],
                message: '__1'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: {
                    "m": "__12",
                    "a": [minLength, maxLength]
                }
            }]
        };
    },

    /**
     * Default comportment for email field.
     * @param       value {string}
     * @returns     {{value: *, key: string, rules: Array}}
     * TODO Use a local instance of user instead of several loads.
     */
    rulesUserEmail: function(value){
        var minLength = __Dao.getSchema('user').email.check.minLength;
        var maxLength = __Dao.getSchema('user').email.check.maxLength;

        return {
            value: value,
            key: 'email',// Must be the key in the Model.
            model: true,
            rules: [{
                function: 'notEmpty',
                message: '__10_14'
            },{
                function: 'len',
                args: [minLength, maxLength],
                message: {
                    "m": "__10_11",
                    "a": [minLength, maxLength]
                }
            },{
                function: 'isEmail',
                message: '__10_13'
            }]
        };
    },

    /**
     * Default comportment for password field.
     * @param       value {string}
     * @returns     {{value: *, key: string, rules: Array}}
     */
    rulesUserPasswordProtected: function(value){
        var minLength = __Dao.getSchema('user').passwordProtected.check.minLength;
        //var maxLength = __Dao.getSchema('user').password.maxLength;

        return {
            value: value,
            key: 'password',// Must be the key in the Model.
            model: true,
            rules: [{
                function: 'notEmpty',
                message: '__8'
            },{
                function: 'len',
                args: [63, 65],
                message: "__13"
            }]
        };
    }
};