one-schema/dist/core/validate.js

one-schema object validator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var validatorResult_1 = require("./validatorResult");
var type_validators_1 = require("./type-validators");
var validatorManager_1 = require("./validatorManager");
function sanitizeKeys(input, schema) {
    var arr = Object.keys(input);
    for (var i = 0, l = arr.length; i < l; i++) {
        if (!schema.hasOwnProperty(arr[i])) {
            return validatorResult_1.vrError("Invalid parameter " + arr[i]);
        }
    }
    return validatorResult_1.vrSuccess();
}
function validatePrimitive(value, fieldValidator, options) {
    var typeFunc = type_validators_1.PRIMITIVE_TYPE_VALIDATORS[fieldValidator.settings.type];
    if (!typeFunc) {
        return validatorResult_1.vrError("invalid type " + fieldValidator.settings.type);
    }
    var result = typeFunc(value, fieldValidator, options);
    return result;
}
function validateArrayField(value, fieldValidator, options) {
    if (fieldValidator.settings.type !== 'array') {
        throw new Error("validateObject called on non object type!");
    }
    if (!Array.isArray(value)) {
        return validatorResult_1.vrError('is not array');
    }
    var _a = fieldValidator.settings, min = _a.min, max = _a.max, arrayOf = _a.arrayOf;
    if (!arrayOf) {
        return validatorResult_1.vrError("Missing schema for array field!");
    }
    var valLength = value.length;
    if (typeof min === 'number' && valLength < min) {
        return validatorResult_1.vrError("is less than minimum length " + min);
    }
    if (typeof max === 'number' && valLength > max) {
        return validatorResult_1.vrError("is larger than maximum length " + max);
    }
    for (var i = 0; i < valLength; i++) {
        var result = validate(value[i], arrayOf, options);
        if (!result.success) {
            return result;
        }
    }
    return validatorResult_1.vrSuccess();
}
function validateObject(input, fieldValidator, options) {
    if (fieldValidator.settings.type !== 'object') {
        throw new Error("validateObject called on non object type!");
    }
    var fvSchema = fieldValidator.settings.schema;
    if (!fvSchema) {
        return validatorResult_1.vrError("Missing schema for object field!");
    }
    var result = sanitizeKeys(input, fvSchema);
    if (!result.success) {
        return result;
    }
    var keys = Object.keys(fvSchema);
    var keysLength = keys.length;
    for (var i = 0; i < keysLength; i++) {
        var r = validate(input[keys[i]], fvSchema[keys[i]], options);
        if (!r.success) {
            r.error = keys[i] + " -> " + r.error;
            return r;
        }
    }
    return validatorResult_1.vrSuccess();
}
function validate(input, fieldValidator, options) {
    if (options === void 0) { options = {}; }
    var _a = fieldValidator.settings, type = _a.type, required = _a.required, validator = _a.validator;
    if (typeof input === 'undefined') {
        if (required && !options.noRequired) {
            return validatorResult_1.vrError('is undefined, but required!');
        }
        return validatorResult_1.vrSuccess();
    }
    var result = null;
    if (type === 'object') {
        result = validateObject(input, fieldValidator, options);
    }
    else if (type === 'array') {
        result = validateArrayField(input, fieldValidator, options);
    }
    else {
        var primFieldValidator = fieldValidator;
        result = validatePrimitive(input, primFieldValidator, options);
        var oneOf = primFieldValidator.settings.oneOf;
        if (Array.isArray(oneOf) && oneOf.indexOf(input) === -1) {
            return validatorResult_1.vrError('is not a valid element of the oneOf array');
        }
    }
    if (!result.success) {
        return result;
    }
    if (typeof validator === 'object' && validator && validator.id) {
        return validatorManager_1.runExternalValidator(input, validator, fieldValidator);
    }
    return validatorResult_1.vrSuccess();
}
exports.default = validate;