java-bean-validation.js/dist/core/validate.js

Java Bean Validation implementation for JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require("./core");
function validateTypeDescriptor(type, value, path, groups, violations, globalViolations) {
    if (type.isBasicType) {
        violations = globalViolations;
        groups = core_1.DEFAULT_GROUPS;
    }
    var constraints = type.constraints;
    if (constraints) {
        for (var i = 0, length_1 = constraints.length; i < length_1; i++) {
            var constraint = constraints[i];
            validateConstraintDescriptor(constraint, value, path, groups, violations, globalViolations);
        }
    }
    if (value === null || value === undefined) {
        return;
    }
    if (!type.isBasicType) {
        validateConstraintDescriptor({ constraintName: 'Object' }, value, path, core_1.DEFAULT_GROUPS, violations, globalViolations);
    }
    var properties = type.properties;
    if (properties) {
        for (var propertyName in properties) {
            var property = properties[propertyName];
            validatePropertyDescriptor(property, propertyName, value, path, groups, violations, globalViolations);
        }
    }
    if (!type.isCollection) {
        return;
    }
    var valueDescriptor = type.valueDescriptor;
    if (!valueDescriptor) {
        return;
    }
    if (Array.isArray(value)) {
        for (var index = 0, length_2 = value.length; index < length_2; index++) {
            validatePropertyDescriptor(valueDescriptor, index, value, path, groups, violations, globalViolations);
        }
    }
    else {
        for (var key in value) {
            validatePropertyDescriptor(valueDescriptor, key, value, path, groups, violations, globalViolations);
        }
    }
}
exports.validateTypeDescriptor = validateTypeDescriptor;
function validatePropertyDescriptor(property, propertyName, objectWithProperty, path, groups, violations, globalViolations) {
    var value;
    if (objectWithProperty) {
        value = objectWithProperty[propertyName];
    }
    var propertyPath = path + '.' + propertyName;
    var type = core_1.getTypeDescriptor(property.porpertyTypeName, value, propertyPath, globalViolations);
    if (!type) {
        return;
    }
    if (type.isBasicType || property.cascade) {
        var cascadeGroups = core_1.convertGroups(groups, property.groupConversions);
        validateTypeDescriptor(type, value, propertyPath, cascadeGroups, violations, globalViolations);
    }
    var constraints = property.constraints;
    if (constraints) {
        for (var i = 0, length_3 = constraints.length; i < length_3; i++) {
            var constraint = constraints[i];
            validateConstraintDescriptor(constraint, value, propertyPath, groups, violations, globalViolations);
        }
    }
}
exports.validatePropertyDescriptor = validatePropertyDescriptor;
function validateConstraintDescriptor(constraint, value, path, groups, violations, globalViolations) {
    var validator = core_1.VALIDATORS[constraint.constraintName];
    if (validator) {
        if (validator.isGlobalValidator) {
            violations = globalViolations;
        }
        if (!constraint.defaultValuesLoaded) {
            core_1.loadDefaultConstraintValues(constraint, validator);
        }
    }
    else {
        if (!constraint.hasNoValidator) {
            var violatedConstraint = { constraintName: 'ValidatorNotFound', attributes: { constraintName: constraint.constraintName } };
            core_1.addViolation(violatedConstraint, value, path, globalViolations);
        }
        validator = noopValidator;
    }
    var attributes = constraint.attributes || {};
    if (!core_1.groupAllowed(groups, attributes.groups)) {
        return true;
    }
    var composingValid = true;
    var composingConstraints = constraint.composingConstraints;
    var reportAsSingle = constraint.reportAsSingle;
    if (composingConstraints) {
        var innerViolations = violations;
        if (reportAsSingle) {
            innerViolations = [];
        }
        for (var i = 0, length_4 = composingConstraints.length; i < length_4; i++) {
            var composedConstraint = composingConstraints[i];
            composingValid = validateConstraintDescriptor(composedConstraint, value, path, groups, innerViolations, globalViolations) && composingValid;
        }
    }
    var constraintValid = validator(value, attributes, constraint, path, globalViolations, violations);
    if (constraintValid && composingValid) {
        return true;
    }
    core_1.addViolation(constraint, value, path, violations);
    return false;
}
exports.validateConstraintDescriptor = validateConstraintDescriptor;
function noopValidator() {
    return true;
}
//# sourceMappingURL=validate.js.map