@splitsoftware/splitio-commons 1.11.0 → 1.12.0-rc.0

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -1,11 +1,11 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet } from '../../utils/lang/sets';
+import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import type { RedisAdapter } from './RedisAdapter';
 
 /**
  * Discard errors for an answer of multiple operations.
@@ -24,15 +24,17 @@ function processPipelineAnswer(results: Array<[Error | null, string]>): string[]
 export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
   private readonly log: ILogger;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly keys: KeyBuilderSS;
   private redisError?: string;
+  private readonly flagSetsFilter: string[];
 
-  constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis) {
+  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 : [];
 
     // 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`.
@@ -57,6 +59,24 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     return this.redis.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.redis.srem(this.keys.buildFlagSetKey(flagSetName), items)),
+      ...addToFlagSets.map(flagSetName => this.redis.sadd(this.keys.buildFlagSetKey(flagSetName), items))
+    ]);
+  }
+
   /**
    * Add a given split.
    * The returned promise is resolved when the operation success
@@ -66,16 +86,16 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
-      // handling parsing errors
-      let parsedPreviousSplit: ISplit, newStringifiedSplit;
+      // handling parsing error
+      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        newStringifiedSplit = JSON.stringify(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return this.redis.set(splitKey, newStringifiedSplit).then(() => {
+      return this.redis.set(splitKey, stringifiedNewSplit).then(() => {
         // avoid unnecessary increment/decrement operations
         if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
 
@@ -83,7 +103,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return this._incrementCounts(split).then(() => {
           if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
         });
-      });
+      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
     }).then(() => true);
   }
 
@@ -101,11 +121,12 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
-  removeSplit(name: string): Promise<number> {
+  removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        this._decrementCounts(split);
+        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
+    }).then(() => {
       return this.redis.del(this.keys.buildSplitKey(name));
     });
   }
@@ -174,7 +195,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
       .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
       .then(processPipelineAnswer)
       .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
-        return JSON.parse(splitDefinition as string);
+        return JSON.parse(splitDefinition);
       }));
   }
 
@@ -190,14 +211,18 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Get list of split names related to a given flag set names list.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if wrapper operation fails.
-   * @todo this is a no-op method to be implemented
+   * 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,
+   * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(): Promise<ISet<string>> {
-    this.log.error(LOG_PREFIX + 'ByFlagSet/s evaluations are not supported with Redis storage yet.');
-    return Promise.reject();
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+    return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
+      .then((results) => results.map(([e, value], index) => {
+        if (e === null) return value;
+
+        this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
+      }))
+      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
   }
 
   /**
@@ -214,26 +239,22 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
         ttCount = parseInt(ttCount as string, 10);
         if (!isFiniteNumber(ttCount) || ttCount < 0) {
-          this.log.info(LOG_PREFIX + `Could not validate traffic type existance of ${trafficType} due to data corruption of some sorts.`);
+          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 existance of ${trafficType} due to an error: ${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;
       });
   }
 
-  /**
-   * Delete everything in the current database.
-   *
-   * @NOTE documentation says it never fails.
-   */
+  // @TODO remove or implement. It is not being used.
   clear() {
-    return this.redis.flushdb().then(status => status === 'OK');
+    return Promise.resolve();
   }
 
   /**

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -3,13 +3,13 @@ import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } fro
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
-import { Redis } from 'ioredis';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
 import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
+import type { RedisAdapter } from './RedisAdapter';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
@@ -19,7 +19,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
    * @param keys  Key builder.
    * @param redis  Redis client.
    */
-  constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly redis: Redis) { }
+  constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly redis: RedisAdapter) { }
 
   recordLatency(method: Method, latencyMs: number) {
     const [key, field] = this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)).split('::');

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -1,21 +1,21 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { Redis } from 'ioredis';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 
 export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
   private readonly log: ILogger;
   private readonly key: string;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly refreshRate: number;
   private intervalId: any;
 
-  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize = DEFAULT_CACHE_SIZE, refreshRate = REFRESH_RATE) {
+  constructor(log: ILogger, key: string, redis: RedisAdapter, uniqueKeysQueueSize = DEFAULT_CACHE_SIZE, refreshRate = REFRESH_RATE) {
     super(uniqueKeysQueueSize);
     this.log = log;
     this.key = key;

package/src/storages/inRedis/index.ts

@@ -45,7 +45,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
     });
 
     return {
-      splits: new SplitsCacheInRedis(log, keys, redisClient),
+      splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -2,10 +2,10 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet } from '../../utils/lang/sets';
+import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -15,6 +15,7 @@ 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.
@@ -22,11 +23,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * @param keys  Key builder.
    * @param wrapper  Adapted wrapper storage.
    */
-  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
+  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) {
@@ -41,6 +43,24 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     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
@@ -67,7 +87,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
         return this._incrementCounts(split).then(() => {
           if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
         });
-      });
+      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
     }).then(() => true);
   }
 
