@splitsoftware/splitio-commons 2.2.1-rc.0 → 2.2.1-rc.2

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

@@ -1,132 +1,103 @@
-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, 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();
+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;
                     }
                     else {
-                        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();
-                        }
+                        backoff.reset();
+                        cdnBypass = true;
+                        __handleSplitUpdateCall();
                     }
-                });
-            }
-            else {
-                isHandlingEvent = false;
-            }
-        }
-        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();
-            }
-        };
+            });
+        }
+        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;
+        }
+        if (backoff.timeoutID || !isHandlingEvent)
+            __handleSplitUpdateCall();
+        backoff.reset();
     }
     return {
-        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);
-        },
+        put: put,
         /**
          * Invoked by NotificationProcessor on SPLIT_KILL event
          *
-         * @param changeNumber - change number of the notification
+         * @param changeNumber - change number of the SPLIT_UPDATE 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 (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+            if (splitsCache.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)
-            ff.put({ changeNumber: changeNumber });
+            put({ changeNumber: changeNumber });
         },
         stop: function () {
-            ff.stop();
-            rbs.stop();
+            isHandlingEvent = false;
+            backoff.reset();
         }
     };
 }

package/esm/sync/streaming/constants.js

@@ -27,7 +27,6 @@ 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, 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 { 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 { UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, 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, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, 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,8 +179,21 @@ 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, splitsUpdateWorker.put);
-    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+    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);
+    });
     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() || storage.rbSegments.usesSegments())
+                                if (storage.splits.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -137,7 +137,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                             }
                         }
                         else {
-                            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                            if (storage.splits.usesSegments())
                                 mySegmentsSyncTask.start();
                         }
                     }

package/esm/utils/constants/index.js

@@ -86,8 +86,7 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAG_SPEC_VERSION = '1.3';
+export var FLAG_SPEC_VERSION = '1.2';
 // 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';

package/esm/utils/labels/index.js

@@ -6,4 +6,3 @@ 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.2.1-rc.0",
+  "version": "2.2.1-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -66,11 +66,6 @@ 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
@@ -181,7 +176,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 | IInRBSegmentMatcher
+  IInLargeSegmentMatcher
 
 /** Split object */
 export interface ISplitPartition {
@@ -194,34 +189,19 @@ export interface ISplitCondition {
     combiner: 'AND',
     matchers: ISplitMatcher[]
   }
-  partitions?: ISplitPartition[]
-  label?: string
-  conditionType?: 'ROLLOUT' | 'WHITELIST'
-}
-
-export interface IRBSegment {
-  name: string,
-  changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[],
-  excluded?: {
-    keys?: string[],
-    segments?: string[]
-  }
+  partitions: ISplitPartition[]
+  label: string
+  conditionType: 'ROLLOUT' | 'WHITELIST'
 }
 
 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
@@ -237,16 +217,8 @@ export type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'traf
 
 /** Interface of the parsed JSON response of `/splitChanges` */
 export interface ISplitChangesResponse {
-  ff?: {
-    t: number,
-    s?: number,
-    d: ISplit[]
-  },
-  rbs?: {
-    t: number,
-    s?: number,
-    d: IRBSegment[]
-  }
+  till: number,
+  splits: ISplit[]
 }
 
 /** Interface of the parsed JSON response of `/segmentChanges/{segmentName}` */

package/src/evaluator/Engine.ts

