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

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -1,192 +0,0 @@
-import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
-import { startsWith } from '../../../utils/lang';
-import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
-import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments) {
-    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-    return registeredSegments.then(function (segmentNames) {
-        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
-    });
-}
-/**
- * Collect segments from a raw FF or RBS definition.
- * Exported for testing purposes.
- */
-export function parseSegments(ruleEntity, matcherType) {
-    if (matcherType === void 0) { matcherType = IN_SEGMENT; }
-    var _a = ruleEntity, _b = _a.conditions, conditions = _b === void 0 ? [] : _b, excluded = _a.excluded;
-    var segments = new Set();
-    if (excluded && excluded.segments) {
-        excluded.segments.forEach(function (_a) {
-            var type = _a.type, name = _a.name;
-            if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
-                segments.add(name);
-            }
-        });
-    }
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        matchers.forEach(function (matcher) {
-            if (matcher.matcherType === matcherType)
-                segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-        });
-    }
-    return segments;
-}
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
- *
- * @param featureFlag - feature flag to be evaluated
- * @param filters - splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag, filters) {
-    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
-    if (setsFilter.length > 0)
-        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
-    var namesFilterConfigured = namesFilter.length > 0;
-    var prefixFilterConfigured = prefixFilter.length > 0;
-    if (!namesFilterConfigured && !prefixFilterConfigured)
-        return true;
-    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return startsWith(featureFlag.name, prefix); });
-    return matchNames || matchPrefix;
-}
-/**
- * Given the list of splits from /splitChanges endpoint, it returns the mutations,
- * i.e., an object with added splits, removed splits and used segments.
- * Exported for testing purposes.
- */
-export function computeMutation(rules, segments, filters) {
-    return rules.reduce(function (accum, ruleEntity) {
-        if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity, filters))) {
-            accum.added.push(ruleEntity);
-            parseSegments(ruleEntity).forEach(function (segmentName) {
-                segments.add(segmentName);
-            });
-        }
-        else {
-            accum.removed.push(ruleEntity);
-        }
-        accum.names.push(ruleEntity.name);
-        return accum;
-    }, { added: [], removed: [], names: [] });
-}
-/**
- * factory of SplitChanges updater, a task that:
- *  - fetches split changes using `splitChangesFetcher`
- *  - updates `splitsCache`
- *  - uses `splitsEventEmitter` to emit events related to split data updates
- *
- * @param log -  Logger instance
- * @param splitChangesFetcher -  Fetcher of `/splitChanges`
- * @param splits -  Splits storage, with sync or async methods
- * @param segments -  Segments storage, with sync or async methods
- * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
- * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
- */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
-    if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
-    if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments;
-    var startingUp = true;
-    /** timeout decorator for `splitChangesFetcher` promise  */
-    function _promiseDecorator(promise) {
-        if (startingUp && requestTimeoutBeforeReady)
-            promise = timeout(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    /**
-     * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
-     * Returned promise will not be rejected.
-     *
-     * @param noCache - true to revalidate data to fetch
-     * @param till - query param to bypass CDN requests
-     */
-    return function splitChangesUpdater(noCache, till, instantUpdate) {
-        /**
-         * @param since - current changeNumber at splitsCache
-         * @param retry - current number of retry attempts
-         */
-        function _splitChangesUpdater(sinces, retry) {
-            if (retry === void 0) { retry = 0; }
-            var since = sinces[0], rbSince = sinces[1];
-            log.debug(SYNC_SPLITS_FETCH, sinces);
-            return Promise.resolve(instantUpdate ?
-                instantUpdate.type === SPLIT_UPDATE ?
-                    // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
-                    Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then(function (contains) {
-                        return contains ?
-                            { ff: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                            splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-                    }) :
-                    { rbs: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
-                .then(function (splitChanges) {
-                var usedSegments = new Set();
-                var updatedFlags = [];
-                var ffUpdate = false;
-                if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
-                    updatedFlags = names;
-                    log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-                    ffUpdate = splits.update(added, removed, splitChanges.ff.t);
-                }
-                var rbsUpdate = false;
-                if (splitChanges.rbs) {
-                    var _b = computeMutation(splitChanges.rbs.d, usedSegments), added = _b.added, removed = _b.removed;
-                    log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
-                    rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
-                }
-                return Promise.all([ffUpdate, rbsUpdate,
-                    // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
-                    segments.registerSegments(setToArray(usedSegments))
-                ]).then(function (_a) {
-                    var ffChanged = _a[0], rbsChanged = _a[1];
-                    if (storage.save)
-                        storage.save();
-                    startingUp = false;
-                    if (splitsEventEmitter) {
-                        // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
-                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                            .then(function (emitSplitsArrivedEvent) {
-                            // emit SDK events
-                            if (emitSplitsArrivedEvent) {
-                                var metadata = {
-                                    type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
-                                    names: updatedFlags.length > 0 ? updatedFlags : []
-                                };
-                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
-                            }
-                            return true;
-                        });
-                    }
-                    return true;
-                });
-            })
-                .catch(function (error) {
-                if (startingUp && retriesOnFailureBeforeReady > retry) {
-                    retry += 1;
-                    log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-                    return _splitChangesUpdater(sinces, retry);
-                }
-                else {
-                    startingUp = false;
-                    log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
-                }
-                return false;
-            });
-        }
-        // `getChangeNumber` never rejects or throws error
-        return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
-    };
-}

package/esm/utils/inputValidation/splitExistence.js

@@ -1,15 +0,0 @@
-import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
-/**
- * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
- */
-export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
-    if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
-            log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
-            return false;
-        }
-    }
-    return true;
-}

