@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -1,92 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { ImpressionCountsPayload } from '../../sync/submitters/types';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { REFRESH_RATE } from '../inRedis/constants';
-import { IPluggableStorageWrapper } from '../types';
-import { LOG_PREFIX } from './constants';
-
-export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
-
-  private readonly log: ILogger;
-  private readonly key: string;
-  private readonly wrapper: IPluggableStorageWrapper;
-  private readonly refreshRate: number;
-  private intervalId: any;
-
-  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
-    super(impressionCountsCacheSize);
-    this.log = log;
-    this.key = key;
-    this.wrapper = wrapper;
-    this.refreshRate = refreshRate;
-    this.onFullQueue = () => { this.storeImpressionCounts(); };
-  }
-
-  private storeImpressionCounts() {
-    const counts = this.pop();
-    const keys = Object.keys(counts);
-    if (!keys.length) return Promise.resolve(false);
-
-    const pipeline = keys.reduce<Promise<any>>((pipeline, key) => {
-      return pipeline.then(() => this.wrapper.incr(`${this.key}::${key}`, counts[key]));
-    }, Promise.resolve());
-
-    return pipeline.catch(err => {
-      this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
-      return false;
-    });
-  }
-
-  start() {
-    this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
-  }
-
-  stop() {
-    clearInterval(this.intervalId);
-    return this.storeImpressionCounts();
-  }
-
-  // Async consumer API, used by synchronizer
-  getImpressionsCount(): Promise<ImpressionCountsPayload | undefined> {
-    return this.wrapper.getKeysByPrefix(this.key)
-      .then(keys => {
-        return keys.length ? Promise.all(keys.map(key => this.wrapper.get(key)))
-          .then(counts => {
-            keys.forEach(key => this.wrapper.del(key).catch(() => { /* noop */ }));
-
-            const pf = [];
-
-            for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              const count = counts[i];
-
-              const keyFeatureNameAndTime = key.split('::');
-              if (keyFeatureNameAndTime.length !== 3) {
-                this.log.error(`${LOG_PREFIX}Error spliting key ${key}`);
-                continue;
-              }
-
-              const timeFrame = parseInt(keyFeatureNameAndTime[2]);
-              if (isNaN(timeFrame)) {
-                this.log.error(`${LOG_PREFIX}Error parsing time frame ${keyFeatureNameAndTime[2]}`);
-                continue;
-              }
-              // @ts-ignore
-              const rawCount = parseInt(count);
-              if (isNaN(rawCount)) {
-                this.log.error(`${LOG_PREFIX}Error parsing raw count ${count}`);
-                continue;
-              }
-
-              pf.push({
-                f: keyFeatureNameAndTime[1],
-                m: timeFrame,
-                rc: rawCount,
-              });
-            }
-
-            return { pf };
-          }) : undefined;
-      });
-  }
-}

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,63 +0,0 @@
-import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import SplitIO from '../../../types/splitio';
-import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
-import { ILogger } from '../../logger/types';
-import { impressionsToJSON } from '../utils';
-
-export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly key: string;
-  private readonly wrapper: IPluggableStorageWrapper;
-  private readonly metadata: IMetadata;
-
-  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata) {
-    this.log = log;
-    this.key = key;
-    this.wrapper = wrapper;
-    this.metadata = metadata;
-  }
-
-  /**
-   * Push given impressions to the storage.
-   * @param impressions -  List of impresions to push.
-   * @returns  A promise that is resolved if the push operation succeeded
-   * or rejected if the wrapper operation fails.
-   */
-  track(impressions: SplitIO.ImpressionDTO[]): Promise<void> {
-    return this.wrapper.pushItems(
-      this.key,
-      impressionsToJSON(impressions, this.metadata)
-    );
-  }
-
-  /**
-   * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
-   * The promise will never be rejected.
-   */
-  count(): Promise<number> {
-    return this.wrapper.getItemsCount(this.key).catch(() => 0);
-  }
-
-  /**
-   * Removes the given number of impressions from the store. If a number is not provided, it deletes all items.
-   * The returned promise rejects if the wrapper operation fails.
-   */
-  drop(count?: number): Promise<void> { // @ts-ignore
-    if (!count) return this.wrapper.del(this.key);
-
-    return this.wrapper.popItems(this.key, count).then(() => { });
-  }
-
-  /**
-   * Pop the given number of impressions from the store.
-   * The returned promise rejects if the wrapper operation fails.
-   */
-  popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]> {
-    return this.wrapper.popItems(this.key, count).then((items) => {
-      return items.map(item => JSON.parse(item) as StoredImpressionWithMetadata);
-    });
-  }
-
-}

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -1,76 +0,0 @@
-import { isNaNNumber } from '../../utils/lang';
-import { KeyBuilder } from '../KeyBuilder';
-import { IPluggableStorageWrapper, IRBSegmentsCacheAsync } from '../types';
-import { ILogger } from '../../logger/types';
-import { IRBSegment } from '../../dtos/types';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-
-export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly keys: KeyBuilder;
-  private readonly wrapper: IPluggableStorageWrapper;
-
-  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
-    this.log = log;
-    this.keys = keys;
-    this.wrapper = wrapper;
-  }
-
-  get(name: string): Promise<IRBSegment | null> {
-    return this.wrapper.get(this.keys.buildRBSegmentKey(name))
-      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
-  }
-
-  private getNames(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildRBSegmentKeyPrefix()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
-    );
-  }
-
-  contains(names: Set<string>): Promise<boolean> {
-    const namesArray = setToArray(names);
-    return this.getNames().then(namesInStorage => {
-      return namesArray.every(name => namesInStorage.includes(name));
-    });
-  }
-
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
-    return Promise.all([
-      this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(toAdd => {
-        const key = this.keys.buildRBSegmentKey(toAdd.name);
-        const stringifiedNewRBSegment = JSON.stringify(toAdd);
-        return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
-      })),
-      Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove.name);
-        return this.wrapper.del(key);
-      }))
-    ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
-    });
-  }
-
-  setChangeNumber(changeNumber: number) {
-    return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-  }
-
-  getChangeNumber(): Promise<number> {
-    return this.wrapper.get(this.keys.buildRBSegmentsTillKey()).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();
-  }
-
-}

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -1,90 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-unused-vars */
-import { isNaNNumber } from '../../utils/lang';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
-import { ILogger } from '../../logger/types';
-import { LOG_PREFIX } from './constants';
-
-/**
- * ISegmentsCacheAsync implementation for pluggable storages.
- */
-export class SegmentsCachePluggable implements ISegmentsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly keys: KeyBuilderSS;
-  private readonly wrapper: IPluggableStorageWrapper;
-
-  constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper) {
-    this.log = log;
-    this.keys = keys;
-    this.wrapper = wrapper;
-  }
-
-  /**
-   * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-   * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    return Promise.all<any>([
-      addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
-      removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
-      this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-    ]).then(() => {
-      return addedKeys.length > 0 || removedKeys.length > 0;
-    });
-  }
-
-  /**
-   * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
-   * Promise can be rejected if wrapper operation fails.
-   */
-  isInSegment(name: string, key: string) {
-    return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
-  }
-
-  /**
-   * 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(name: string) {
-    return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
-      const i = parseInt(value as string, 10);
-
-      return isNaNNumber(i) ? undefined : i;
-    }).catch((e) => {
-      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-      return undefined;
-    });
-  }
-
-  /**
-   * Add the given segment names to the set of registered segments.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  registerSegments(segments: string[]) {
-    if (segments.length) {
-      return this.wrapper.addItems(this.keys.buildRegisteredSegmentsKey(), segments);
-    } else {
-      return Promise.resolve();
-    }
-  }
-
-  /**
-   * Returns a promise that resolves with the set of registered segments in a list,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  getRegisteredSegments() {
-    return this.wrapper.getItems(this.keys.buildRegisteredSegmentsKey());
-  }
-
-  // @TODO implement if required by DataLoader or Producer mode
-  clear(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-}

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);
-  }
-
-}