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

package/src/storages/inMemory/InMemoryStorage.ts

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -17,18 +17,18 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new SegmentsCacheInMemory();
 
   const storage = {
-    splits,
+    definitions,
     rbSegments,
     segments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: new ImpressionCountsCacheInMemory(),
     events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
     uniqueKeys: new UniqueKeysCacheInMemory(),
 
     destroy() { }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -17,20 +17,20 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new MySegmentsCacheInMemory();
   const largeSegments = new MySegmentsCacheInMemory();
 
   const storage = {
-    splits,
+    definitions,
     rbSegments,
     segments,
     largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: new ImpressionCountsCacheInMemory(),
     events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
     uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
     destroy() { },
@@ -38,7 +38,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {
-        splits: this.splits,
+        definitions: this.definitions,
         rbSegments: this.rbSegments,
         segments: new MySegmentsCacheInMemory(),
         largeSegments: new MySegmentsCacheInMemory(),

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -1,6 +1,6 @@
 import { IRBSegment } from '../../dtos/types';
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
+import { usesSegments } from '../AbstractDefinitionsCacheSync';
 import { IRBSegmentsCacheSync } from '../types';
 
 export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -2,7 +2,7 @@ import { isIntegerNumber } from '../../utils/lang';
 import { ISegmentsCacheSync } from '../types';
 
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default IDefinitionsCacheSync implementation for server-side that stores segments definitions in memory.
  */
 export class SegmentsCacheInMemory implements ISegmentsCacheSync {
 

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -2,7 +2,7 @@ import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies,
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { checkIfServerSide } from '../../utils/key';
 import { findLatencyIndex } from '../findLatencyIndex';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ISegmentsCacheSync, IDefinitionsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
 const MAX_STREAMING_EVENTS = 20;
 const MAX_TAGS = 10;
@@ -28,7 +28,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   public name = 'telemetry stats';
 
-  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
+  constructor(private definitions?: IDefinitionsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
 
   // isEmpty flag
   private e = true;
@@ -51,7 +51,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       iQ: this.getImpressionStats(QUEUED),
       iDe: this.getImpressionStats(DEDUPED),
       iDr: this.getImpressionStats(DROPPED),
-      spC: this.splits && this.splits.getSplitNames().length,
+      spC: this.definitions && this.definitions.getNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
       lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,

package/src/storages/inRedis/{SplitsCacheInRedis.ts → DefinitionsCacheInRedis.ts}

@@ -3,7 +3,7 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
 import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
@@ -18,23 +18,23 @@ function processPipelineAnswer(results: Array<[Error | null, unknown]> | null):
 }
 
 /**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
+ * IDefinitionsCacheAsync implementation that stores definitions in Redis.
  * Supported by Node.js
  */
-export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
+export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
 
   private readonly log: ILogger;
   private readonly redis: RedisAdapter;
   private readonly keys: KeyBuilderSS;
   private redisError?: Error;
-  private readonly flagSetsFilter: string[];
+  private readonly setsFilter: string[];
 
   constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation) {
     super();
     this.log = log;
     this.redis = redis;
     this.keys = keys;
-    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+    this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
 
     // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
     // But it is done just to avoid getting the ioredis message `Unhandled error event`.
@@ -47,95 +47,95 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     });
   }
 
-  private _decrementCounts(split: IDefinition) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+  private _decrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
     return this.redis.decr(ttKey).then((count: number) => {
       if (count === 0) return this.redis.del(ttKey);
     });
   }
 
-  private _incrementCounts(split: IDefinition) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+  private _incrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
     return this.redis.incr(ttKey);
   }
 
