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

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, returnListDifference } 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 = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+
+    let addToFlagSets = returnListDifference(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));
     });
   }
@@ -171,10 +192,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    */
   getAll(): Promise<ISplit[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
-      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
+      .then((listOfKeys) => this.redis.pipelineExec(listOfKeys.map(k => ['get', k])))
       .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.
   */
-  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.pipelineExec(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)]))
+      .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,14 +239,14 @@ 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;
       });

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/pluggable/SplitsCachePluggable.ts

@@ -177,14 +177,14 @@ 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 any wrapper operation fails.
-  */
+   * 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);
+      return this.wrapper.getItems(flagSetKey).catch(() => []);
     })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
   }
 

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/redis/RedisMock.ts

@@ -8,13 +8,10 @@ function asyncFunction(data: any): Promise<any> {
 }
 
 const IDENTITY_METHODS: string[] = [];
-const ASYNC_METHODS = ['rpush', 'hincrby'];
-const PIPELINE_METHODS = ['rpush', 'hincrby'];
+const ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
 
 export class RedisMock {
 
-  private pipelineMethods: any = { exec: jest.fn(asyncFunction) };
-
   constructor() {
     IDENTITY_METHODS.forEach(method => {
       this[method] = jest.fn(identityFunction);
@@ -22,12 +19,5 @@ export class RedisMock {
     ASYNC_METHODS.forEach(method => {
       this[method] = jest.fn(asyncFunction);
     });
-    PIPELINE_METHODS.forEach(method => {
-      this.pipelineMethods[method] = this[method];
-    });
-
-    this.pipeline = jest.fn(() => {return this.pipelineMethods;});
   }
-
-
 }

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,8 @@ 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>);
+    pipelineExec(commands?: (string | number)[][]): Promise<Array<[Error | null, any]>>;
     _listenToEvents(): void;
     _setTimeoutWrappers(): void;
     _setDisconnectWrapper(): void;
@@ -20,5 +21,5 @@ export declare class RedisAdapter extends ioredis {
     /**
      * Parses the options into what we care about.
      */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }?: Record<string, any>): object;
 }

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

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.
     */
-    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.

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

@@ -71,10 +71,10 @@ 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 any wrapper operation fails.
-    */
+     * 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.

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/redis/RedisMock.d.ts

@@ -1,4 +1,3 @@
 export declare class RedisMock {
-    private pipelineMethods;
     constructor();
 }