express-cargo/dist/cjs/src/validator.js

express middleware for class-based request parsing

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get equal () {
        return equal;
    },
    get isFalse () {
        return isFalse;
    },
    get isTrue () {
        return isTrue;
    },
    get length () {
        return length;
    },
    get max () {
        return max;
    },
    get maxLength () {
        return maxLength;
    },
    get min () {
        return min;
    },
    get minLength () {
        return minLength;
    },
    get notEqual () {
        return notEqual;
    },
    get oneOf () {
        return oneOf;
    },
    get prefix () {
        return prefix;
    },
    get range () {
        return range;
    },
    get regexp () {
        return regexp;
    },
    get suffix () {
        return suffix;
    },
    get validate () {
        return validate;
    }
});
const _metadata = require("./metadata");
function addValidator(target, propertyKey, rule) {
    const classMeta = new _metadata.CargoClassMetadata(target);
    const fieldMeta = classMeta.getFieldMetadata(propertyKey);
    fieldMeta.addValidator(rule);
    classMeta.setFieldMetadata(propertyKey, fieldMeta);
}
function min(minimum) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'min',
            validate: (input)=>typeof input === 'number' && input >= minimum,
            message: `${String(propertyKey)} must be >= ${minimum}`
        });
    };
}
function max(maximum) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'max',
            validate: (input)=>typeof input === 'number' && input <= maximum,
            message: `${String(propertyKey)} must be <= ${maximum}`
        });
    };
}
function prefix(prefixText) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'prefix',
            validate: (val)=>typeof val === 'string' && val.startsWith(prefixText),
            message: `${String(propertyKey)} must start with ${prefixText}`
        });
    };
}
function suffix(suffixText) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'suffix',
            validate: (val)=>typeof val === 'string' && val.endsWith(suffixText),
            message: `${String(propertyKey)} must end with ${suffixText}`
        });
    };
}
function equal(value) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'equal',
            validate: (val)=>val === value,
            message: `${String(propertyKey)} must be equal to ${value}`
        });
    };
}
function notEqual(value) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'notEqual',
            validate: (val)=>val !== value,
            message: `${String(propertyKey)} must not be equal to ${value}`
        });
    };
}
function range(min, max) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'range',
            validate: (value)=>typeof value === 'number' && value >= min && value <= max,
            message: `${String(propertyKey)} must be between ${min} and ${max}`
        });
    };
}
function isFalse() {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'isFalse',
            validate: (val)=>val === false,
            message: `${String(propertyKey)} must be false`
        });
    };
}
function isTrue() {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'isTrue',
            validate: (val)=>val === true,
            message: `${String(propertyKey)} must be true`
        });
    };
}
function length(value) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'length',
            validate: (val)=>typeof val === 'string' && val.length === value,
            message: `${String(propertyKey)} must be ${value} characters`
        });
    };
}
function maxLength(max) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'maxLength',
            validate: (val)=>typeof val === 'string' && val.length <= max,
            message: `${String(propertyKey)} must not exceed ${max} characters`
        });
    };
}
function minLength(min) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'minLength',
            validate: (val)=>typeof val === 'string' && val.length >= min,
            message: `${String(propertyKey)} must be at least ${min} characters`
        });
    };
}
function oneOf(options) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'oneOf',
            validate: (value)=>options.includes(value),
            message: `${String(propertyKey)} must be one of ${options.join(', ')}`
        });
    };
}
function validate(validateFn, message) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'validate',
            validate: validateFn,
            message: message || `${String(propertyKey)} did not pass the provided validation rule.`
        });
    };
}
function regexp(pattern, message) {
    return (target, propertyKey)=>{
        addValidator(target, propertyKey, {
            type: 'regexp',
            validate: (value)=>typeof value === 'string' && pattern.test(value),
            message: message || `${String(propertyKey)} does not match pattern ${pattern}`
        });
    };
}