Code coverage report for build/validator.js

Statements: 100% (52 / 52)      Branches: 97.37% (37 / 38)      Functions: 100% (6 / 6)      Lines: 100% (49 / 49)      Ignored: none     

All files » build/ » validator.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103              1       1 3 13 13 20   3 1   2       17 17       17   17 27 27 26   1   26 1   25 10 10 10     25     17 22 22 6 11 11 11     16   20     17 17 22 15   15 15       17 17 7       15   5 1   4     10                     3     1
/**
 * @fileOverview redux validator middleware
 * @author Max
 **/
 
'use strict';
 
Object.defineProperty(exports, '__esModule', {
    value: true
});
 
exports['default'] = function (options) {
    var validatorMiddleware = function validatorMiddleware(store) {
        return function (next) {
            return function (action) {
                if (!action[options.validatorKey] || !action[options.validatorKey].validator) {
                    // thunk compatible
                    if (action[options.paramKey] && action[options.paramKey].thunk) {
                        return next(action[options.paramKey].thunk);
                    } else {
                        return next(action);
                    }
                }
 
                var flag = true;
                var errorParam = undefined,
                    errorId = undefined,
                    errorMsg = undefined;
 
                var validators = action[options.validatorKey].validator || {};
 
                var runValidator = function runValidator(param, func, msg, id, key) {
                    var flag = undefined;
                    if (func) {
                        flag = func(param, store.getState(), action.payload);
                    } else {
                        throw new Error('validator func is needed');
                    }
                    if (typeof flag !== 'boolean') {
                        throw new Error('validator func must return boolean type');
                    }
                    if (!flag) {
                        errorParam = key;
                        errorId = id;
                        errorMsg = msg || '';
                    }
 
                    return flag;
                };
 
                var runValidatorContainer = function runValidatorContainer(validator, param, key) {
                    var flag = undefined;
                    if (Array.prototype.isPrototypeOf(validator)) {
                        for (var j in validator) {
                            var item = validator[j];
                            flag = runValidator(param, item.func, item.msg, j, key);
                            if (!flag) break;
                        }
                    } else {
                        flag = runValidator(param, validator.func, validator.msg, 0, key);
                    }
                    return flag;
                };
 
                var params = action[options.paramKey] || {};
                for (var i in validators) {
                    if (i === options.paramKey) continue;
                    var validator = validators[i];
 
                    flag = runValidatorContainer(validator, params[i], i);
                    if (!flag) break;
                }
 
                // param object itself
                var paramObjValidator = validators[options.paramKey];
                if (paramObjValidator && flag) {
                    flag = runValidatorContainer(paramObjValidator, action[options.paramKey], options.paramKey);
                }
                // -------
 
                if (flag) {
                    // thunk compatible
                    if (action[options.paramKey] && action[options.paramKey].thunk) {
                        return next(action[options.paramKey].thunk);
                    } else {
                        return next(action);
                    }
                } else {
                    return {
                        err: 'validator',
                        msg: errorMsg,
                        param: errorParam,
                        id: errorId
                    };
                }
            };
        };
    };
 
    return validatorMiddleware;
};
 
module.exports = exports['default'];