@@ -1,16 +1,14 @@
-import { get, isString } from '../utils/lang';
+import { get } 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 { EXCEPTION, NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED } 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, ISplitEvaluator } from './types';
+import { IEvaluation, IEvaluationResult, IEvaluator, 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 {
@@ -19,55 +17,84 @@ function evaluationResult(result: IEvaluation | undefined, defaultTreatment: str
   };
 }
 
-export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync) {
-  const { killed, seed, trafficAllocation, trafficAllocationSeed, status, conditions, prerequisites } = split;
+export class Engine {
 
-  const defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
+  constructor(private baseInfo: ISplit, private evaluator: IEvaluator) {
 
-  const evaluator = parser(log, conditions, storage);
-  const prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log);
-
-  return {
-
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+    // 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 parsedKey = keyParser(key);
+  static parse(log: ILogger, splitFlatStructure: ISplit, storage: IStorageSync | IStorageAsync) {
+    const conditions = splitFlatStructure.conditions;
+    const evaluator = parser(log, conditions, storage);
 
-      function evaluate(prerequisitesMet: boolean) {
-        if (!prerequisitesMet) {
-          log.debug(ENGINE_DEFAULT, ['Prerequisite not met']);
-          return {
-            treatment: defaultTreatment,
-            label: PREREQUISITES_NOT_MET
-          };
-        }
+    return new Engine(splitFlatStructure, evaluator);
+  }
 
-        const evaluation = evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) as MaybeThenable<IEvaluation>;
+  getKey() {
+    return this.baseInfo.name;
+  }
 
-        return thenable(evaluation) ?
-          evaluation.then(result => evaluationResult(result, defaultTreatment)) :
-          evaluationResult(evaluation, defaultTreatment);
-      }
+  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;
 
-      if (status === 'ARCHIVED') return {
+    try {
+      parsedKey = keyParser(key);
+    } catch (err) {
+      return {
         treatment: CONTROL,
-        label: SPLIT_ARCHIVED
+        label: EXCEPTION
       };
+    }
+
+    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
+      );
 
-      if (killed) {
-        log.debug(ENGINE_DEFAULT, ['Flag is killed']);
-        return {
-          treatment: defaultTreatment,
-          label: SPLIT_KILLED
-        };
+      // 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);
       }
+    }
 
-      const prerequisitesMet = prerequisiteMatcher({ key, attributes }, splitEvaluator);
+    return {
+      treatment,
+      label
+    };
+  }
 
-      return thenable(prerequisitesMet) ?
-        prerequisitesMet.then(evaluate) :
-        evaluate(prerequisitesMet);
-    }
-  };
+  isGarbage() {
+    return this.baseInfo.status === 'ARCHIVED';
+  }
 
+  getChangeNumber() {
+    return this.baseInfo.changeNumber;
+  }
 }

package/src/evaluator/combiners/and.ts

@@ -2,11 +2,10 @@ import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
-import { ISplitEvaluator } from '../types';
+import { IMatcher } from '../types';
 import { ENGINE_COMBINER_AND } from '../../logger/constants';
-import SplitIO from '../../../types/splitio';
 
-export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>>) {
+export function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
 
   function andResults(results: boolean[]): boolean {
     // Array.prototype.every is supported by target environments
@@ -16,8 +15,8 @@ export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.S
     return hasMatchedAll;
   }
 
-  return function andCombiner(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator): MaybeThenable<boolean> {
-    const matcherResults = matchers.map(matcher => matcher(key, attributes, splitEvaluator));
+  return function andCombiner(...params: any): MaybeThenable<boolean> {
+    const matcherResults = matchers.map(matcher => matcher(...params));
 
     // 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, isBoolean } from '../../utils/lang';
+import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
@@ -18,12 +18,14 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     };
   }
 
-  function computeEvaluation(predicateResults: Array<IEvaluation | boolean | undefined>): IEvaluation | boolean | undefined {
-    for (let i = 0, len = predicateResults.length; i < len; i++) {
+  function computeTreatment(predicateResults: Array<IEvaluation | undefined>) {
+    const len = predicateResults.length;
+
+    for (let i = 0; i < len; i++) {
       const evaluation = predicateResults[i];
 
       if (evaluation !== undefined) {
-        if (!isBoolean(evaluation)) log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
+        log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
 
         return evaluation;
       }
@@ -33,7 +35,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     return undefined;
   }
 
-  function ifElseIfCombiner(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitIO.SplitKey, 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).
@@ -41,10 +43,10 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
 
     // if we find a thenable
     if (findIndex(predicateResults, thenable) !== -1) {
-      return Promise.all(predicateResults).then(results => computeEvaluation(results));
+      return Promise.all(predicateResults).then(results => computeTreatment(results));
     }
 
-    return computeEvaluation(predicateResults as IEvaluation[]);
+    return computeTreatment(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 | undefined, treatments: { getTreatmentFor: (x: number) => string }) {
+export function getTreatment(log: ILogger, key: string, seed: number, treatments: { getTreatmentFor: (x: number) => string }) {
   const _bucket = bucket(key, seed);
 
   const treatment = treatments.getTreatmentFor(_bucket);