-  private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+  private _updateSets(definitionName: string, setsOfRemovedDefinition?: string[] | null, setsOfAddedDefinition?: string[] | null) {
+    const removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
 
-    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-    if (this.flagSetsFilter.length > 0) {
-      addToFlagSets = addToFlagSets.filter(flagSet => {
-        return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);
+    let addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+    if (this.setsFilter.length > 0) {
+      addToSets = addToSets.filter(set => {
+        return this.setsFilter.some(filterSet => filterSet === set);
       });
     }
 
-    const items = [featureFlagName];
+    const items = [definitionName];
 
     return Promise.all([
-      ...removeFromFlagSets.map(flagSetName => this.redis.srem(this.keys.buildFlagSetKey(flagSetName), items)),
-      ...addToFlagSets.map(flagSetName => this.redis.sadd(this.keys.buildFlagSetKey(flagSetName), items))
+      ...removeFromSets.map(setName => this.redis.srem(this.keys.buildSetKey(setName), items)),
+      ...addToSets.map(setName => this.redis.sadd(this.keys.buildSetKey(setName), items))
     ]);
   }
 
   /**
-   * Add a given split.
+   * Add a given definition.
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(split: IDefinition): Promise<boolean> {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    return this.redis.get(splitKey).then((splitFromStorage: string | null) => {
+  add(definition: IDefinition): Promise<boolean> {
+    const name = definition.name;
+    const definitionKey = this.keys.buildDefinitionKey(name);
+    return this.redis.get(definitionKey).then((definitionFromStorage: string | null) => {
 
       // handling parsing error
-      let parsedPreviousSplit: IDefinition, stringifiedNewSplit;
+      let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
       try {
-        parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        stringifiedNewSplit = JSON.stringify(split);
+        parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        stringifiedNewDefinition = JSON.stringify(definition);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return this.redis.set(splitKey, stringifiedNewSplit).then(() => {
+      return this.redis.set(definitionKey, stringifiedNewDefinition).then(() => {
         // avoid unnecessary increment/decrement operations
-        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
+        if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
 
         // update traffic type counts
-        return this._incrementCounts(split).then(() => {
-          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
+        return this._incrementCounts(definition).then(() => {
+          if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
         });
-      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
     }).then(() => true);
   }
 
   /**
-   * Remove a given split.
-   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
+   * Remove a given definition.
+   * The returned promise is resolved when the operation success, with true or false indicating if the definition existed (and was removed) or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
-  removeSplit(name: string) {
-    return this.getSplit(name).then((split) => {
-      if (split) {
-        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
+  remove(name: string) {
+    return this.get(name).then((definition) => {
+      if (definition) {
+        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name)).then((status: number) => status === 1);
+      return this.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
     });
   }
 
   /**
-   * Get split definition or null if it's not defined.
+   * Get definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplit(name: string): Promise<IDefinition | null> {
+  get(name: string): Promise<IDefinition | null> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    return this.redis.get(this.keys.buildSplitKey(name))
-      .then((maybeSplit: string | null) => maybeSplit && JSON.parse(maybeSplit));
+    return this.redis.get(this.keys.buildDefinitionKey(name))
+      .then((maybeDefinition: string | null) => maybeDefinition && JSON.parse(maybeDefinition));
   }
 
   /**
@@ -144,7 +144,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * or rejected if it fails.
    */
   setChangeNumber(changeNumber: number): Promise<boolean> {
-    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(
+    return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(
       (status: string | null) => status === 'OK'
     );
   }
@@ -155,7 +155,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The promise will never be rejected.
    */
   getChangeNumber(): Promise<number> {
-    return this.redis.get(this.keys.buildSplitsTillKey()).then((value: string | null) => {
+    return this.redis.get(this.keys.buildDefinitionsTillKey()).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
       return isNaNNumber(i) ? -1 : i;
@@ -166,44 +166,44 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Get list of all split definitions.
-   * The returned promise is resolved with the list of split definitions,
+   * Get list of all definitions.
+   * The returned promise is resolved with the list of definitions,
    * or rejected if redis operation fails.
    */
   // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
   getAll(): Promise<IDefinition[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys())
+    return this.redis.keys(this.keys.searchPatternForDefinitionKeys())
       .then((listOfKeys: string[]) => this.redis.pipeline(listOfKeys.map((k: string) => ['get', k])).exec())
       .then(processPipelineAnswer)
-      .then((splitDefinitions: string[]) => splitDefinitions.map((splitDefinition: string) => {
-        return JSON.parse(splitDefinition);
+      .then((definitions: string[]) => definitions.map((definition: string) => {
+        return JSON.parse(definition);
       }));
   }
 
   /**
-   * Get list of split names.
-   * The returned promise is resolved with the list of split names,
+   * Get list of definition names.
+   * The returned promise is resolved with the list of names,
    * or rejected if redis operation fails.
    */
-  getSplitNames(): Promise<string[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
+  getNames(): Promise<string[]> {
+    return this.redis.keys(this.keys.searchPatternForDefinitionKeys()).then(
       (listOfKeys: string[]) => 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,
+   * Get list of definition names related to a given list of set names.
+   * The returned promise is resolved with the list of names per set,
    * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
-    return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
+  getNamesBySets(sets: string[]): Promise<Set<string>[]> {
+    return this.redis.pipeline(sets.map(set => ['smembers', this.keys.buildSetKey(set)])).exec()
       .then((results: [Error | null, unknown][] | null) => results ? results.map(([e, value]: [Error | null, unknown], index: number) => {
         if (e === null) return value as string;
 
-        this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
+        this.log.error(LOG_PREFIX + `Could not read result from get members of set ${sets[index]} due to an error: ${e}`);
       }) : [])
-      .then((namesByFlagSets: (string | undefined)[]) => namesByFlagSets.map((namesByFlagSet: string | undefined) => new Set(namesByFlagSet)));
+      .then((namesBySets: (string | undefined)[]) => namesBySets.map((namesBySet: string | undefined) => new Set(namesBySet)));
   }
 
   /**
@@ -239,25 +239,25 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Fetches multiple splits definitions.
+   * Fetches multiple definitions.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, IDefinition | null>> {
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    const keys = names.map(name => this.keys.buildSplitKey(name));
+    const keys = names.map(name => this.keys.buildDefinitionKey(name));
     return this.redis.mget(...keys)
-      .then((splitDefinitions: (string | null)[]) => {
-        const splits: Record<string, IDefinition | null> = {};
+      .then((stringifiedDefinitions: (string | null)[]) => {
+        const definitions: Record<string, IDefinition | null> = {};
         names.forEach((name, idx) => {
-          const split = splitDefinitions[idx];
-          splits[name] = split && JSON.parse(split);
+          const definition = stringifiedDefinitions[idx];
+          definitions[name] = definition && JSON.parse(definition);
         });
-        return Promise.resolve(splits);
+        return Promise.resolve(definitions);
       })
       .catch((e: unknown) => {
         this.log.error(LOG_PREFIX + `Could not grab feature flags due to an error: ${e}.`);

package/src/storages/inRedis/index.ts

@@ -2,7 +2,7 @@ import type { RedisAdapter } from './RedisAdapter';
 import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCacheInRedis } from './SplitsCacheInRedis';
+import { DefinitionsCacheInRedis } from './DefinitionsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
@@ -59,7 +59,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
     });
 
     return {
-      splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+      definitions: new DefinitionsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
       rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),

package/src/storages/pluggable/DefinitionsCachePluggable.ts

@@ -0,0 +1,230 @@
+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 { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
+import { returnDifference } from '../../utils/lang/sets';
+
+/**
+ * IDefinitionsCacheAsync implementation for pluggable storages.
+ */
+export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilder;
+  private readonly wrapper: IPluggableStorageWrapper;
+  private readonly setsFilter: string[];
+
+  /**
+   * Create a DefinitionsCache 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.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+  }
+
+  private _decrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+    return this.wrapper.decr(ttKey).then(count => {
+      if (count === 0) return this.wrapper.del(ttKey);
+    });
+  }
+
+  private _incrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+    return this.wrapper.incr(ttKey);
+  }
+
+  private _updateSets(definitionName: string, setsOfRemovedDefinition?: string[] | null, setsOfAddedDefinition?: string[] | null) {
+    const removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+
+    let addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+    if (this.setsFilter.length > 0) {
+      addToSets = addToSets.filter(set => {
+        return this.setsFilter.some(filterSet => filterSet === set);
+      });
+    }
+
+    const items = [definitionName];
+
+    return Promise.all([
+      ...removeFromSets.map(setName => this.wrapper.removeItems(this.keys.buildSetKey(setName), items)),
+      ...addToSets.map(setName => this.wrapper.addItems(this.keys.buildSetKey(setName), items))
+    ]);
+  }
+
+  /**
+   * Add a given definition.
+   * The returned promise is resolved when the operation success
+   * or rejected if it fails (e.g., wrapper operation fails)
+   */
+  add(definition: IDefinition): Promise<boolean> {
+    const name = definition.name;
+    const definitionKey = this.keys.buildDefinitionKey(name);
+    return this.wrapper.get(definitionKey).then(definitionFromStorage => {
+
+      // handling parsing error
+      let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
+      try {
+        parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        stringifiedNewDefinition = JSON.stringify(definition);
+      } catch (e) {
+        throw new Error('Error parsing feature flag definition: ' + e);
+      }
+
+      return this.wrapper.set(definitionKey, stringifiedNewDefinition).then(() => {
+        // avoid unnecessary increment/decrement operations
+        if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
+
+        // update traffic type counts
+        return this._incrementCounts(definition).then(() => {
+          if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
+        });
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
+    }).then(() => true);
+  }
+
+  /**
+   * Remove a given definition.
+   * The returned promise is resolved when the operation success, with a boolean indicating if the definition existed or not.
+   * or rejected if it fails (e.g., wrapper operation fails).
+   */
+  remove(name: string) {
+    return this.get(name).then((definition) => {
+      if (definition) {
+        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
+      }
+    }).then(() => {
+      return this.wrapper.del(this.keys.buildDefinitionKey(name));
+    });
+  }
+
+  /**
+   * Get definition.
+   * The returned promise is resolved with the definition or null if it's not defined,
+   * or rejected if wrapper operation fails.
+   */
+  get(name: string): Promise<IDefinition | null> {
+    return this.wrapper.get(this.keys.buildDefinitionKey(name))
+      .then(maybeDefinition => maybeDefinition && JSON.parse(maybeDefinition));
+  }
+
+  /**
+   * Get list of definitions.
+   * The returned promise is resolved with a map of names to their definition or null if it's not defined,
+   * or rejected if wrapper operation fails.
+   */
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>> {
+    const keys = names.map(name => this.keys.buildDefinitionKey(name));
+
+    return this.wrapper.getMany(keys).then(stringifiedDefinitions => {
+      const definitions: Record<string, IDefinition | null> = {};
+      names.forEach((name, idx) => {
+        const definition = stringifiedDefinitions[idx];
+        definitions[name] = definition && JSON.parse(definition);
+      });
+      return Promise.resolve(definitions);
+    });
+  }
+
+  /**
+   * Get list of all definitions.
+   * The returned promise is resolved with the list of definitions,
+   * or rejected if wrapper operation fails.
+   */
+  getAll(): Promise<IDefinition[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((definitions) => definitions.map((definition) => {
+        return JSON.parse(definition as string);
+      }));
+  }
+
+  /**
+   * Get list of definition names.
+   * The returned promise is resolved with the list of names,
+   * or rejected if wrapper operation fails.
+   */
+  getNames(): Promise<string[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  /**
+   * Get list of definition names related to a given list of set names.
+   * The returned promise is resolved with the list of names per set.
+   * It never rejects (If there is a wrapper error for some set, an empty set is returned for it).
+   */
+  getNamesBySets(sets: string[]): Promise<Set<string>[]> {
+    return Promise.all(sets.map(set => {
+      const setKey = this.keys.buildSetKey(set);
+      return this.wrapper.getItems(setKey).catch(() => []);
+    })).then(namesBySets => namesBySets.map(namesBySet => new Set(namesBySet)));
+  }
+
+  /**
+   * 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.buildDefinitionsTillKey(), 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.buildDefinitionsTillKey()).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);
+  }
+
+}