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

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, 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.
@@ -14,7 +14,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     private readonly keys;
     private redisError?;
     private readonly flagSetsFilter;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis, splitFiltersValidation?: ISplitFiltersValidation);
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
     private _updateFlagSets;
@@ -75,9 +75,9 @@ 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 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,
+     * or rejected if the pipelined redis operation fails.
     */
     getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**

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();
 }