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

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,130 +0,0 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber } from '../../utils/lang';
-
-/**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- */
-export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
-
-  private flagSetsFilter: string[];
-  private splitsCache: Record<string, ISplit> = {};
-  private ttCache: Record<string, number> = {};
-  private changeNumber: number = -1;
-  private segmentsCount: number = 0;
-  private flagSetsCache: Record<string, Set<string>> = {};
-
-  constructor(splitFiltersValidation?: ISplitFiltersValidation) {
-    super();
-    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-  }
-
-  clear() {
-    this.splitsCache = {};
-    this.ttCache = {};
-    this.changeNumber = -1;
-    this.segmentsCount = 0;
-    this.flagSetsCache = {};
-  }
-
-  addSplit(split: ISplit): boolean {
-    const name = split.name;
-    const previousSplit = this.getSplit(name);
-    if (previousSplit) { // We had this Split already
-
-      const previousTtName = previousSplit.trafficTypeName;
-      this.ttCache[previousTtName]--;
-      if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
-
-      this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-
-      // Subtract from segments count for the previous version of this Split
-      if (usesSegments(previousSplit)) this.segmentsCount--;
-    }
-
-    // Store the Split.
-    this.splitsCache[name] = split;
-    // Update TT cache
-    const ttName = split.trafficTypeName;
-    this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-    this.addToFlagSets(split);
-
-    // Add to segments count for the new version of the Split
-    if (usesSegments(split)) this.segmentsCount++;
-
-    return true;
-  }
-
-  removeSplit(name: string): boolean {
-    const split = this.getSplit(name);
-    if (!split) return false;
-
-    // Delete the Split
-    delete this.splitsCache[name];
-
-    const ttName = split.trafficTypeName;
-    this.ttCache[ttName]--; // Update tt cache
-    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-    this.removeFromFlagSets(split.name, split.sets);
-
-    // Update the segments count.
-    if (usesSegments(split)) this.segmentsCount--;
-
-    return true;
-  }
-
-  getSplit(name: string): ISplit | null {
-    return this.splitsCache[name] || null;
-  }
-
-  setChangeNumber(changeNumber: number): boolean {
-    this.changeNumber = changeNumber;
-    return true;
-  }
-
-  getChangeNumber(): number {
-    return this.changeNumber;
-  }
-
-  getSplitNames(): string[] {
-    return Object.keys(this.splitsCache);
-  }
-
-  trafficTypeExists(trafficType: string): boolean {
-    return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-  }
-
-  usesSegments(): boolean {
-    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
-  }
-
-  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
-    return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new Set());
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new Set([]);
-
-      this.flagSetsCache[featureFlagSet].add(featureFlag.name);
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName: string, flagSets: string[] | undefined) {
-    if (!flagSets) return;
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    if (!this.flagSetsCache[flagSetName]) return;
-    this.flagSetsCache[flagSetName].delete(featureFlagName);
-    if (this.flagSetsCache[flagSetName].size === 0) delete this.flagSetsCache[flagSetName];
-  }
-
-}

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -1,230 +0,0 @@
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { KeyBuilder } from '../KeyBuilder';
-import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../logger/types';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { LOG_PREFIX } from './constants';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { returnDifference } from '../../utils/lang/sets';
-
-/**
- * ISplitsCacheAsync implementation for pluggable storages.
- */
-export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly keys: KeyBuilder;
-  private readonly wrapper: IPluggableStorageWrapper;
-  private readonly flagSetsFilter: string[];
-
-  /**
-   * Create a SplitsCache that uses a storage wrapper.
-   * @param log -  Logger instance.
-   * @param keys -  Key builder.
-   * @param wrapper -  Adapted wrapper storage.
-   */
-  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation) {
-    super();
-    this.log = log;
-    this.keys = keys;
-    this.wrapper = wrapper;
-    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-  }
-
-  private _decrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-    return this.wrapper.decr(ttKey).then(count => {
-      if (count === 0) return this.wrapper.del(ttKey);
-    });
-  }
-
-  private _incrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-    return this.wrapper.incr(ttKey);
-  }
-
-  private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-
-    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-    if (this.flagSetsFilter.length > 0) {
-      addToFlagSets = addToFlagSets.filter(flagSet => {
-        return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);
-      });
-    }
-
-    const items = [featureFlagName];
-
-    return Promise.all([
-      ...removeFromFlagSets.map(flagSetName => this.wrapper.removeItems(this.keys.buildFlagSetKey(flagSetName), items)),
-      ...addToFlagSets.map(flagSetName => this.wrapper.addItems(this.keys.buildFlagSetKey(flagSetName), items))
-    ]);
-  }
-
-  /**
-   * Add a given split.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., wrapper operation fails)
-   */
-  addSplit(split: ISplit): Promise<boolean> {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    return this.wrapper.get(splitKey).then(splitFromStorage => {
-
-      // handling parsing error
-      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
-      try {
-        parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        stringifiedNewSplit = JSON.stringify(split);
-      } catch (e) {
-        throw new Error('Error parsing feature flag definition: ' + e);
-      }
-
-      return this.wrapper.set(splitKey, stringifiedNewSplit).then(() => {
-        // avoid unnecessary increment/decrement operations
-        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
-
-        // update traffic type counts
-        return this._incrementCounts(split).then(() => {
-          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
-        });
-      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
-    }).then(() => true);
-  }
-
-  /**
-   * Remove a given split.
-   * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  removeSplit(name: string) {
-    return this.getSplit(name).then((split) => {
-      if (split) {
-        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
-      }
-    }).then(() => {
-      return this.wrapper.del(this.keys.buildSplitKey(name));
-    });
-  }
-
-  /**
-   * Get split.
-   * The returned promise is resolved with the split definition or null if it's not defined,
-   * or rejected if wrapper operation fails.
-   */
-  getSplit(name: string): Promise<ISplit | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name))
-      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
-  }
-
-  /**
-   * Get list of splits.
-   * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
-   * or rejected if wrapper operation fails.
-   */
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
-    const keys = names.map(name => this.keys.buildSplitKey(name));
-
-    return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, ISplit | null> = {};
-      names.forEach((name, idx) => {
-        const split = splitDefinitions[idx];
-        splits[name] = split && JSON.parse(split);
-      });
-      return Promise.resolve(splits);
-    });
-  }
-
-  /**
-   * Get list of all split definitions.
-   * The returned promise is resolved with the list of split definitions,
-   * or rejected if wrapper operation fails.
-   */
-  getAll(): Promise<ISplit[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
-      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
-      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
-        return JSON.parse(splitDefinition as string);
-      }));
-  }
-
-  /**
-   * Get list of split names.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if wrapper operation fails.
-   */
-  getSplitNames(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
-    );
-  }
-
-  /**
-   * Get list of feature flag names related to a given list of flag set names.
-   * The returned promise is resolved with the list of feature flag names per flag set.
-   * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
-   */
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
-    return Promise.all(flagSets.map(flagSet => {
-      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      return this.wrapper.getItems(flagSetKey).catch(() => []);
-    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
-  }
-
-  /**
-   * Check traffic type existence.
-   * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-   * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
-   * It will never be rejected.
-   */
-  trafficTypeExists(trafficType: string): Promise<boolean> {
-    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-    return this.wrapper.get(this.keys.buildTrafficTypeKey(trafficType))
-      .then((ttCount: string | null | number) => {
-        if (ttCount === null) return false; // if entry doesn't exist, means that TT doesn't exist
-
-        ttCount = parseInt(ttCount as string, 10);
-        if (!isFiniteNumber(ttCount) || ttCount < 0) {
-          this.log.info(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to data corruption of some sorts.`);
-          return false;
-        }
-
-        return ttCount > 0;
-      }).catch(e => {
-        this.log.error(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to an error: ${e}.`);
-        // If there is an error, bypass the validation so the event can get tracked.
-        return true;
-      });
-  }
-
-  /**
-   * Set till number.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  setChangeNumber(changeNumber: number) {
-    return this.wrapper.set(this.keys.buildSplitsTillKey(), changeNumber + '');
-  }
-
-  /**
-   * Get till number or -1 if it's not defined.
-   * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
-   * The promise will never be rejected.
-   */
-  getChangeNumber(): Promise<number> {
-    return this.wrapper.get(this.keys.buildSplitsTillKey()).then((value) => {
-      const i = parseInt(value as string, 10);
-
-      return isNaNNumber(i) ? -1 : i;
-    }).catch((e) => {
-      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
-      return -1;
-    });
-  }
-
-  // @TODO implement if required by DataLoader or producer mode
-  clear() {
-    return Promise.resolve(true);
-  }
-
-}

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -1,230 +0,0 @@
-import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
-import { ISplitChangesFetcher } from '../fetchers/types';
-import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
-import { ISplitsEventEmitter } from '../../../readiness/types';
-import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
-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';
-import { SdkUpdateMetadata } from '../../../../types/splitio';
-
-export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
-type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
-
-// 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: ISegmentsCacheBase): Promise<boolean> {
-  let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-  return registeredSegments.then(segmentNames => {
-    return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
-      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
-  });
-}
-
-/**
- * Collect segments from a raw FF or RBS definition.
- * Exported for testing purposes.
- */
-export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
-  const { conditions = [], excluded } = ruleEntity as IRBSegment;
-
-  const segments = new Set<string>();
-  if (excluded && excluded.segments) {
-    excluded.segments.forEach(({ type, name }) => {
-      if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
-        segments.add(name);
-      }
-    });
-  }
-
-  for (let i = 0; i < conditions.length; i++) {
-    const matchers = conditions[i].matcherGroup.matchers;
-
-    matchers.forEach(matcher => {
-      if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-    });
-  }
-
-  return segments;
-}
-
-interface ISplitMutations<T extends ISplit | IRBSegment> {
-  added: T[],
-  removed: T[],
-  names: string[]
-}
-
-/**
- * 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: ISplit, filters: ISplitFiltersValidation) {
-  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
-  if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
-
-  const namesFilterConfigured = namesFilter.length > 0;
-  const prefixFilterConfigured = prefixFilter.length > 0;
-
-  if (!namesFilterConfigured && !prefixFilterConfigured) return true;
-
-  const matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => 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<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
-
-  return rules.reduce((accum, ruleEntity) => {
-    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
-      accum.added.push(ruleEntity);
-
-      parseSegments(ruleEntity).forEach((segmentName: string) => {
-        segments.add(segmentName);
-      });
-    } else {
-      accum.removed.push(ruleEntity);
-    }
-    accum.names.push(ruleEntity.name);
-
-    return accum;
-  }, { added: [], removed: [], names: [] } as ISplitMutations<T>);
-}
-
-/**
- * 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: ILogger,
-  splitChangesFetcher: ISplitChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
-  splitFiltersValidation: ISplitFiltersValidation,
-  splitsEventEmitter?: ISplitsEventEmitter,
-  requestTimeoutBeforeReady = 0,
-  retriesOnFailureBeforeReady = 0,
-  isClientSide?: boolean
-): SplitChangesUpdater {
-  const { splits, rbSegments, segments } = storage;
-
-  let startingUp = true;
-
-  /** timeout decorator for `splitChangesFetcher` promise  */
-  function _promiseDecorator<T>(promise: Promise<T>) {
-    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?: boolean, till?: number, instantUpdate?: InstantUpdate) {
-
-    /**
-     * @param since - current changeNumber at splitsCache
-     * @param retry - current number of retry attempts
-     */
-    function _splitChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
-      const [since, rbSince] = sinces;
-      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((contains) => {
-              return contains ?
-                { ff: { d: [instantUpdate.payload as ISplit], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-            }) :
-            { rbs: { d: [instantUpdate.payload as IRBSegment], t: instantUpdate.changeNumber } } :
-          splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
-      )
-        .then((splitChanges: ISplitChangesResponse) => {
-          const usedSegments = new Set<string>();
-
-          let updatedFlags: string[] = [];
-          let ffUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.ff) {
-            const { added, removed, names } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
-            updatedFlags = names;
-            log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-            ffUpdate = splits.update(added, removed, splitChanges.ff.t);
-          }
-
-          let rbsUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.rbs) {
-            const { added, removed } = computeMutation(splitChanges.rbs.d, usedSegments);
-            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(([ffChanged, rbsChanged]) => {
-            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(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                .then(emitSplitsArrivedEvent => {
-                  // emit SDK events
-                  if (emitSplitsArrivedEvent) {
-                    const metadata: SdkUpdateMetadata = {
-                      type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
-                      names: updatedFlags.length > 0 ? updatedFlags : []
-                    };
-                    splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
-                  }
-                  return true;
-                });
-            }
-            return true;
-          });
-        })
-        .catch(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/src/utils/inputValidation/split.ts

@@ -1,27 +0,0 @@
-import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { isString } from '../lang';
-
-// include BOM and nbsp
-const TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-
-export function validateSplit(log: ILogger, maybeSplit: any, method: string, item = 'feature flag name'): string | false {
-  if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
-    log.error(ERROR_NULL, [method, item]);
-  } else if (!isString(maybeSplit)) {
-    log.error(ERROR_INVALID, [method, item]);
-  } else {
-    if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
-      log.warn(WARN_TRIMMING, [method, item, maybeSplit]);
-      maybeSplit = maybeSplit.trim();
-    }
-
-    if (maybeSplit.length > 0) {
-      return maybeSplit;
-    } else {
-      log.error(ERROR_EMPTY, [method, item]);
-    }
-  }
-
-  return false;
-}

package/src/utils/inputValidation/splitExistence.ts

@@ -1,19 +0,0 @@
-import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
-import { IReadinessManager } from '../../readiness/types';
-import { ILogger } from '../../logger/types';
-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: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
-  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/src/utils/inputValidation/splits.ts

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