@splitsoftware/splitio-commons 2.3.0 → 2.3.1-rc.0

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -1,103 +1,132 @@
+import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
+import { RB_SEGMENT_UPDATE } from '../constants';
+import { parseFFUpdatePayload } from '../parseUtils';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
-    var maxChangeNumber = 0;
-    var handleNewEvent = false;
-    var isHandlingEvent;
-    var cdnBypass;
-    var payload;
-    var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-    function __handleSplitUpdateCall() {
-        isHandlingEvent = true;
-        if (maxChangeNumber > splitsCache.getChangeNumber()) {
-            handleNewEvent = false;
-            var splitUpdateNotification_1 = payload ? { payload: payload, changeNumber: maxChangeNumber } : undefined;
-            // fetch splits revalidating data if cached
-            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification_1).then(function () {
-                if (!isHandlingEvent)
-                    return; // halt if `stop` has been called
-                if (handleNewEvent) {
-                    __handleSplitUpdateCall();
-                }
-                else {
-                    if (splitUpdateNotification_1)
-                        telemetryTracker.trackUpdatesFromSSE(SPLITS);
-                    // fetch new registered segments for server-side API. Not retrying on error
-                    if (segmentsSyncTask)
-                        segmentsSyncTask.execute(true);
-                    var attempts = backoff.attempts + 1;
-                    if (maxChangeNumber <= splitsCache.getChangeNumber()) {
-                        log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
-                        isHandlingEvent = false;
-                        return;
-                    }
-                    if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-                        backoff.scheduleCall();
-                        return;
-                    }
-                    if (cdnBypass) {
-                        log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
-                        isHandlingEvent = false;
+export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
+    var ff = SplitsUpdateWorker(storage.splits);
+    var rbs = SplitsUpdateWorker(storage.rbSegments);
+    function SplitsUpdateWorker(cache) {
+        var maxChangeNumber = -1;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var instantUpdate;
+        var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+        function __handleSplitUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > cache.getChangeNumber()) {
+                handleNewEvent = false;
+                // fetch splits revalidating data if cached
+                splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (handleNewEvent) {
+                        __handleSplitUpdateCall();
                     }
                     else {
-                        backoff.reset();
-                        cdnBypass = true;
-                        __handleSplitUpdateCall();
+                        if (instantUpdate)
+                            telemetryTracker.trackUpdatesFromSSE(SPLITS);
+                        // fetch new registered segments for server-side API. Not retrying on error
+                        if (segmentsSyncTask)
+                            segmentsSyncTask.execute(true);
+                        var attempts = backoff.attempts + 1;
+                        if (ff.isSync() && rbs.isSync()) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleSplitUpdateCall();
+                        }
                     }
-                }
-            });
-        }
-        else {
-            isHandlingEvent = false;
-        }
-    }
-    /**
-     * Invoked by NotificationProcessor on SPLIT_UPDATE event
-     *
-     * @param changeNumber - change number of the SPLIT_UPDATE notification
-     */
-    function put(_a, _payload) {
-        var changeNumber = _a.changeNumber, pcn = _a.pcn;
-        var currentChangeNumber = splitsCache.getChangeNumber();
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
-            return;
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-        payload = undefined;
-        if (_payload && currentChangeNumber === pcn) {
-            payload = _payload;
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
         }
-        if (backoff.timeoutID || !isHandlingEvent)
-            __handleSplitUpdateCall();
-        backoff.reset();
+        return {
+            /**
+             * Invoked by NotificationProcessor on SPLIT_UPDATE or RB_SEGMENT_UPDATE event
+             *
+             * @param changeNumber - change number of the notification
+             */
+            put: function (_a, payload) {
+                var changeNumber = _a.changeNumber, pcn = _a.pcn, type = _a.type;
+                var currentChangeNumber = cache.getChangeNumber();
+                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                    return;
+                maxChangeNumber = changeNumber;
+                handleNewEvent = true;
+                cdnBypass = false;
+                instantUpdate = undefined;
+                if (payload && currentChangeNumber === pcn) {
+                    instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
+                }
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleSplitUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                isHandlingEvent = false;
+                backoff.reset();
+            },
+            isSync: function () {
+                return maxChangeNumber <= cache.getChangeNumber();
+            }
+        };
     }
     return {
-        put: put,
+        put: function (parsedData) {
+            if (parsedData.d && parsedData.c !== undefined) {
+                try {
+                    var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+                    if (payload) {
+                        (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
+                        return;
+                    }
+                }
+                catch (e) {
+                    log.warn(STREAMING_PARSING_SPLIT_UPDATE, [parsedData.type, e]);
+                }
+            }
+            (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData);
+        },
         /**
          * Invoked by NotificationProcessor on SPLIT_KILL event
          *
-         * @param changeNumber - change number of the SPLIT_UPDATE notification
+         * @param changeNumber - change number of the notification
          * @param splitName - name of split to kill
          * @param defaultTreatment - default treatment value
          */
         killSplit: function (_a) {
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-            if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+            if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
                 splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
-            put({ changeNumber: changeNumber });
+            ff.put({ changeNumber: changeNumber });
         },
         stop: function () {
-            isHandlingEvent = false;
-            backoff.reset();
+            ff.stop();
+            rbs.stop();
         }
     };
 }