@@ -88,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        this._decrementCounts(split);
+        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
+    }).then(() => {
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
   }
@@ -156,14 +177,15 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Get list of split names related to a given flag set names list.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if wrapper operation fails.
-   * @todo this is a no-op method to be implemented
-  */
-  getNamesByFlagSets(): Promise<ISet<string>> {
-    this.log.error(LOG_PREFIX + 'ByFlagSet/s evaluations are not supported with pluggable storage yet.');
-    return Promise.reject();
+   * 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<ISet<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)));
   }
 
   /**

package/src/storages/pluggable/index.ts

@@ -105,7 +105,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     });
 
     return {
-      splits: new SplitsCachePluggable(log, keys, wrapper),
+      splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/types.ts

@@ -44,10 +44,10 @@ export interface IPluggableStorageWrapper {
    *
    * @function del
    * @param {string} key Item to delete
-   * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+   * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
    * The promise rejects if the operation fails, for example, if there is a connection error.
    */
-  del: (key: string) => Promise<boolean | void>
+  del: (key: string) => Promise<boolean>
   /**
    * Returns all keys matching the given prefix.
    *
@@ -210,7 +210,7 @@ export interface ISplitsCacheBase {
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -227,7 +227,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): ISet<string>
+  getNamesByFlagSets(flagSets: string[]): ISet<string>[]
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -244,7 +244,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>
 }
 
 /** Segments cache */

package/src/trackers/impressionObserver/utils.ts

@@ -4,6 +4,6 @@ import { ISettings } from '../../types';
 /**
  * Storage is async if mode is consumer or partial consumer
  */
