datatypes-validation/dist/lib/data/Rules/Rules.js

     

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const Field_1 = require("../Field");
const nested_property_1 = __importDefault(require("nested-property"));
class Rules {
    constructor() {
        this.rules = {};
    }
    static checkRules(schema, data, options = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const { prefix, globalFields } = options;
            let fields = {};
            const withPrefix = (prefixString, key) => ((!!prefixString && prefixString !== '') ? `${prefixString}.${key}` : key);
            const identifyFieldValue = (field, key) => {
                field.path = withPrefix(prefix, key);
                field.value = (nested_property_1.default.has(data, key)) ? nested_property_1.default.get(data, key) : undefined;
            };
            const invokeCommonMethods = (field, item) => __awaiter(this, void 0, void 0, function* () {
                const others = ['objectOf', 'conditional', 'custom', 'alternatives'];
                for (const keyRuleFunction of Object.keys(item.rules).filter((fnName) => others.indexOf(fnName) === -1)) {
                    if (!field.error && keyRuleFunction !== 'arrayOf') {
                        yield item.rules[keyRuleFunction](field);
                    }
                }
            });
            const createFieldsObject = (field, item, key) => __awaiter(this, void 0, void 0, function* () {
                if (item.rules.alternatives) {
                    const newFields = (yield item.rules.alternatives(field, globalFields || fields));
                    fields = Object.assign({}, fields, newFields);
                }
                else if (item.rules.objectOf) {
                    const newFields = (yield item.rules.objectOf(field, globalFields || fields));
                    fields = Object.assign({}, fields, newFields);
                }
                else if (item.rules.arrayOf) {
                    const newFields = (yield item.rules.arrayOf(field, globalFields || fields));
                    fields = Object.assign({}, fields, newFields);
                }
                else if (item.rules.custom) {
                    const newFields = (yield item.rules.custom(field, globalFields || fields));
                    fields = Object.assign({}, fields, newFields);
                }
                else {
                    fields = Object.assign({}, fields, { [withPrefix(prefix, key)]: field });
                }
            });
            const checkRulesByConditionalMethods = () => __awaiter(this, void 0, void 0, function* () {
                for (const key of Object.keys(schema)) {
                    const item = schema[key];
                    if (item instanceof Rules) {
                        const field = (fields[withPrefix(prefix, key)]);
                        if (item.rules.conditional) {
                            const response = yield item.rules.conditional(field, globalFields || fields);
                            fields = Object.assign({}, fields, response);
                        }
                    }
                }
            });
            const checkRules = () => __awaiter(this, void 0, void 0, function* () {
                for (const key of Object.keys(schema)) {
                    const item = schema[key];
                    if (item instanceof Rules) {
                        const field = new Field_1.Field();
                        identifyFieldValue(field, key);
                        yield invokeCommonMethods(field, item);
                        yield createFieldsObject(field, item, key);
                    }
                    else {
                        fields = Object.assign({}, fields, yield Rules.checkRules(item, data, { prefix: key }));
                    }
                }
            });
            yield checkRules();
            yield checkRulesByConditionalMethods();
            return fields;
        });
    }
}
exports.Rules = Rules;
//# sourceMappingURL=Rules.js.map