package/esm/sync/streaming/constants.js

@@ -27,6 +27,7 @@ export var MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';
+export var RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 export var CONTROL = 'CONTROL';
 export var OCCUPANCY = 'OCCUPANCY';

package/esm/sync/streaming/pushManager.js

@@ -8,10 +8,10 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -43,7 +43,7 @@ export function pushManagerFactory(params, pollingManager) {
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -179,21 +179,8 @@ export function pushManagerFactory(params, pollingManager) {
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
     pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(SPLIT_UPDATE, function (parsedData) {
-        if (parsedData.d && parsedData.c !== undefined) {
-            try {
-                var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
-                if (payload) {
-                    splitsUpdateWorker.put(parsedData, payload);
-                    return;
-                }
-            }
-            catch (e) {
-                log.warn(STREAMING_PARSING_SPLIT_UPDATE, [e]);
-            }
-        }
-        splitsUpdateWorker.put(parsedData);
-    });
+    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {

package/esm/sync/syncManagerOnline.js

@@ -127,7 +127,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments())
+                                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -137,7 +137,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                             }
                         }
                         else {
-                            if (storage.splits.usesSegments())
+                            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
                                 mySegmentsSyncTask.start();
                         }
                     }

package/esm/utils/constants/index.js

@@ -86,7 +86,11 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAG_SPEC_VERSION = '1.2';
+export var FLAG_SPEC_VERSION = '1.3';
 // Matcher types
 export var IN_SEGMENT = 'IN_SEGMENT';
 export var IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';
+export var IN_RULE_BASED_SEGMENT = 'IN_RULE_BASED_SEGMENT';
+export var STANDARD_SEGMENT = 'standard';
+export var LARGE_SEGMENT = 'large';
+export var RULE_BASED_SEGMENT = 'rule-based';

package/esm/utils/labels/index.js

@@ -6,3 +6,4 @@ export var EXCEPTION = 'exception';
 export var SPLIT_ARCHIVED = 'archived';
 export var NOT_IN_SPLIT = 'not in split';
 export var UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
+export var PREREQUISITES_NOT_MET = 'prerequisites not met';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.3.0",
+  "version": "2.3.1-rc.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -66,6 +66,11 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
   userDefinedSegmentMatcherData: IInSegmentMatcherData
 }
 
