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

package/src/sdkManager/index.ts

@@ -5,12 +5,9 @@ import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validate
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
-
-const SPLIT_FN_LABEL = 'split';
-const SPLITS_FN_LABEL = 'splits';
-const NAMES_FN_LABEL = 'names';
+import { ISettings, SplitIO } from '../types';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 
 function collectTreatments(splitObject: ISplit) {
   const conditions = splitObject.conditions;
@@ -49,11 +46,14 @@ function objectsToViews(splitObjects: ISplit[]) {
 }
 
 export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(
-  log: ILogger,
+  settings: Pick<ISettings, 'log' | 'mode'>,
   splits: TSplitCache,
-  { readinessManager, sdkStatus }: ISdkReadinessManager
+  { readinessManager, sdkStatus }: ISdkReadinessManager,
 ): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
 
+  const log = settings.log;
+  const isSync = isStorageSync(settings);
+
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus),
@@ -64,7 +64,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-          return null;
+          return isSync ? null : Promise.resolve(null);
         }
 
         const split = splits.getSplit(splitName);
@@ -85,7 +85,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       splits() {
         if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-          return [];
+          return isSync ? [] : Promise.resolve([]);
         }
         const currentSplits = splits.getAll();
 
@@ -98,7 +98,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       names() {
         if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-          return [];
+          return isSync ? [] : Promise.resolve([]);
         }
         const splitNames = splits.getSplitNames();
 

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -27,7 +27,11 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     const keys = Object.keys(counts);
     if (!keys.length) return Promise.resolve(false);
 
