@splitsoftware/splitio-commons/esm/evaluator/Engine.js

Split JavaScript SDK common components

import { get, isString } from '../utils/lang';
import { parser } from './parser';
import { keyParser } from '../utils/key';
import { thenable } from '../utils/promise/thenable';
import { NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED, PREREQUISITES_NOT_MET } from '../utils/labels';
import { CONTROL } from '../utils/constants';
import { ENGINE_DEFAULT } from '../logger/constants';
import { prerequisitesMatcherContext } from './matchers/prerequisites';
function evaluationResult(result, defaultTreatment) {
    return {
        treatment: get(result, 'treatment', defaultTreatment),
        label: get(result, 'label', NO_CONDITION_MATCH)
    };
}
export function engineParser(log, split, storage) {
    var killed = split.killed, seed = split.seed, trafficAllocation = split.trafficAllocation, trafficAllocationSeed = split.trafficAllocationSeed, status = split.status, conditions = split.conditions, prerequisites = split.prerequisites;
    var defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
    var evaluator = parser(log, conditions, storage);
    var prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log);
    return {
        getTreatment: function (key, attributes, splitEvaluator) {
            var parsedKey = keyParser(key);
            function evaluate(prerequisitesMet) {
                if (!prerequisitesMet) {
                    log.debug(ENGINE_DEFAULT, ['Prerequisite not met']);
                    return {
                        treatment: defaultTreatment,
                        label: PREREQUISITES_NOT_MET
                    };
                }
                var evaluation = evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator);
                return thenable(evaluation) ?
                    evaluation.then(function (result) { return evaluationResult(result, defaultTreatment); }) :
                    evaluationResult(evaluation, defaultTreatment);
            }
            if (status === 'ARCHIVED')
                return {
                    treatment: CONTROL,
                    label: SPLIT_ARCHIVED
                };
            if (killed) {
                log.debug(ENGINE_DEFAULT, ['Flag is killed']);
                return {
                    treatment: defaultTreatment,
                    label: SPLIT_KILLED
                };
            }
            var prerequisitesMet = prerequisiteMatcher({ key: key, attributes: attributes }, splitEvaluator);
            return thenable(prerequisitesMet) ?
                prerequisitesMet.then(evaluate) :
                evaluate(prerequisitesMet);
        }
    };
}