+interface IInRBSegmentMatcher extends ISplitMatcherBase {
+  matcherType: 'IN_RULE_BASED_SEGMENT',
+  userDefinedSegmentMatcherData: IInSegmentMatcherData
+}
+
 interface IInLargeSegmentMatcher extends ISplitMatcherBase {
   matcherType: 'IN_LARGE_SEGMENT',
   userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData
@@ -176,7 +181,7 @@ export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatc
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
   IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
   IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher |
-  IInLargeSegmentMatcher
+  IInLargeSegmentMatcher | IInRBSegmentMatcher
 
 /** Split object */
 export interface ISplitPartition {
@@ -189,19 +194,39 @@ export interface ISplitCondition {
     combiner: 'AND',
     matchers: ISplitMatcher[]
   }
-  partitions: ISplitPartition[]
-  label: string
-  conditionType: 'ROLLOUT' | 'WHITELIST'
+  partitions?: ISplitPartition[]
+  label?: string
+  conditionType?: 'ROLLOUT' | 'WHITELIST'
+}
+
+export interface IExcludedSegment {
+  type: 'standard' | 'large' | 'rule-based',
+  name: string,
+}
+
+export interface IRBSegment {
+  name: string,
+  changeNumber: number,
+  status: 'ACTIVE' | 'ARCHIVED',
+  conditions?: ISplitCondition[],
+  excluded?: {
+    keys?: string[] | null,
+    segments?: IExcludedSegment[] | null
+  }
 }
 
 export interface ISplit {
   name: string,
   changeNumber: number,
+  status: 'ACTIVE' | 'ARCHIVED',
+  conditions: ISplitCondition[],
+  prerequisites?: {
+    n: string,
+    ts: string[]
+  }[]
   killed: boolean,
   defaultTreatment: string,
   trafficTypeName: string,
-  conditions: ISplitCondition[],
-  status: 'ACTIVE' | 'ARCHIVED',
   seed: number,
   trafficAllocation?: number,
   trafficAllocationSeed?: number
@@ -217,8 +242,16 @@ export type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'traf
 
 /** Interface of the parsed JSON response of `/splitChanges` */
 export interface ISplitChangesResponse {
-  till: number,
-  splits: ISplit[]
+  ff?: {
+    t: number,
+    s?: number,
+    d: ISplit[]
+  },
+  rbs?: {
+    t: number,
+    s?: number,
+    d: IRBSegment[]
+  }
 }
 
 /** Interface of the parsed JSON response of `/segmentChanges/{segmentName}` */

package/src/evaluator/Engine.ts

@@ -1,14 +1,16 @@
-import { get } from '../utils/lang';
+import { get, isString } from '../utils/lang';
 import { parser } from './parser';
 import { keyParser } from '../utils/key';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED } from '../utils/labels';
+import { NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED, PREREQUISITES_NOT_MET } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import SplitIO from '../../types/splitio';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
+import { IEvaluation, IEvaluationResult, ISplitEvaluator } from './types';
 import { ILogger } from '../logger/types';
+import { ENGINE_DEFAULT } from '../logger/constants';
+import { prerequisitesMatcherContext } from './matchers/prerequisites';
 
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
@@ -17,84 +19,55 @@ function evaluationResult(result: IEvaluation | undefined, defaultTreatment: str
   };
 }
 
-export class Engine {
+export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync) {
+  const { killed, seed, trafficAllocation, trafficAllocationSeed, status, conditions, prerequisites } = split;
 
-  constructor(private baseInfo: ISplit, private evaluator: IEvaluator) {
+  const defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
 
-    // in case we don't have a default treatment in the instantiation, use 'control'
-    if (typeof this.baseInfo.defaultTreatment !== 'string') {
-      this.baseInfo.defaultTreatment = CONTROL;
-    }
-  }
+  const evaluator = parser(log, conditions, storage);
+  const prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log);
+
+  return {
 
-  static parse(log: ILogger, splitFlatStructure: ISplit, storage: IStorageSync | IStorageAsync) {
-    const conditions = splitFlatStructure.conditions;
-    const evaluator = parser(log, conditions, storage);
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
 
-    return new Engine(splitFlatStructure, evaluator);
-  }
+      const parsedKey = keyParser(key);
 
-  getKey() {
-    return this.baseInfo.name;
-  }
+      function evaluate(prerequisitesMet: boolean) {
+        if (!prerequisitesMet) {
+          log.debug(ENGINE_DEFAULT, ['Prerequisite not met']);
+          return {
+            treatment: defaultTreatment,
+            label: PREREQUISITES_NOT_MET
+          };
+        }
 
-  getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
-    const {
-      killed,
-      seed,
-      defaultTreatment,
-      trafficAllocation,
-      trafficAllocationSeed
-    } = this.baseInfo;
-    let parsedKey;
-    let treatment;
-    let label;
+        const evaluation = evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) as MaybeThenable<IEvaluation>;
+
+        return thenable(evaluation) ?
+          evaluation.then(result => evaluationResult(result, defaultTreatment)) :
+          evaluationResult(evaluation, defaultTreatment);
+      }
 