-    return this.redis.pipelineExec(keys.map(key => ['hincrby', this.key, key, counts[key]]))
+    const pipeline = this.redis.pipeline();
+    keys.forEach(key => {
+      pipeline.hincrby(this.key, key, counts[key]);
+    });
+    return pipeline.exec()
       .then(data => {
         // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
         if (data.length && data.length === keys.length) {

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,4 +1,4 @@
-import ioredis from 'ioredis';
+import ioredis, { Pipeline } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
 import { _Set, setToArray, ISet } from '../../utils/lang/sets';
@@ -8,7 +8,8 @@ import { timeout } from '../../utils/promise/timeout';
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
+const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
+const METHODS_TO_PROMISE_WRAP_EXEC = ['pipeline'];
 
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 const DEFAULT_OPTIONS = {
@@ -38,7 +39,7 @@ export class RedisAdapter extends ioredis {
   private _notReadyCommandsQueue?: IRedisCommand[];
   private _runningCommands: ISet<Promise<any>>;
 
-  constructor(log: ILogger, storageSettings?: Record<string, any>) {
+  constructor(log: ILogger, storageSettings: Record<string, any> = {}) {
     const options = RedisAdapter._defineOptions(storageSettings);
     // Call the ioredis constructor
     super(...RedisAdapter._defineLibrarySettings(options));
@@ -52,10 +53,6 @@ export class RedisAdapter extends ioredis {
     this._setDisconnectWrapper();
   }
 
-  pipelineExec(commands?: (string | number)[][]): Promise<Array<[Error | null, any]>> {
-    return this.pipeline(commands as string[][]).exec();
-  }
-
   _listenToEvents() {
     this.once('ready', () => {
       const commandsCount = this._notReadyCommandsQueue ? this._notReadyCommandsQueue.length : 0;
@@ -76,21 +73,22 @@ export class RedisAdapter extends ioredis {
   _setTimeoutWrappers() {
     const instance: Record<string, any> = this;
 
-    METHODS_TO_PROMISE_WRAP.forEach(methodName => {
-      const originalMethod = instance[methodName];
-
-      instance[methodName] = function () {
+    const wrapCommand = (originalMethod: Function, methodName: string) => {
+      // The value of "this" in this function should be the instance actually executing the method. It might be the instance referred (the base one)
+      // or it can be the instance of a Pipeline object.
+      return function (this: RedisAdapter | Pipeline) {
         const params = arguments;
+        const caller = this;
 
         function commandWrapper() {
           instance.log.debug(`${LOG_PREFIX}Executing ${methodName}.`);
-          const result = originalMethod.apply(instance, params);
+          const result = originalMethod.apply(caller, params);
 
           if (thenable(result)) {
             // For handling pending commands on disconnect, add to the set and remove once finished.
             // On sync commands there's no need, only thenables.
             instance._runningCommands.add(result);
-            const cleanUpRunningCommandsCb = () => {
+            const cleanUpRunningCommandsCb = function () {
               instance._runningCommands.delete(result);
             };
             // Both success and error remove from queue.
@@ -107,10 +105,10 @@ export class RedisAdapter extends ioredis {
         }
 
         if (instance._notReadyCommandsQueue) {
-          return new Promise((res, rej) => {
+          return new Promise((resolve, reject) => {
             instance._notReadyCommandsQueue.unshift({
-              resolve: res,
-              reject: rej,
+              resolve,
+              reject,
               command: commandWrapper,
               name: methodName.toUpperCase()
             });
@@ -119,6 +117,26 @@ export class RedisAdapter extends ioredis {
           return commandWrapper();
         }
       };
+    };
+
+    // Wrap regular async methods to track timeouts and queue when Redis is not yet executing commands.
+    METHODS_TO_PROMISE_WRAP.forEach(methodName => {
+      const originalFn = instance[methodName];
+      instance[methodName] = wrapCommand(originalFn, methodName);
+    });
+
+    // Special handling for pipeline~like methods. We need to wrap the async trigger, which is exec, but return the Pipeline right away.
+    METHODS_TO_PROMISE_WRAP_EXEC.forEach(methodName => {
+      const originalFn = instance[methodName];
+      // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
+      instance[methodName] = function () {
+        const res = originalFn.apply(instance, arguments);
+        const originalExec = res.exec;
+
+        res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+
+        return res;
+      };
     });
   }
 
@@ -181,7 +199,7 @@ export 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> = {}) {
+  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>) {
     const parsedOptions = {
       connectionTimeout, operationTimeout, url, host, port, db, pass, tls
     };

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -72,8 +72,8 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
   }
 
-  // @TODO remove/review. It is not being used.
+  // @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/SplitsCacheInRedis.ts

@@ -192,7 +192,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    */
   getAll(): Promise<ISplit[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
-      .then((listOfKeys) => this.redis.pipelineExec(listOfKeys.map(k => ['get', k])))
+      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
       .then(processPipelineAnswer)
       .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
         return JSON.parse(splitDefinition);
@@ -213,10 +213,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   /**
    * 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.
+   * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
   getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
-    return this.redis.pipelineExec(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)]))
+    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;
 
@@ -252,13 +252,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
       });
   }
 
-  /**
-   * 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/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/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/redis/RedisMock.ts

@@ -8,10 +8,13 @@ function asyncFunction(data: any): Promise<any> {
 }
 
 const IDENTITY_METHODS: string[] = [];
-const ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
+const ASYNC_METHODS = ['rpush', 'hincrby'];
+const PIPELINE_METHODS = ['rpush', 'hincrby'];
 
 export class RedisMock {
 
+  private pipelineMethods: any = { exec: jest.fn(asyncFunction) };
+
   constructor() {
     IDENTITY_METHODS.forEach(method => {
       this[method] = jest.fn(identityFunction);
@@ -19,5 +22,10 @@ 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/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/inRedis/RedisAdapter.d.ts

@@ -9,7 +9,6 @@ export declare class RedisAdapter extends ioredis {
     private _notReadyCommandsQueue?;
     private _runningCommands;
     constructor(log: ILogger, storageSettings?: Record<string, any>);
-    pipelineExec(commands?: (string | number)[][]): Promise<Array<[Error | null, any]>>;
     _listenToEvents(): void;
     _setTimeoutWrappers(): void;
     _setDisconnectWrapper(): void;
@@ -21,5 +20,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

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

@@ -77,7 +77,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     /**
      * 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.
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
     getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
@@ -87,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/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/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/redis/RedisMock.d.ts

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