@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.1

package/src/storages/AbstractDefinitionsCacheSync.ts

@@ -0,0 +1,95 @@
+import { IDefinitionsCacheSync, IStorageSync } from './types';
+import { IRBSegment, IDefinition } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
+
+/**
+ * This class provides a skeletal implementation of the IDefinitionsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+export abstract class AbstractDefinitionsCacheSync implements IDefinitionsCacheSync {
+
+  protected abstract add(definition: IDefinition): boolean
+  protected abstract remove(name: string): boolean
+  protected abstract setChangeNumber(changeNumber: number): boolean | void
+
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean {
+    let updated = toAdd.map(addedFF => this.add(addedFF)).some(result => result);
+    updated = toRemove.map(removedFF => this.remove(removedFF)).some(result => result) || updated;
+    this.setChangeNumber(changeNumber);
+    return updated;
+  }
+
+  abstract get(name: string): IDefinition | null
+
+  getMany(names: string[]): Record<string, IDefinition | null> {
+    const definitions: Record<string, IDefinition | null> = {};
+    names.forEach(name => {
+      definitions[name] = this.get(name);
+    });
+    return definitions;
+  }
+
+  abstract getChangeNumber(): number
+
+  getAll(): IDefinition[] {
+    return this.getNames().map(key => this.get(key) as IDefinition);
+  }
+
+  abstract getNames(): string[]
+
+  abstract trafficTypeExists(trafficType: string): boolean
+
+  abstract usesSegments(): boolean
+
+  abstract clear(): void
+
+  /**
+   * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
+   * Used for SPLIT_KILL push notifications.
+   *
+   * @returns `true` if the operation successed updating the definition, or `false` if no definition is updated,
+   * for instance, if the `changeNumber` is old, or if the definition is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+   */
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
+    const definition = this.get(name);
+
+    if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
+      const newDefinition = objectAssign({}, definition);
+      newDefinition.killed = true;
+      newDefinition.defaultTreatment = defaultTreatment;
+      newDefinition.changeNumber = changeNumber;
+
+      return this.add(newDefinition);
+    }
+    return false;
+  }
+
+  abstract getNamesBySets(sets: string[]): Set<string>[]
+
+}
+
+/**
+ * Given a parsed definition, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
+ * This util is intended to simplify the implementation of `definitionsCache::usesSegments` method
+ */
+export function usesSegments(ruleEntity: IDefinition | IRBSegment) {
+  const conditions = ruleEntity.conditions || [];
+  for (let i = 0; i < conditions.length; i++) {
+    const matchers = conditions[i].matcherGroup.matchers;
+
+    for (let j = 0; j < matchers.length; j++) {
+      const matcher = matchers[j].matcherType;
+      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
+    }
+  }
+
+  const excluded = (ruleEntity as IRBSegment).excluded;
+  if (excluded && excluded.segments && excluded.segments.length > 0) return true;
+
+  return false;
+}
+
+export function usesSegmentsSync(storage: Pick<IStorageSync, 'definitions' | 'rbSegments'>) {
+  return storage.definitions.usesSegments() || storage.rbSegments.usesSegments();
+}

package/src/storages/KeyBuilder.ts

@@ -21,19 +21,19 @@ export class KeyBuilder {
     return `${this.prefix}.trafficType.${trafficType}`;
   }
 