-export function isStorageSync(settings: ISettings) {
+export function isStorageSync(settings: Pick<ISettings, 'mode'>) {
   return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
 }

package/src/types.ts

@@ -197,8 +197,6 @@ interface ISharedSettings {
      * List of feature flag filters. These filters are used to fetch a subset of the feature flag definitions in your environment, in order to reduce the delay of the SDK to be ready.
      * This configuration is only meaningful when the SDK is working in "standalone" mode.
      *
-     * At the moment, only one type of feature flag filter is supported: by name.
-     *
      * Example:
      *  `splitFilter: [
      *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'

package/src/utils/constants/index.ts

@@ -39,6 +39,22 @@ export const CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tr
 export const CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
 export const CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions
 
+// Client method names
+export const GET_TREATMENT = 'getTreatment';
+export const GET_TREATMENTS = 'getTreatments';
+export const GET_TREATMENT_WITH_CONFIG = 'getTreatmentWithConfig';
+export const GET_TREATMENTS_WITH_CONFIG = 'getTreatmentsWithConfig';
+export const GET_TREATMENTS_BY_FLAG_SET = 'getTreatmentsByFlagSet';
+export const GET_TREATMENTS_BY_FLAG_SETS = 'getTreatmentsByFlagSets';
+export const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'getTreatmentsWithConfigByFlagSet';
+export const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'getTreatmentsWithConfigByFlagSets';
+export const TRACK_FN_LABEL = 'track';
+
+// Manager method names
+export const SPLIT_FN_LABEL = 'split';
+export const SPLITS_FN_LABEL = 'splits';
+export const NAMES_FN_LABEL = 'names';
+
 // Telemetry
 export const QUEUED = 0;
 export const DROPPED = 1;

package/src/utils/inputValidation/index.ts

@@ -8,6 +8,6 @@ export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
-export { validateSplitExistance } from './splitExistance';
-export { validateTrafficTypeExistance } from './trafficTypeExistance';
+export { validateSplitExistence } from './splitExistence';
+export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';

package/src/utils/inputValidation/{splitExistance.ts → splitExistence.ts}

@@ -7,7 +7,7 @@ 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 compeling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
-export function validateSplitExistance(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
+export function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
   if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
     if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {
       log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);

package/src/utils/inputValidation/{trafficTypeExistance.ts → trafficTypeExistence.ts}

@@ -7,14 +7,14 @@ import { MaybeThenable } from '../../dtos/types';
 import { ILogger } from '../../logger/types';
 import { WARN_NOT_EXISTENT_TT } from '../../logger/constants';
 
-function logTTExistanceWarning(log: ILogger, maybeTT: string, method: string) {
+function logTTExistenceWarning(log: ILogger, maybeTT: string, method: string) {
   log.warn(WARN_NOT_EXISTENT_TT, [method, maybeTT]);
 }
 
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-export function validateTrafficTypeExistance(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
+export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
 
   // If not ready or in localhost mode, we won't run the validation
   if (!readinessManager.isReady() || mode === LOCALHOST_MODE) return true;
@@ -23,11 +23,11 @@ export function validateTrafficTypeExistance(log: ILogger, readinessManager: IRe
 
   if (thenable(res)) {
     return res.then(function (isValid) {
-      if (!isValid) logTTExistanceWarning(log, maybeTT, method);
+      if (!isValid) logTTExistenceWarning(log, maybeTT, method);
       return isValid; // propagate result
     });
   } else {
-    if (!res) logTTExistanceWarning(log, maybeTT, method);
+    if (!res) logTTExistenceWarning(log, maybeTT, method);
     return res;
   }
 }

package/src/utils/lang/sets.ts

@@ -114,8 +114,16 @@ export const _Set = __getSetConstructor();
 
 export function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T> {
   const result = new _Set(setToArray(set));
-  set2.forEach( value => {
+  set2.forEach(value => {
     result.add(value);
   });
   return result;
 }
+
+export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
+  const result = new _Set(list);
+  list2.forEach(item => {
+    result.delete(item);
+  });
+  return setToArray(result);
+}

package/src/utils/redis/RedisMock.ts

@@ -26,8 +26,6 @@ export class RedisMock {
       this.pipelineMethods[method] = this[method];
     });
 
-    this.pipeline = jest.fn(() => {return this.pipelineMethods;});
+    this.pipeline = jest.fn(() => { return this.pipelineMethods; });
   }
-
-
 }

package/src/utils/settingsValidation/index.ts

@@ -202,7 +202,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   }
 
   // validate the `splitFilters` settings and parse splits query
-  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters);
+  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,8 +1,9 @@
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
 import { ISplitFiltersValidation } from '../../dtos/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
-import { WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
 
@@ -53,7 +54,7 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
   if (result) {
 
     if (type === 'bySet') {
-      result = sanitizeFlagSets(log, result);
+      result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
     }
 
     // check max length
@@ -87,7 +88,7 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
 }
 
 /**
- * Sanitizes set names list taking in account:
+ * Sanitizes set names list taking into account:
  *  - It should be lowercase
  *  - Must adhere the following regular expression /^[a-z0-9][_a-z0-9]{0,49}$/ that means
  *   - must start with a letter or number
@@ -97,20 +98,21 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
  *
  * @param {ILogger} log
  * @param {string[]} flagSets
+ * @param {string} method
  * @returns sanitized list of set names
  */
-function sanitizeFlagSets(log: ILogger, flagSets: string[]) {
+function sanitizeFlagSets(log: ILogger, flagSets: string[], method: string) {
   let sanitizedSets = flagSets
     .map(flagSet => {
-      if (CAPITAL_LETTERS_REGEX.test(flagSet)){
-        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET,[flagSet]);
+      if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
+        log.warn(WARN_LOWERCASE_FLAGSET, [method, flagSet]);
         flagSet = flagSet.toLowerCase();
       }
       return flagSet;
     })
     .filter(flagSet => {
-      if (!VALID_FLAGSET_REGEX.test(flagSet)){
-        log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet,VALID_FLAGSET_REGEX,flagSet]);
+      if (!VALID_FLAGSET_REGEX.test(flagSet)) {
+        log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
         return false;
       }
       if (typeof flagSet !== 'string') return false;
@@ -128,6 +130,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @param {ILogger} log logger
  * @param {any} maybeSplitFilters split filters configuration param provided by the user
+ * @param {string} mode settings mode
  * @returns it returns an object with the following properties:
  *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
  *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
@@ -135,7 +138,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation {
+export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation {
   // Validation result schema
   const res = {
     validFilters: [],
@@ -145,6 +148,11 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISpl
 
   // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
   if (!maybeSplitFilters) return res;
+  // Warn depending on the mode
+  if (mode === CONSUMER_MODE || mode === CONSUMER_PARTIAL_MODE) {
+    log.warn(WARN_SPLITS_FILTER_IGNORED);
+    return res;
+  }
   // Check collection type
   if (!Array.isArray(maybeSplitFilters) || maybeSplitFilters.length === 0) {
     log.warn(WARN_SPLITS_FILTER_EMPTY);
@@ -181,9 +189,9 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISpl
   return res;
 }
 
-export function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
+export function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
   const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-  let toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+  let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
   if (flagSetsInConfig.length > 0) {
     toReturn = toReturn.filter(flagSet => {
       if (flagSetsInConfig.indexOf(flagSet) > -1) {

package/types/evaluator/index.d.ts

@@ -5,4 +5,4 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export declare function evaluateFeature(log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<IEvaluationResult>;
 export declare function evaluateFeatures(log: ILogger, key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
-export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
+export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync, method: string): MaybeThenable<Record<string, IEvaluationResult>>;

package/types/logger/constants.d.ts

@@ -89,14 +89,16 @@ export declare const WARN_NOT_EXISTENT_SPLIT = 215;
 export declare const WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export declare const WARN_NOT_EXISTENT_TT = 217;
 export declare const WARN_INTEGRATION_INVALID = 218;
+export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
 export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
-export declare const WARN_SPLITS_FILTER_INVALID_SET = 225;
-export declare const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export declare const WARN_INVALID_FLAGSET = 225;
+export declare const WARN_LOWERCASE_FLAGSET = 226;
 export declare const WARN_FLAGSET_NOT_CONFIGURED = 227;
+export declare const WARN_FLAGSET_WITHOUT_FLAGS = 228;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;