verificator/lib/Validator.js

Client and server-side validation JavaScript library

'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _actions = require('./actions');

var _constants = require('./constants');

var _rules = require('./rules');

var _rules2 = _interopRequireDefault(_rules);

var _deepmerge = require('deepmerge');

var _deepmerge2 = _interopRequireDefault(_deepmerge);

var _reducer = require('./reducer');

var _reducer2 = _interopRequireDefault(_reducer);

var _redux = require('redux');

var _ErrorBag = require('./ErrorBag');

var _ErrorBag2 = _interopRequireDefault(_ErrorBag);

var _Translator = require('./Translator');

var _Translator2 = _interopRequireDefault(_Translator);

var _utils = require('./utils');

var utils = _interopRequireWildcard(_utils);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var RULES = _rules2['default'];
var LOCALE = _constants.DEFAULT_LOCALE;

var Validator = function () {
    function Validator(data, rules) {
        var _this = this;

        var customLocale = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        _classCallCheck(this, Validator);

        this._listeners = [];
        this._rules = {};
        this._store = (0, _redux.createStore)(_reducer2['default'], (0, _redux.applyMiddleware)(function (store) {
            return function (next) {
                return function (action) {
                    var result = next(action);
                    _this._listeners.forEach(function (listener) {
                        return listener(action.type);
                    });
                    return result;
                };
            };
        }));
        this._store.dispatch((0, _actions.setData)(data || {}));
        this.setRules(rules);
        this._errors = new _ErrorBag2['default'](this._store);
        this._translator = new _Translator2['default'](Object.assign({}, LOCALE, { customMessages: customLocale.messages || {}, customAttributes: customLocale.attributes || {} }), this);
    }

    Validator.useLocale = function useLocale(locale) {
        LOCALE = locale || _constants.DEFAULT_LOCALE;
    };

    Validator.extend = function extend(name, validate) {
        if (typeof validate !== 'function') {
            throw new TypeError('The rule [' + name + '] must be a function');
        }
        RULES[name] = validate;
    };

    Validator.prototype.isValidating = function isValidating(attribute) {
        var _store$getState = this._store.getState(),
            validating = _store$getState.validating;

        if (attribute) {
            return Boolean(validating[attribute]);
        }
        return Object.keys(validating).some(function (key) {
            return validating[key];
        });
    };

    Validator.prototype.validateAll = function validateAll() {
        var _store$getState2 = this._store.getState(),
            rules = _store$getState2.rules;

        var attributes = Object.keys(rules);
        this.errors.clear();
        var promises = [];
        for (var _iterator = attributes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var attribute = _ref;

            promises.push(this.validate(attribute));
        }
        return Promise.all(promises).then(function (results) {
            return results.every(function (result) {
                return result;
            });
        });
    };

    Validator.prototype.validate = function validate(attribute) {
        var _this2 = this;

        if (this.isValidating(attribute) || !this._passesOptionalCheck(attribute)) {
            return Promise.resolve(true);
        }
        this._store.dispatch((0, _actions.startValidate)(attribute));
        if (this._errors.has(attribute)) {
            this._errors.remove(attribute);
        }

        var _store$getState3 = this._store.getState(),
            rules = _store$getState3.rules;

        var queue = [];
        for (var _iterator2 = rules[attribute], _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
            }

            var rule = _ref2;

            queue.push(function (a, r) {
                return function (result) {
                    if (result === true) {
                        return _this2._validateRule(a, r);
                    }
                    return result;
                };
            }(attribute, rule));
        }
        return queue.reduce(function (promise, queueFn) {
            return promise.then(queueFn);
        }, Promise.resolve(true)).then(function (result) {
            _this2._store.dispatch((0, _actions.stopValidate)(attribute));
            return result;
        })['catch'](function (e) {
            _this2._store.dispatch((0, _actions.stopValidate)(attribute));
            return e;
        });
    };

    Validator.prototype.setData = function setData(data) {
        var _store$getState4 = this._store.getState(),
            initialRules = _store$getState4.initialRules;

        this._store.dispatch((0, _actions.setData)(data || {}));
        this.setRules(initialRules);
        return this;
    };

    Validator.prototype.getData = function getData() {
        var _store$getState5 = this._store.getState(),
            data = _store$getState5.data;

        return data;
    };

    Validator.prototype.getValue = function getValue(attribute, defaultValue) {
        var _store$getState6 = this._store.getState(),
            data = _store$getState6.data;

        return utils.get(data, attribute, defaultValue);
    };

    Validator.prototype.setRules = function setRules(rules) {
        var _store$getState7 = this._store.getState(),
            data = _store$getState7.data;

        this._store.dispatch((0, _actions.setRules)(data, rules || {}));
        return this;
    };

    Validator.prototype.addRules = function addRules(rules) {
        var _store$getState8 = this._store.getState(),
            initialRules = _store$getState8.initialRules;

        this.setRules((0, _deepmerge2['default'])(initialRules, rules));
        return this;
    };

    Validator.prototype.getRules = function getRules() {
        var _store$getState9 = this._store.getState(),
            rules = _store$getState9.rules;

        return rules;
    };

    Validator.prototype.getPrimaryAttribute = function getPrimaryAttribute(attribute) {
        var _store$getState10 = this._store.getState(),
            implicitAttributes = _store$getState10.implicitAttributes;

        for (var _iterator3 = Object.keys(implicitAttributes), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var unparsed = _ref3;

            if (implicitAttributes[unparsed].indexOf(attribute) > -1) {
                return unparsed;
            }
        }
        return attribute;
    };

    Validator.prototype.subscribe = function subscribe(listener) {
        var _this3 = this;

        if (typeof listener !== 'function') {
            throw new Error('Expected listener to be a function.');
        }
        var isListener = true;
        this._listeners.push(listener);
        return function () {
            if (isListener === false) {
                return;
            }
            isListener = false;
            var index = _this3._listeners.indexOf(listener);
            _this3._listeners.splice(index, 1);
        };
    };

    Validator.prototype.getRule = function getRule(attribute, target) {
        var _store$getState11 = this._store.getState(),
            rules = _store$getState11.rules;

        if (!(attribute in rules)) {
            return null;
        }
        if (typeof target === 'string') {
            target = [target];
        }
        for (var _iterator4 = rules[attribute], _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref4;

            if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                _ref4 = _iterator4[_i4++];
            } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                _ref4 = _i4.value;
            }

            var rule = _ref4;
            var name = rule.name;

            if (target.indexOf(name) > -1) {
                return rule;
            }
        }
        return null;
    };

    Validator.prototype.hasRule = function hasRule(attribute, target) {
        return this.getRule(attribute, target) !== null;
    };

    Validator.prototype.extend = function extend(name, validate) {
        if (typeof validate !== 'function') {
            throw new TypeError('The rule [' + name + '] must be a function');
        }
        this._rules[name] = validate;
        return this;
    };

    Validator.prototype.getImplicitAttributes = function getImplicitAttributes() {
        var _store$getState12 = this._store.getState(),
            implicitAttributes = _store$getState12.implicitAttributes;

        return implicitAttributes;
    };

    Validator.prototype.setCustomMessages = function setCustomMessages(messages) {
        this._translator.setCustomMessages(messages);
        return this;
    };

    Validator.prototype.addCustomMessages = function addCustomMessages(messages) {
        this._translator.addCustomMessages(messages);
        return this;
    };

    Validator.prototype.setAttributeNames = function setAttributeNames(attributes) {
        this._translator.setCustomAttributes(attributes);
        return this;
    };

    Validator.prototype.addAttributeNames = function addAttributeNames(attributes) {
        this._translator.addCustomAttributes(attributes);
        return this;
    };

    Validator.prototype._validateRule = function _validateRule(attribute, rule) {
        var _this4 = this;

        var value = this.getValue(attribute);
        var name = rule.name;

        var parameters = this._replaceAsterisksInParameters(rule, attribute);
        var validate = this._rules[name] || RULES[name];
        if (validate) {
            return Promise.resolve(validate(attribute, value, parameters, this)).then(function (result) {
                if (result === false) {
                    var message = _this4._translator.getMessage(name, attribute, value, parameters);
                    _this4._errors.add(attribute, message);
                }
                return result;
            });
        }
        return Promise.reject(new Error('The rule [' + name + '] does not exist'));
    };

    Validator.prototype._passesOptionalCheck = function _passesOptionalCheck(attribute) {
        if (!this.hasRule(attribute, 'sometimes')) {
            return true;
        }
        return this.getValue(attribute, '__MISSING__') !== '__MISSING__';
    };

    Validator.prototype._replaceAsterisksInParameters = function _replaceAsterisksInParameters(rule, attribute) {
        var name = rule.name,
            parameters = rule.parameters;

        if (_constants.DEPENDENT_RULES.indexOf(name) === -1) {
            return parameters;
        }
        var pattern = utils.escape(this.getPrimaryAttribute(attribute)).replace(/\\\*/g, '([^\.]+)');
        var regex = new RegExp('^' + pattern);
        var match = regex.exec(attribute);
        if (match) {
            match.shift();
            var keys = match.slice(0);
            return parameters.map(function (field) {
                if (typeof field === 'string') {
                    keys.forEach(function (key) {
                        field = field.replace('*', key);
                    });
                }
                return field;
            });
        }
        return parameters;
    };

    _createClass(Validator, [{
        key: 'errors',
        get: function get() {
            return this._errors;
        }
    }]);

    return Validator;
}();

exports['default'] = Validator;