-  buildFlagSetKey(flagSet: string) {
-    return `${this.prefix}.flagSet.${flagSet}`;
+  buildSetKey(set: string) {
+    return `${this.prefix}.flagSet.${set}`;
   }
 
-  buildSplitKey(splitName: string) {
-    return `${this.prefix}.split.${splitName}`;
+  buildDefinitionKey(definitionName: string) {
+    return `${this.prefix}.split.${definitionName}`;
   }
 
-  buildSplitsTillKey() {
+  buildDefinitionsTillKey() {
     return `${this.prefix}.splits.till`;
   }
 
-  buildSplitKeyPrefix() {
+  buildDefinitionKeyPrefix() {
     return `${this.prefix}.split.`;
   }
 

package/src/storages/KeyBuilderCS.ts

@@ -9,13 +9,13 @@ export interface MySegmentsKeyBuilder {
 
 export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
 
-  protected readonly regexSplitsCacheKey: RegExp;
+  protected readonly regexDefinitionsCacheKey: RegExp;
   protected readonly matchingKey: string;
 
   constructor(prefix: string, matchingKey: string) {
     super(prefix);
     this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
+    this.regexDefinitionsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
   }
 
   /**
@@ -35,15 +35,15 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     return `${this.prefix}.splits.lastUpdated`;
   }
 
-  isSplitsCacheKey(key: string) {
-    return this.regexSplitsCacheKey.test(key);
+  isDefinitionsCacheKey(key: string) {
+    return this.regexDefinitionsCacheKey.test(key);
   }
 
   buildTillKey() {
     return `${this.prefix}.${this.matchingKey}.segments.till`;
   }
 
-  isSplitKey(key: string) {
+  isDefinitionKey(key: string) {
     return startsWith(key, `${this.prefix}.split.`);
   }
 
@@ -51,7 +51,7 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     return startsWith(key, `${this.prefix}.rbsegment.`);
   }
 
-  buildSplitsWithSegmentCountKey() {
+  buildDefinitionsWithSegmentCountKey() {
     return `${this.prefix}.splits.usingSegments`;
   }
 

package/src/storages/KeyBuilderSS.ts

@@ -49,8 +49,8 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.events`;
   }
 
-  searchPatternForSplitKeys() {
-    return `${this.buildSplitKeyPrefix()}*`;
+  searchPatternForDefinitionKeys() {
+    return `${this.buildDefinitionKeyPrefix()}*`;
   }
 
   searchPatternForRBSegmentKeys() {

package/src/storages/getRolloutPlan.ts

@@ -12,16 +12,16 @@ import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
 export function getRolloutPlan(log: ILogger, storage: IStorageSync, options: SplitIO.RolloutPlanOptions = {}): RolloutPlan {
 
   const { keys, exposeSegments } = options;
-  const { splits, segments, rbSegments } = storage;
+  const { definitions, segments, rbSegments } = storage;
 
   log.debug(`storage: get feature flags${keys ? `, and memberships for keys: ${keys}` : ''}${exposeSegments ? ', and segments' : ''}`);
 
   return {
     splitChanges: {
       ff: {
-        t: splits.getChangeNumber(),
+        t: definitions.getChangeNumber(),
         s: -1,
-        d: splits.getAll(),
+        d: definitions.getAll(),
       },
       rbs: {
         t: rbSegments.getChangeNumber(),

package/src/storages/inLocalStorage/DefinitionsCacheInLocal.ts

@@ -0,0 +1,234 @@
+import { IDefinition } from '../../dtos/types';
+import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
+import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import { ILogger } from '../../logger/types';
+import { LOG_PREFIX } from './constants';
+import { ISettings } from '../../types';
+import { setToArray } from '../../utils/lang/sets';
+import { StorageAdapter } from '../types';
+
+export class DefinitionsCacheInLocal extends AbstractDefinitionsCacheSync {
+
+  private readonly keys: KeyBuilderCS;
+  private readonly log: ILogger;
+  private readonly setsFilter: string[];
+  private hasSync?: boolean;
+  private readonly storage: StorageAdapter;
+
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
+    super();
+    this.keys = keys;
+    this.log = settings.log;
+    this.setsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+    this.storage = storage;
+  }
+
+  private _decrementCount(key: string) {
+    const count = toNumber(this.storage.getItem(key)) - 1;
+    if (count > 0) this.storage.setItem(key, count + '');
+    else this.storage.removeItem(key);
+  }
+
+  private _decrementCounts(definition: IDefinition) {
+    try {
+      const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+      this._decrementCount(ttKey);
+
+      if (usesSegments(definition)) {
+        const segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+        this._decrementCount(segmentsCountKey);
+      }
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+    }
+  }
+
+  private _incrementCounts(definition: IDefinition) {
+    try {
+      const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+      this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
+
+      if (usesSegments(definition)) {
+        const segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+        this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
+      }
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+    }
+  }
+
+
+  /**
+   * Removes all definitions related data from localStorage (splits, counters, changeNumber and lastUpdated).
+   * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
+   */
+  clear() {
+    // collect item keys
+    const len = this.storage.length;
+    const accum = [];
+    for (let cur = 0; cur < len; cur++) {
+      const key = this.storage.key(cur);
+      if (key != null && this.keys.isDefinitionsCacheKey(key)) accum.push(key);
+    }
+    // remove items
+    accum.forEach(key => {
+      this.storage.removeItem(key);
+    });
+
+    this.hasSync = false;
+  }
+
+  add(definition: IDefinition) {
+    const name = definition.name;
+    const definitionKey = this.keys.buildDefinitionKey(name);
+    const definitionFromStorage = this.storage.getItem(definitionKey);
+    const previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
+
+    if (previousDefinition) {
+      this._decrementCounts(previousDefinition);
+      this.removeFromSets(previousDefinition.name, previousDefinition.sets);
+    }
+
+    this.storage.setItem(definitionKey, JSON.stringify(definition));
+
+    this._incrementCounts(definition);
+    this.addToSets(definition);
+
+    return true;
+  }
+
+  remove(name: string): boolean {
+    const definition = this.get(name);
+    if (!definition) return false;
+
+    this.storage.removeItem(this.keys.buildDefinitionKey(name));
+
+    this._decrementCounts(definition);
+    this.removeFromSets(definition.name, definition.sets);
+
+    return true;
+  }
+
+  get(name: string): IDefinition | null {
+    const item = this.storage.getItem(this.keys.buildDefinitionKey(name));
+    return item && JSON.parse(item);
+  }
+
+  setChangeNumber(changeNumber: number): boolean {
+    try {
+      this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+      // update "last updated" timestamp with current time
+      this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      this.hasSync = true;
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
+  }
+
+  getChangeNumber(): number {
+    const n = -1;
+    let value: string | number | null = this.storage.getItem(this.keys.buildDefinitionsTillKey());
+
+    if (value !== null) {
+      value = parseInt(value, 10);
+
+      return isNaNNumber(value) ? n : value;
+    }
+
+    return n;
+  }
+
+  getNames(): string[] {
+    const len = this.storage.length;
+    const accum = [];
+
+    let cur = 0;
+
+    while (cur < len) {
+      const key = this.storage.key(cur);
+
+      if (key != null && this.keys.isDefinitionKey(key)) accum.push(this.keys.extractKey(key));
+
+      cur++;
+    }
+
+    return accum;
+  }
+
+  trafficTypeExists(trafficType: string): boolean {
+    const ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+    return isFiniteNumber(ttCount) && ttCount > 0;
+  }
+
+  usesSegments() {
+    // If cache hasn't been synchronized with the cloud, assume we need them.
+    if (!this.hasSync) return true;
+
+    const storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
+    const definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+
+    return isFiniteNumber(definitionsWithSegmentsCount) ?
+      definitionsWithSegmentsCount > 0 :
+      true;
+  }
+
+  getNamesBySets(sets: string[]): Set<string>[] {
+    return sets.map(set => {
+      const setKey = this.keys.buildSetKey(set);
+      const setFromStorage = this.storage.getItem(setKey);
+
+      return new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
+    });
+  }
+
+  private addToSets(definition: IDefinition) {
+    if (!definition.sets) return;
+
+    definition.sets.forEach(set => {
+
+      if (this.setsFilter.length > 0 && !this.setsFilter.some(filterSet => filterSet === set)) return;
+
+      const setKey = this.keys.buildSetKey(set);
+
+      const setFromStorage = this.storage.getItem(setKey);
+
+      const setCache = new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
+
+      if (setCache.has(definition.name)) return;
+
+      setCache.add(definition.name);
+
+      this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
+    });
+  }
+
+  private removeFromSets(definitionName: string, sets?: string[] | null) {
+    if (!sets) return;
+
+    sets.forEach(set => {
+      this.removeNames(set, definitionName);
+    });
+  }
+
+  private removeNames(setName: string, definitionName: string) {
+    const setKey = this.keys.buildSetKey(setName);
+
+    const setFromStorage = this.storage.getItem(setKey);
+
+    if (!setFromStorage) return;
+
+    const setCache = new Set(JSON.parse(setFromStorage));
+    setCache.delete(definitionName);
+
+    if (setCache.size === 0) {
+      this.storage.removeItem(setKey);
+      return;
+    }
+
+    this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
+  }
+
+}

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -3,7 +3,7 @@ import { ILogger } from '../../logger/types';
 import { ISettings } from '../../types';
 import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
+import { usesSegments } from '../AbstractDefinitionsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { IRBSegmentsCacheSync, StorageAdapter } from '../types';
 import { LOG_PREFIX } from './constants';
@@ -42,7 +42,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private updateSegmentCount(diff: number) {
-    const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+    const segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
     const count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
     if (count > 0) this.storage.setItem(segmentsCountKey, count + '');
     else this.storage.removeItem(segmentsCountKey);
@@ -121,11 +121,11 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   usesSegments(): boolean {
-    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+    const storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
+    const definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
+    return isFiniteNumber(definitionsWithSegmentsCount) ?
+      definitionsWithSegmentsCount > 0 :
       true;
   }
 

package/src/storages/inLocalStorage/index.ts

@@ -5,7 +5,7 @@ import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory, StorageAdapte
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
-import { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import { DefinitionsCacheInLocal } from './DefinitionsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
@@ -50,26 +50,26 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
 
-    const splits = new SplitsCacheInLocal(settings, keys, storage);
+    const definitions = new DefinitionsCacheInLocal(settings, keys, storage);
     const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
     const segments = new MySegmentsCacheInLocal(log, keys, storage);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
     let validateCachePromise: Promise<SplitIO.SdkReadyMetadata> | undefined;
 
     return {
-      splits,
+      definitions,
       rbSegments,
       segments,
       largeSegments,
       impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
       impressionCounts: new ImpressionCountsCacheInMemory(),
       events: new EventsCacheInMemory(eventsQueueSize),
-      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
       validateCache() {
         if (!validateCachePromise) {
-          validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+          validateCachePromise = validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments);
         }
         return validateCachePromise;
       },
@@ -86,7 +86,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       shared(matchingKey: string) {
 
         return {
-          splits: this.splits,
+          definitions: this.definitions,
           rbSegments: this.rbSegments,
           segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
           largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),

package/src/storages/inLocalStorage/validateCache.ts

@@ -2,7 +2,7 @@ import { ISettings } from '../../types';
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { getStorageHash } from '../KeyBuilder';
 import { LOG_PREFIX } from './constants';
-import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import type { DefinitionsCacheInLocal } from './DefinitionsCacheInLocal';
 import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { KeyBuilderCS } from '../KeyBuilderCS';
@@ -68,11 +68,11 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: Sto
  *
  * @returns Metadata object with `initialCacheLoad` (true if is fresh install, false if is ready from cache) and `lastUpdateTimestamp` (timestamp of last cache update or undefined)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<SplitIO.SdkReadyMetadata> {
+export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, definitions: DefinitionsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<SplitIO.SdkReadyMetadata> {
 
   return Promise.resolve(storage.load && storage.load()).then(() => {
     const currentTimestamp = Date.now();
-    const isThereCache = splits.getChangeNumber() > -1;
+    const isThereCache = definitions.getChangeNumber() > -1;
 
     // Get lastUpdateTimestamp from storage
     const lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
@@ -80,7 +80,7 @@ export function validateCache(options: SplitIO.InLocalStorageOptions, storage: S
     const lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== undefined) ? lastUpdatedTimestamp : undefined;
 
     if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-      splits.clear();
+      definitions.clear();
       rbSegments.clear();
       segments.clear();
       largeSegments.clear();

package/src/storages/inMemory/DefinitionsCacheInMemory.ts

@@ -0,0 +1,130 @@
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
+import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
+import { isFiniteNumber } from '../../utils/lang';
+
+/**
+ * Default IDefinitionsCacheSync implementation that stores split definitions in memory.
+ */
+export class DefinitionsCacheInMemory extends AbstractDefinitionsCacheSync {
+
+  private setsFilter: string[];
+  private definitionsCache: Record<string, IDefinition> = {};
+  private ttCache: Record<string, number> = {};
+  private changeNumber: number = -1;
+  private segmentsCount: number = 0;
+  private setsCache: Record<string, Set<string>> = {};
+
+  constructor(splitFiltersValidation?: ISplitFiltersValidation) {
+    super();
+    this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+  }
+
+  clear() {
+    this.definitionsCache = {};
+    this.ttCache = {};
+    this.changeNumber = -1;
+    this.segmentsCount = 0;
+    this.setsCache = {};
+  }
+
+  add(definition: IDefinition): boolean {
+    const name = definition.name;
+    const previousDefinition = this.get(name);
+    if (previousDefinition) { // We had this Split already
+
+      const previousTtName = previousDefinition.trafficTypeName;
+      this.ttCache[previousTtName]--;
+      if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
+
+      this.removeFromFlagSets(previousDefinition.name, previousDefinition.sets);
+
+      // Subtract from segments count for the previous version of this Split
+      if (usesSegments(previousDefinition)) this.segmentsCount--;
+    }
+
+    // Store the Split.
+    this.definitionsCache[name] = definition;
+    // Update TT cache
+    const ttName = definition.trafficTypeName;
+    this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+    this.addToFlagSets(definition);
+
+    // Add to segments count for the new version of the Split
+    if (usesSegments(definition)) this.segmentsCount++;
+
+    return true;
+  }
+
+  remove(name: string): boolean {
+    const definition = this.get(name);
+    if (!definition) return false;
+
+    // Delete the Split
+    delete this.definitionsCache[name];
+
+    const ttName = definition.trafficTypeName;
+    this.ttCache[ttName]--; // Update tt cache
+    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+    this.removeFromFlagSets(definition.name, definition.sets);
+
+    // Update the segments count.
+    if (usesSegments(definition)) this.segmentsCount--;
+
+    return true;
+  }
+
+  get(name: string): IDefinition | null {
+    return this.definitionsCache[name] || null;
+  }
+
+  setChangeNumber(changeNumber: number): boolean {
+    this.changeNumber = changeNumber;
+    return true;
+  }
+
+  getChangeNumber(): number {
+    return this.changeNumber;
+  }
+
+  getNames(): string[] {
+    return Object.keys(this.definitionsCache);
+  }
+
+  trafficTypeExists(trafficType: string): boolean {
+    return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
+  }
+
+  usesSegments(): boolean {
+    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+  }
+
+  getNamesBySets(sets: string[]): Set<string>[] {
+    return sets.map(set => this.setsCache[set] || new Set());
+  }
+
+  private addToFlagSets(featureFlag: IDefinition) {
+    if (!featureFlag.sets) return;
+    featureFlag.sets.forEach(featureFlagSet => {
+
+      if (this.setsFilter.length > 0 && !this.setsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
+
+      if (!this.setsCache[featureFlagSet]) this.setsCache[featureFlagSet] = new Set([]);
+
+      this.setsCache[featureFlagSet].add(featureFlag.name);
+    });
+  }
+
+  private removeFromFlagSets(featureFlagName: string, sets?: string[] | null) {
+    if (!sets) return;
+    sets.forEach(set => {
+      this.removeNames(set, featureFlagName);
+    });
+  }
+
+  private removeNames(setName: string, featureFlagName: string) {
+    if (!this.setsCache[setName]) return;
+    this.setsCache[setName].delete(featureFlagName);
+    if (this.setsCache[setName].size === 0) delete this.setsCache[setName];
+  }
+
+}