json-expression-eval/dist/lib/engine.js

json serializable rule engine / boolean expression evaluator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateRules = exports.evaluateRules = void 0;
const evaluator_1 = require("./evaluator");
const helpers_1 = require("./helpers");
const typeGuards_1 = require("./typeGuards");
const engineConsequenceEvaluator_1 = require("./engineConsequenceEvaluator");
async function run(rules, context, functionsTable, ruleFunctionsTable, haltOnFirstMatch, validation, runOptions) {
    const errors = [];
    for (const rule of rules) {
        const keys = (0, helpers_1.objectKeys)(rule);
        const key = keys[0];
        if (keys.length === 1 && key && (0, typeGuards_1.isRuleFunction)(rule, ruleFunctionsTable, key)) {
            const consequence = await ruleFunctionsTable[key](rule[key], context, {
                custom: runOptions,
                validation,
            });
            if (consequence) {
                errors.push(consequence);
                if (haltOnFirstMatch && !validation) {
                    return errors;
                }
            }
        }
        else {
            // Type assertion needed because TypeScript can't narrow RequireOnlyOne union types
            const ruleDefinition = rule;
            if (!ruleDefinition.condition) {
                throw new Error(`Missing condition for rule`);
            }
            if (!ruleDefinition.consequence) {
                throw new Error(`Missing consequence for rule`);
            }
            if (validation) {
                await (0, evaluator_1.validate)(ruleDefinition.condition, context, functionsTable, runOptions);
                await (0, engineConsequenceEvaluator_1.evaluateEngineConsequence)(context, ruleDefinition.consequence);
            }
            else {
                const ruleApplies = await (0, evaluator_1.evaluate)(ruleDefinition.condition, context, functionsTable, runOptions);
                if (ruleApplies) {
                    const consequence = await (0, engineConsequenceEvaluator_1.evaluateEngineConsequence)(context, ruleDefinition.consequence);
                    errors.push(consequence);
                    if (haltOnFirstMatch) {
                        return errors;
                    }
                }
            }
        }
    }
    return errors.length ? errors : undefined;
}
const evaluateRules = async (rules, context, functionsTable, ruleFunctionsTable, haltOnFirstMatch, runOptions) => {
    return run(rules, context, functionsTable, ruleFunctionsTable, haltOnFirstMatch, false, runOptions);
};
exports.evaluateRules = evaluateRules;
const validateRules = async (rules, validationContext, functionsTable, ruleFunctionsTable, runOptions) => {
    await run(rules, validationContext, functionsTable, ruleFunctionsTable, false, true, runOptions);
};
exports.validateRules = validateRules;
//# sourceMappingURL=engine.js.map