roc/lib/validation/validators.js

Build modern web applications easily

'use strict';

exports.__esModule = true;
exports.isArray = isArray;
exports.isObject = isObject;
exports.isArrayOrSingle = isArrayOrSingle;
exports.isString = isString;
exports.isBoolean = isBoolean;
exports.isInteger = isInteger;
exports.isPath = isPath;
exports.oneOf = oneOf;
exports.required = required;

require('source-map-support/register');

var _lodash = require('lodash');

var _indexJs = require('./index.js');

/**
 * Validates an array using a validator.
 *
 * @param {function|RegExp} validator - The validator to use on the elements in the array.
 * @return {function} - A function that takes a value and that returns true or false if valid or not.
 */

function isArray(validator) {
    return function (input, info) {
        if (info) {
            return infoObject(validator, function (wrap) {
                return '[ ' + wrap + ' ]';
            });
        }

        if (!_lodash.isArray(input)) {
            return 'Was not an array!';
        }

        return isArrayOrSingle(validator)(input);
    };
}

/**
 * Validates an object using a validator.
 *
 * @param {function|RegExp} validator - The validator to use on the elements in the object
 * @return {function} - A function that takes a value and that returns true or false if valid or not.
 */

function isObject(validator) {
    return function (input, info) {
        if (info) {
            return infoObject(validator, function (wrap) {
                return '{ ' + wrap + ' }';
            });
        }

        if (!_lodash.isPlainObject(input)) {
            return 'Was not an object!';
        }

        if (!validator) {
            return true;
        }

        return Object.keys(input).map(function (key) {
            return _indexJs.isValid(input[key], validator);
        }).reduce(function (a, b) {
            return a === true && b === true;
        }, true);
    };
}

/**
 * Validates an pontential array using a validator.
 *
 * Allows that a single value is given.
 *
 * @param {function|RegExp} validator - The validator to use on the elements in the array.
 * @return {function} - A function that takes a value and that returns true or false if valid or not.
 */

function isArrayOrSingle(validator) {
    return function (input, info) {
        if (info) {
            return infoObject(validator, function (wrap) {
                return wrap + ' / [ ' + wrap + ' ]';
            });
        }

        var array = [].concat(input);
        for (var _iterator = array, _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 value = _ref;

            var result = _indexJs.isValid(value, validator);
            if (result !== true) {
                return result;
            }
        }

        return true;
    };
}

/**
 * Validates an string.
 *
 * @param {object} value - Something to validate.
 * @param {boolean} info - If type information should be returned.
 * @return {infoObject|boolean|string} - Type information or if it is valid.
 */

function isString(value, info) {
    if (info) {
        return infoObject('String');
    }

    if (!_lodash.isString(value)) {
        return 'Was not a string!';
    }

    return true;
}

/**
 * Validates an string.
 *
 * @param {object} value - Something to validate.
 * @param {boolean} info - If type information should be returned.
 * @return {infoObject|boolean|string} - Type information or if it is valid.
 */

function isBoolean(value, info) {
    if (info) {
        return infoObject('Boolean');
    }

    if (!_lodash.isBoolean(value)) {
        return 'Was not a boolean!';
    }

    return true;
}

/**
 * Validates an string.
 *
 * @param {object} value - Something to validate.
 * @param {boolean} info - If type information should be returned.
 * @return {infoObject|boolean|string} - Type information or if it is valid.
 */

function isInteger(value, info) {
    if (info) {
        return infoObject('Integer');
    }

    if (!Number.isInteger(value)) {
        return 'Was not an integer!';
    }

    return true;
}

/**
 * Validates an string.
 *
 * @param {object} value - Something to validate.
 * @param {boolean} info - If type information should be returned.
 * @return {infoObject|boolean|string} - Type information or if it is valid.
 */

function isPath(value, info) {
    if (info) {
        return infoObject('Filepath');
    }

    if (isString(value) !== true) {
        return 'Was not a filepath!';
    }

    return true;
}

/**
 * Validates against a list of validators.
 *
 * @param {...function} validators - Validators to validate against.
 * @return {function} - A function that takes a value and that returns true or false if valid or not.
 */

function oneOf() {
    for (var _len = arguments.length, validators = Array(_len), _key = 0; _key < _len; _key++) {
        validators[_key] = arguments[_key];
    }

    if (!validators.length) {
        throw new Error('You need to use at least one validator.');
    }

    return function (input, info) {
        if (info) {
            var types = [];
            for (var _iterator2 = validators, _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 validator = _ref2;

                types.push(infoObject(validator).type);
            }
            return infoObject(types.join(' / '));
        }

        var invalid = [];
        for (var _iterator3 = validators, _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 validator = _ref3;

            var result = _indexJs.isValid(input, validator);
            if (result === true) {
                return true;
            }
            invalid.push(validator(null, true).type);
        }

        return 'Was not any of the possible types:\n' + invalid.reduce(function (prev, next) {
            return prev + '\n' + next;
        }, '');
    };
}

/**
 * Marks that the value is required
 *
 * @param {function} validator - Validator to validate against
 * @return {function} - A function that takes a value and that returns true or false if valid or not.
 */

function required(validator) {
    return function (input, info) {
        if (info) {
            return infoObject(validator, null, true);
        }

        if (!input && input !== false || (_lodash.isArray(input) || _lodash.isString(input)) && input.length === 0 || _lodash.isPlainObject(input) && Object.keys(input).length === 0) {
            return 'A value was required but none was given!';
        }

        if (!validator) {
            return true;
        }

        return validator(input);
    };
}

function infoObject(validator, wrapper) {
    var req = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];

    var info = _lodash.isFunction(validator) ? validator(null, true).type : validator.toString();
    var type = wrapper ? wrapper(info) : info;
    return {
        type: type,
        required: req
    };
}
//# sourceMappingURL=validators.js.map