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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,234 +0,0 @@
-import { IDefinition } 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: IDefinition) {
-    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: IDefinition) {
-    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: IDefinition) {
-    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): IDefinition | 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: IDefinition) {
-    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)));
-  }
-
-}

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,130 +0,0 @@
-import { IDefinition, 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, IDefinition> = {};
-  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: IDefinition): 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): IDefinition | 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: IDefinition) {
-    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 { IDefinition, 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: IDefinition) {
-    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: IDefinition) {
-    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: IDefinition): Promise<boolean> {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    return this.wrapper.get(splitKey).then(splitFromStorage => {
-
-      // handling parsing error
-      let parsedPreviousSplit: IDefinition, 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<IDefinition | 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, IDefinition | null>> {
-    const keys = names.map(name => this.keys.buildSplitKey(name));
-
-    return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, IDefinition | 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<IDefinition[]> {
-    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);
-  }
-
-}