@splitsoftware/splitio-commons 1.10.1-rc.4 → 1.12.0-rc.0

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;

package/types/sdkFactory/types.d.ts

@@ -1,9 +1,9 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
+import type { sdkManagerFactory } from '../sdkManager';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
+import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
@@ -66,7 +66,7 @@ export interface ISdkFactoryParams {
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi;
     syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
-    sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
+    sdkManagerFactory: typeof sdkManagerFactory;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;

package/types/sdkManager/index.d.ts

@@ -1,5 +1,4 @@
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
-export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(log: ILogger, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;
+import { ISettings, SplitIO } from '../types';
+export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(settings: Pick<ISettings, 'log' | 'mode'>, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getChangeNumber(): Promise<number>;
     abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
-    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
     usesSegments(): Promise<boolean>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -48,7 +48,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -22,7 +22,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

package/types/storages/inRedis/EventsCacheInRedis.d.ts

@@ -1,15 +1,15 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { Redis } from 'ioredis';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class EventsCacheInRedis implements IEventsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly metadata;
-    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
     /**
      * Add a new event object into the queue.
      * Unlike `impressions::track`, result promise is never rejected.

package/types/storages/inRedis/ImpressionCountsCacheInRedis.d.ts

@@ -1,14 +1,15 @@
-import { Redis } from 'ioredis';
+/// <reference types="ioredis" />
 import { ILogger } from '../../logger/types';
 import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly refreshRate;
     private intervalId;
-    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, impressionCountsCacheSize?: number, refreshRate?: number);
     private postImpressionCountsInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;

package/types/storages/inRedis/ImpressionsCacheInRedis.d.ts

@@ -1,15 +1,15 @@
 import { IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly metadata;
-    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
     track(impressions: ImpressionDTO[]): Promise<void>;
     count(): Promise<number>;
     drop(count?: number): Promise<any>;

package/types/storages/inRedis/RedisAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class RedisAdapter extends ioredis {
     private _options;
     private _notReadyCommandsQueue?;
     private _runningCommands;
-    constructor(log: ILogger, storageSettings: Record<string, any>);
+    constructor(log: ILogger, storageSettings?: Record<string, any>);
     _listenToEvents(): void;
     _setTimeoutWrappers(): void;
     _setDisconnectWrapper(): void;

package/types/storages/inRedis/SegmentsCacheInRedis.d.ts

@@ -1,12 +1,12 @@
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly log;
     private readonly redis;
     private readonly keys;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
     addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
     removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean>;
     isInSegment(name: string, key: string): Promise<boolean>;
@@ -14,5 +14,5 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     getChangeNumber(name: string): Promise<number>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
 }

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -1,9 +1,9 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
+import type { RedisAdapter } from './RedisAdapter';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
  * Supported by Node.
@@ -13,9 +13,11 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     private readonly redis;
     private readonly keys;
     private redisError?;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    private readonly flagSetsFilter;
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -73,12 +75,11 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      */
     getSplitNames(): Promise<string[]>;
     /**
-     * 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>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.
@@ -86,12 +87,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * It will never be rejected.
      */
     trafficTypeExists(trafficType: string): Promise<boolean>;
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
     /**
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -2,7 +2,7 @@ import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
-import { Redis } from 'ioredis';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     private readonly log;
     private readonly keys;
@@ -13,7 +13,7 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
      * @param keys  Key builder.
      * @param redis  Redis client.
      */
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
     recordConfig(): Promise<number | void>;

package/types/storages/inRedis/UniqueKeysCacheInRedis.d.ts

@@ -1,15 +1,16 @@
+/// <reference types="ioredis" />
 import { IUniqueKeysCacheBase } from '../types';
-import { Redis } from 'ioredis';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly refreshRate;
     private intervalId;
-    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, uniqueKeysQueueSize?: number, refreshRate?: number);
     private postUniqueKeysInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,7 +1,7 @@
 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 { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
 /**
@@ -11,15 +11,17 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
+    private readonly flagSetsFilter;
     /**
      * 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);
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -37,7 +39,7 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * 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): Promise<boolean | void>;
+    removeSplit(name: string): Promise<boolean>;
     /**
      * Remove a list of splits.
      * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
@@ -69,12 +71,11 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      */
     getSplitNames(): Promise<string[]>;
     /**
-     * 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>>;
+     * 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>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/types/storages/types.d.ts

@@ -41,10 +41,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.
      *
@@ -193,7 +193,7 @@ export interface ISplitsCacheBase {
     clear(): MaybeThenable<boolean | void>;
     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 {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -209,7 +209,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 {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -225,7 +225,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 */
 export interface ISegmentsCacheBase {

package/types/trackers/impressionObserver/utils.d.ts

@@ -2,4 +2,4 @@ import { ISettings } from '../../types';
 /**
  * Storage is async if mode is consumer or partial consumer
  */
-export declare function isStorageSync(settings: ISettings): boolean;
+export declare function isStorageSync(settings: Pick<ISettings, 'mode'>): boolean;

package/types/types.d.ts

@@ -191,8 +191,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/types/utils/constants/index.d.ts

@@ -24,6 +24,18 @@ export declare const STORAGE_PLUGGABLE: StorageType;
 export declare const CONSENT_GRANTED = "GRANTED";
 export declare const CONSENT_DECLINED = "DECLINED";
 export declare const CONSENT_UNKNOWN = "UNKNOWN";
+export declare const GET_TREATMENT = "getTreatment";
+export declare const GET_TREATMENTS = "getTreatments";
+export declare const GET_TREATMENT_WITH_CONFIG = "getTreatmentWithConfig";
+export declare const GET_TREATMENTS_WITH_CONFIG = "getTreatmentsWithConfig";
+export declare const GET_TREATMENTS_BY_FLAG_SET = "getTreatmentsByFlagSet";
+export declare const GET_TREATMENTS_BY_FLAG_SETS = "getTreatmentsByFlagSets";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = "getTreatmentsWithConfigByFlagSet";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = "getTreatmentsWithConfigByFlagSets";
+export declare const TRACK_FN_LABEL = "track";
+export declare const SPLIT_FN_LABEL = "split";
+export declare const SPLITS_FN_LABEL = "splits";
+export declare const NAMES_FN_LABEL = "names";
 export declare const QUEUED = 0;
 export declare const DROPPED = 1;
 export declare const DEDUPED = 2;

package/types/utils/inputValidation/index.d.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/types/utils/inputValidation/splitExistence.d.ts

@@ -0,0 +1,7 @@
+import { IReadinessManager } from '../../readiness/types';
+import { ILogger } from '../../logger/types';
+/**
+ * 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 declare function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean;

package/types/utils/inputValidation/trafficTypeExistence.d.ts

@@ -0,0 +1,9 @@
+import { ISplitsCacheBase } from '../../storages/types';
+import { IReadinessManager } from '../../readiness/types';
+import { SDKMode } from '../../types';
+import { MaybeThenable } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
+/**
+ * Separated from the previous method since on some cases it'll be async.
+ */
+export declare function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SDKMode, maybeTT: string, method: string): MaybeThenable<boolean>;

package/types/utils/lang/sets.d.ts

@@ -58,4 +58,5 @@ interface ISetConstructor {
 export declare function __getSetConstructor(): ISetConstructor;
 export declare const _Set: ISetConstructor;
 export declare function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T>;
+export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];
 export {};

package/types/utils/settingsValidation/splitFilters.d.ts

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
  *
  * @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.
@@ -12,5 +13,5 @@ import { ILogger } from '../../logger/types';
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation;
-export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];
+export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation;
+export declare function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];