salix/client/core/src/lib/validator.js

import {validator} from 'vendor';

export const validators = {
    presence: function(value, conf) {
        if (validator.isEmpty(value))
            throw new Error(`Value can't be empty`);
    },
    absence: function(value, conf) {
        if (!validator.isEmpty(value))
            throw new Error(`Value should be empty`);
    },
    length: function(value, conf) {
        let options = {
            min: conf.min || conf.is,
            max: conf.max || conf.is
        };
        if (!validator.isLength(value, options)) {
            if (conf.is || conf.min === conf.max)
                throw new Error(`Value should be ${conf.is} characters long`);
            else if (conf.min !== conf.max)
                throw new Error(`Value should have a length between ${conf.min} and ${conf.max}`);
            else if (conf.min)
                throw new Error(`Value should have at least ${conf.min} characters`);
            else
                throw new Error(`Value should have at most ${conf.min} characters`);
        }
    },
    numericality: function(value, conf) {
        if (conf.int) {
            if (!validator.isInt(value))
                throw new Error(`Value should be integer`);
        } else if (!validator.isNumeric(value))
            throw new Error(`Value should be a number`);
    },
    inclusion: function(value, conf) {
        if (!validator.isIn(value, conf.in))
            throw new Error(`Invalid value`);
    },
    exclusion: function(value, conf) {
        if (validator.isIn(value, conf.in))
            throw new Error(`Invalid value`);
    },
    format: function(value, conf) {
        if (!validator.matches(value, conf.with))
            throw new Error(`Invalid value`);
    },
    custom: function(value, conf) {
        let valid = true;
        function err(kind) {
            valid = false;
        }

        let inst = {attr: value};
        conf.customValidator.call(inst, err);

        if (!valid)
            throw new Error(`Invalid value`);
    },
    uniqueness: function() {
        // TODO: Implement me
    }
};

/**
 * Checks if value satisfies a set of validations.
 *
 * @param {*} value The value
 * @param {Array} validations Array with validations
 */
export function validateAll(value, validations) {
    for (let conf of validations)
        validate(value, conf);
}

/**
 * Checks if value satisfies a validation.
 *
 * @param {*} value The value
 * @param {Object} conf The validation configuration
 */
export function validate(value, conf) {
    let validator = validators[conf.validation];
    try {
        checkNull(value, conf);

        if (validator && value != null)
            validator(value, conf);
    } catch (e) {
        let message = conf.message ? conf.message : e.message;
        throw new Error(message);
    }
}

/**
 * Checks if value satisfies a not null validation.
 *
 * @param {*} value The value
 * @param {Object} conf The validation configuration
 */
export function checkNull(value, conf) {
    if (typeof value === 'undefined' || value === '') {
        if (!conf.allowBlank)
            throw new Error(`Value can't be blank`);
    } else if (value === null && !conf.allowNull)
        throw new Error(`Value can't be null`);
}