nowjs-core/lib/validation/Validation.js

NowCanDo Javascript Core [nowjs-core] is a library written by TypeScript code maintains under Apache 2.0 licence

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
require("reflect-metadata");
const index_1 = require("./index");
const ValidationDefinition_1 = require("./ValidationDefinition");
const ValidatorBase_1 = require("./ValidatorBase");
class Validation {
    static registerValidator(data, validator) {
        let name = '';
        if (typeof data === 'string' && !validator) {
            name = data;
        }
        else if (data instanceof ValidatorBase_1.ValidatorBase) {
            name = data.Name;
        }
        else {
            name = data.constructor.name;
        }
        Validation.validators.set(name, validator);
        return this;
    }
    static registerDefinition(name, definition) {
        if (!name) {
            return this;
        }
        Validation.definitions.set(name, definition);
        return this;
    }
    static jsonDefine(definition, json) {
        if (definition && json) {
            for (const itemName in json) {
                const item = json[itemName];
                if (item && item.validators) {
                    for (const validatorName in item.validators) {
                        const validatorItem = item.validators[validatorName];
                        if (validatorItem) {
                            const validatorFn = definition.on(itemName)[`${validatorName}`];
                            if (validatorFn) {
                                validatorItem[index_1.VALIDATION_DEFINIIONITEM_KEY] = index_1.VALIDATION_DEFINIIONITEM_KEY;
                                validatorFn.apply(definition, [validatorItem]);
                            }
                        }
                    }
                }
            }
        }
    }
    static define(name, json) {
        if (!name) {
            return new ValidationDefinition_1.ValidationDefinition();
        }
        const definition = new ValidationDefinition_1.ValidationDefinition();
        if (json) {
            Validation.jsonDefine(definition, json);
        }
        Validation.definitions.set(name, definition);
        return definition;
    }
    static nestedValidatorDefine(definition, target, parentPropertyName) {
        if (target && typeof target !== 'object') {
            return;
        }
        for (const propertyKey of Reflect.ownKeys(Object.getPrototypeOf(target))) {
            let propertyName = propertyKey.toString();
            if (propertyName === 'constructor') {
                continue;
            }
            if (typeof target[propertyKey] === 'function') {
                continue;
            }
            else if (typeof target[propertyKey] === 'object') {
                propertyName = parentPropertyName
                    ? parentPropertyName + index_1.VALIDATION_PROPERTYPATH_SEPRATOR + propertyName
                    : propertyName;
                Validation.nestedValidatorDefine(definition, target[propertyKey], propertyName);
            }
            else {
                const validatorIf = Reflect.getMetadata(index_1.VALIDATION_VALIDATEIF_METADATA_KEY, target, propertyName);
                if (validatorIf) {
                    const result = validatorIf.apply(target);
                    if (!result) {
                        continue;
                    }
                }
                const validator = Reflect.getMetadata(index_1.VALIDATOR_METADATA_KEY, target, propertyName);
                if (validator) {
                    propertyName = parentPropertyName
                        ? parentPropertyName + index_1.VALIDATION_PROPERTYPATH_SEPRATOR + propertyName
                        : propertyName;
                    definition.on(propertyName).add(validator);
                }
            }
        }
    }
    static async validate(target, arg1) {
        let definitionName = '';
        const validatorPromises = [];
        if (!arg1) {
            if (Validation.definitions.has(target.constructor.name)) {
                definitionName = target.constructor.name;
            }
            else {
                const definition = Validation.define();
                arg1 = definition;
                Validation.nestedValidatorDefine(definition, target);
            }
        }
        else if (typeof arg1 === 'string') {
            definitionName = arg1;
            arg1 = Validation.definitions.get(definitionName);
            if (!arg1) {
                throw new Error(`There is no registered definition by name : "${definitionName}"`);
            }
        }
        if (arg1 && arg1 instanceof ValidationDefinition_1.ValidationDefinition) {
            for (const item of arg1.Definitions) {
                const validators = item[1];
                const context = new index_1.ValidationContext(target, item[0]);
                for (const validator of validators) {
                    validatorPromises.push(validator.validate(context));
                }
            }
        }
        else if (arg1 instanceof Array || typeof arg1 === 'object') {
            const context = new index_1.ValidationContext(target, '');
            const validators = new Map();
            if (typeof arg1 === 'object') {
                validators.set(arg1.Name, arg1);
            }
            else {
                for (const member of arg1) {
                    validators.set(member.Name, member);
                }
            }
            for (const item of validators) {
                validatorPromises.push(item[1].validate(context));
            }
        }
        return Promise.all(validatorPromises).then(results => {
            return results.every(item => item === true);
        });
    }
}
exports.Validation = Validation;
Validation.definitions = new Map();
Validation.validators = new Map();