@berish/validate/build/rule/createRule.js

Validation of complex objects with support for validation maps, rules and decorators

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const berish_guid_1 = require("berish-guid");
const registrator_1 = require("./registrator");
const flags_1 = require("./flags");
const isRuleFlag_1 = require("./isRuleFlag");
const pluginSystem_1 = require("../pluginSystem");
exports.SYMBOL_ERROR_TEXT_DEFAULT = Symbol('errorTextDefault');
function createRule(params) {
    if (!params)
        throw new Error('params is undefined in createRule');
    const _createRule = (params, body) => {
        const ruleName = params.name || `rule-${berish_guid_1.default.generateId()}`;
        const defaultErrorText = `${ruleName}-error`;
        const rule = (...args) => _createRule(params, args);
        rule.ruleName = ruleName;
        Object.defineProperty(rule, 'name', { value: rule.ruleName });
        Object.defineProperty(rule, 'isRegistered', {
            get: function () {
                return registrator_1.isRegisteredRule(rule.ruleName);
            },
        });
        rule.revertSimple = newRuleName => {
            newRuleName = newRuleName || `${ruleName}-revertSimple`;
            return rule.revertError(newRuleName);
        };
        rule.revertError = (newRuleName, errorText) => {
            newRuleName = newRuleName || `${ruleName}-revertError`;
            if (registrator_1.isRegisteredRule(newRuleName))
                return registrator_1.getRegisteredRule(newRuleName);
            const newRule = _createRule(Object.assign(Object.assign({}, params), { name: newRuleName, conditionSync: obj => {
                    if (!params.conditionSync)
                        return flags_1.FLAG_CONDITION_FALSY;
                    const result = params.conditionSync(obj);
                    if (isRuleFlag_1.isRuleFlag(result)) {
                        if (result === flags_1.FLAG_CONDITION_TRUTHY)
                            return flags_1.FLAG_CONDITION_FALSY;
                        if (result === flags_1.FLAG_CONDITION_FALSY)
                            return flags_1.FLAG_CONDITION_TRUTHY;
                        return flags_1.FLAG_CONDITION_TRUTHY;
                    }
                    return !result;
                }, conditionAsync: (obj) => __awaiter(this, void 0, void 0, function* () {
                    if (!params.conditionSync && !params.conditionAsync)
                        return flags_1.FLAG_CONDITION_FALSY;
                    const result = params.conditionAsync ? yield params.conditionAsync(obj) : params.conditionSync(obj);
                    if (isRuleFlag_1.isRuleFlag(result)) {
                        if (result === flags_1.FLAG_CONDITION_TRUTHY)
                            return flags_1.FLAG_CONDITION_FALSY;
                        if (result === flags_1.FLAG_CONDITION_FALSY)
                            return flags_1.FLAG_CONDITION_TRUTHY;
                        return flags_1.FLAG_CONDITION_TRUTHY;
                    }
                    return !result;
                }), errorText }), body);
            newRule.revertSimple = () => rule;
            newRule.revertError = () => rule;
            registrator_1.registerRule(newRule);
            return newRule;
        };
        rule.conditionSync = obj => {
            if (!params.conditionSync)
                return flags_1.FLAG_CONDITION_TRUTHY;
            const result = params.conditionSync(Object.assign(Object.assign({}, obj), { body }));
            if (isRuleFlag_1.isRuleFlag(result))
                return result;
            return result ? flags_1.FLAG_CONDITION_TRUTHY : flags_1.FLAG_CONDITION_FALSY;
        };
        rule.conditionAsync = (obj) => __awaiter(this, void 0, void 0, function* () {
            if (!params.conditionSync && !params.conditionAsync)
                return flags_1.FLAG_CONDITION_TRUTHY;
            const result = params.conditionAsync
                ? yield params.conditionAsync(Object.assign(Object.assign({}, obj), { body }))
                : params.conditionSync(Object.assign(Object.assign({}, obj), { body }));
            if (isRuleFlag_1.isRuleFlag(result))
                return result;
            return result ? flags_1.FLAG_CONDITION_TRUTHY : flags_1.FLAG_CONDITION_FALSY;
        });
        rule.errorText = obj => {
            if (!params.errorText)
                return defaultErrorText;
            const result = params.errorText(Object.assign(Object.assign({}, obj), { body })) || exports.SYMBOL_ERROR_TEXT_DEFAULT;
            if (result === exports.SYMBOL_ERROR_TEXT_DEFAULT)
                return defaultErrorText;
            return result;
        };
        rule.upgradeErrorText = callback => _createRule(Object.assign(Object.assign({}, params), { errorText: callback }), body);
        registrator_1.addRule(rule);
        return pluginSystem_1.callPlugin(rule, (plugin, rule) => pluginSystem_1.useUpgradeRuleAfterInit(plugin, rule));
    };
    const rule = _createRule(params, []);
    registrator_1.registerRule(rule);
    return pluginSystem_1.callPlugin(rule, (plugin, rule) => pluginSystem_1.useUpgradeRuleAfterRegister(plugin, rule));
}
exports.createRule = createRule;
//# sourceMappingURL=createRule.js.map