-    try {
-      parsedKey = keyParser(key);
-    } catch (err) {
-      return {
+      if (status === 'ARCHIVED') return {
         treatment: CONTROL,
-        label: EXCEPTION
+        label: SPLIT_ARCHIVED
       };
-    }
-
-    if (this.isGarbage()) {
-      treatment = CONTROL;
-      label = SPLIT_ARCHIVED;
-    } else if (killed) {
-      treatment = defaultTreatment;
-      label = SPLIT_KILLED;
-    } else {
-      const evaluation = this.evaluator(
-        parsedKey,
-        seed,
-        trafficAllocation,
-        trafficAllocationSeed,
-        attributes,
-        splitEvaluator
-      );
 
-      // Evaluation could be async, so we should handle that case checking for a
-      // thenable object
-      if (thenable(evaluation)) {
-        return evaluation.then(result => evaluationResult(result, defaultTreatment));
-      } else {
-        return evaluationResult(evaluation, defaultTreatment);
+      if (killed) {
+        log.debug(ENGINE_DEFAULT, ['Flag is killed']);
+        return {
+          treatment: defaultTreatment,
+          label: SPLIT_KILLED
+        };
       }
-    }
 
-    return {
-      treatment,
-      label
-    };
-  }
+      const prerequisitesMet = prerequisiteMatcher({ key, attributes }, splitEvaluator);
 
-  isGarbage() {
-    return this.baseInfo.status === 'ARCHIVED';
-  }
+      return thenable(prerequisitesMet) ?
+        prerequisitesMet.then(evaluate) :
+        evaluate(prerequisitesMet);
+    }
+  };
 
-  getChangeNumber() {
-    return this.baseInfo.changeNumber;
-  }
 }

package/src/evaluator/combiners/and.ts

@@ -2,10 +2,11 @@ import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
-import { IMatcher } from '../types';
+import { ISplitEvaluator } from '../types';
 import { ENGINE_COMBINER_AND } from '../../logger/constants';
+import SplitIO from '../../../types/splitio';
 
-export function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
+export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>>) {
 
   function andResults(results: boolean[]): boolean {
     // Array.prototype.every is supported by target environments
@@ -15,8 +16,8 @@ export function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
     return hasMatchedAll;
   }
 
-  return function andCombiner(...params: any): MaybeThenable<boolean> {
-    const matcherResults = matchers.map(matcher => matcher(...params));
+  return function andCombiner(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator): MaybeThenable<boolean> {
+    const matcherResults = matchers.map(matcher => matcher(key, attributes, splitEvaluator));
 
     // If any matching result is a thenable we should use Promise.all
     if (findIndex(matcherResults, thenable) !== -1) {

package/src/evaluator/combiners/ifelseif.ts

@@ -1,4 +1,4 @@
-import { findIndex } from '../../utils/lang';
+import { findIndex, isBoolean } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
@@ -18,14 +18,12 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     };
   }
 
-  function computeTreatment(predicateResults: Array<IEvaluation | undefined>) {
-    const len = predicateResults.length;
-
-    for (let i = 0; i < len; i++) {
+  function computeEvaluation(predicateResults: Array<IEvaluation | boolean | undefined>): IEvaluation | boolean | undefined {
+    for (let i = 0, len = predicateResults.length; i < len; i++) {
       const evaluation = predicateResults[i];
 
       if (evaluation !== undefined) {
-        log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
+        if (!isBoolean(evaluation)) log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
 
         return evaluation;
       }
@@ -35,7 +33,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     return undefined;
   }
 
-  function ifElseIfCombiner(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
     // In Async environments we are going to have async predicates. There is none way to know
     // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
     // define how to return the treatment (wrap result into a Promise or not).
@@ -43,10 +41,10 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
 
     // if we find a thenable
     if (findIndex(predicateResults, thenable) !== -1) {
-      return Promise.all(predicateResults).then(results => computeTreatment(results));
+      return Promise.all(predicateResults).then(results => computeEvaluation(results));
     }
 
-    return computeTreatment(predicateResults as IEvaluation[]);
+    return computeEvaluation(predicateResults as IEvaluation[]);
   }
 
   // if there is none predicates, then there was an error in parsing phase

package/src/evaluator/condition/engineUtils.ts

@@ -5,7 +5,7 @@ import { bucket } from '../../utils/murmur3/murmur3';
 /**
  * Get the treatment name given a key, a seed, and the percentage of each treatment.
  */
-export function getTreatment(log: ILogger, key: string, seed: number, treatments: { getTreatmentFor: (x: number) => string }) {
+export function getTreatment(log: ILogger, key: string, seed: number | undefined, treatments: { getTreatmentFor: (x: number) => string }) {
   const _bucket = bucket(key, seed);
 
   const treatment = treatments.getTreatmentFor(_bucket);