package/esm/utils/inputValidation/splits.js

@@ -1,21 +0,0 @@
-import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { uniq } from '../lang';
-import { validateSplit } from './split';
-export function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = validateSplit(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return uniq(validatedArray_1);
-    }
-    log.error(ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,63 +0,0 @@
-import { ISplitsCacheAsync } from './types';
-import { ISplit } from '../dtos/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-
-  protected abstract addSplit(split: ISplit): Promise<boolean>
-  protected abstract removeSplit(name: string): Promise<boolean>
-  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
-
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean> {
-    return Promise.all([
-      this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
-      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF.name)))
-    ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
-    });
-  }
-
-  abstract getSplit(name: string): Promise<ISplit | null>
-  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
-  abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<ISplit[]>
-  abstract getSplitNames(): Promise<string[]>
-  abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
-  abstract trafficTypeExists(trafficType: string): Promise<boolean>
-  abstract clear(): Promise<boolean | void>
-
-  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-  // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-  usesSegments(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-   * The promise will never be rejected.
-   */
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
-    return this.getSplit(name).then(split => {
-
-      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-        const newSplit = objectAssign({}, split);
-        newSplit.killed = true;
-        newSplit.defaultTreatment = defaultTreatment;
-        newSplit.changeNumber = changeNumber;
-
-        return this.addSplit(newSplit);
-      }
-      return false;
-    }).catch(() => false);
-  }
-
-}

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,95 +0,0 @@
-import { ISplitsCacheSync, IStorageSync } from './types';
-import { IRBSegment, ISplit } 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 ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-
-  protected abstract addSplit(split: ISplit): boolean
-  protected abstract removeSplit(name: string): boolean
-  protected abstract setChangeNumber(changeNumber: number): boolean | void
-
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
-    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
-    this.setChangeNumber(changeNumber);
-    return updated;
-  }
-
-  abstract getSplit(name: string): ISplit | null
-
-  getSplits(names: string[]): Record<string, ISplit | null> {
-    const splits: Record<string, ISplit | null> = {};
-    names.forEach(name => {
-      splits[name] = this.getSplit(name);
-    });
-    return splits;
-  }
-
-  abstract getChangeNumber(): number
-
-  getAll(): ISplit[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
-  }
-
-  abstract getSplitNames(): string[]
-
-  abstract trafficTypeExists(trafficType: string): boolean
-
-  abstract usesSegments(): boolean
-
-  abstract clear(): void
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split 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 split = this.getSplit(name);
-
-    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-      const newSplit = objectAssign({}, split);
-      newSplit.killed = true;
-      newSplit.defaultTreatment = defaultTreatment;
-      newSplit.changeNumber = changeNumber;
-
-      return this.addSplit(newSplit);
-    }
-    return false;
-  }
-
-  abstract getNamesByFlagSets(flagSets: string[]): Set<string>[]
-
-}
-
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export function usesSegments(ruleEntity: ISplit | 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, 'splits' | 'rbSegments'>) {
-  return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,234 +0,0 @@
-import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-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 SplitsCacheInLocal extends AbstractSplitsCacheSync {
-
-  private readonly keys: KeyBuilderCS;
-  private readonly log: ILogger;
-  private readonly flagSetsFilter: string[];
-  private hasSync?: boolean;
-  private readonly storage: StorageAdapter;
-
-  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
-    super();
-    this.keys = keys;
-    this.log = settings.log;
-    this.flagSetsFilter = 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(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this._decrementCount(ttKey);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this._decrementCount(segmentsCountKey);
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-  private _incrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-
-  /**
-   * Removes all splits cache 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.isSplitsCacheKey(key)) accum.push(key);
-    }
-    // remove items
-    accum.forEach(key => {
-      this.storage.removeItem(key);
-    });
-
-    this.hasSync = false;
-  }
-
-  addSplit(split: ISplit) {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    const splitFromStorage = this.storage.getItem(splitKey);
-    const previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-
-    if (previousSplit) {
-      this._decrementCounts(previousSplit);
-      this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-    }
-
-    this.storage.setItem(splitKey, JSON.stringify(split));
-
-    this._incrementCounts(split);
-    this.addToFlagSets(split);
-
-    return true;
-  }
-
-  removeSplit(name: string): boolean {
-    const split = this.getSplit(name);
-    if (!split) return false;
-
-    this.storage.removeItem(this.keys.buildSplitKey(name));
-
-    this._decrementCounts(split);
-    this.removeFromFlagSets(split.name, split.sets);
-
-    return true;
-  }
-
-  getSplit(name: string): ISplit | null {
-    const item = this.storage.getItem(this.keys.buildSplitKey(name));
-    return item && JSON.parse(item);
-  }
-
-  setChangeNumber(changeNumber: number): boolean {
-    try {
-      this.storage.setItem(this.keys.buildSplitsTillKey(), 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.buildSplitsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  getSplitNames(): 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.isSplitKey(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.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
-  }
-
-  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
-    return flagSets.map(flagSet => {
-      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-      return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-    });
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
-
-      const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-      const flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-
-      if (flagSetCache.has(featureFlag.name)) return;
-
-      flagSetCache.add(featureFlag.name);
-
-      this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
-    if (!flagSets) return;
-
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-
-    const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-    if (!flagSetFromStorage) return;
-
-    const flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-    flagSetCache.delete(featureFlagName);
-
-    if (flagSetCache.size === 0) {
-      this.storage.removeItem(flagSetKey);
-      return;
-    }
-
-    this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-  }
-
-}