@splitsoftware/splitio-commons 1.6.2-rc.9 → 1.7.0

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

@@ -0,0 +1,35 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+    private onFullQueue?;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    private uniqueKeysTracker;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys per feature.
+     */
+    track(userKey: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadCs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    private fromUniqueKeysCollector;
+}

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

@@ -0,0 +1,16 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+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);
+    private postImpressionCountsInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
+}

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

@@ -11,7 +11,6 @@ export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly metadata;
     constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
     track(impressions: ImpressionDTO[]): Promise<void>;
-    private _toJSON;
     count(): Promise<number>;
     drop(count?: number): Promise<any>;
     popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;

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

@@ -1 +1,4 @@
 export declare const LOG_PREFIX = "storage:redis: ";
+export declare const DEFAULT_CACHE_SIZE = 30000;
+export declare const REFRESH_RATE = 300000;
+export declare const TTL_REFRESH = 3600;

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

@@ -0,0 +1,21 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
+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);
+    private postUniqueKeysInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
+}

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

@@ -0,0 +1,16 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { IPluggableStorageWrapper } from '../types';
+export declare class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate?: number);
+    private storeImpressionCounts;
+    start(): void;
+    stop(): Promise<any>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
+}

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

@@ -1,8 +1,8 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+import { ILogger } from '../../logger/types';
 export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;
@@ -16,7 +16,6 @@ export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync
      * or rejected if the wrapper operation fails.
      */
     track(impressions: ImpressionDTO[]): Promise<void>;
-    private _toJSON;
     /**
      * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
      * The promise will never be rejected.

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

@@ -0,0 +1,20 @@
+import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
+export declare class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, uniqueKeysQueueSize?: number, refreshRate?: number);
+    storeUniqueKeys(): Promise<any>;
+    start(): void;
+    stop(): Promise<any>;
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
+}

package/types/storages/types.d.ts

@@ -1,7 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
-import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { MaybeThenable, ISplit } from '../dtos/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -65,23 +64,25 @@ export interface IPluggableStorageWrapper {
     getMany: (keys: string[]) => Promise<(string | null)[]>;
     /** Integer operations */
     /**
-     * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
+     * Increments the number stored at `key` by `increment`, or set it to `increment` if the value doesn't exist.
      *
      * @function incr
      * @param {string} key Key to increment
+     * @param {number} increment Value to increment by. Defaults to 1.
      * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
      * for example, if there is a connection error or the key contains a string that can not be represented as integer.
      */
-    incr: (key: string) => Promise<number>;
+    incr: (key: string, increment?: number) => Promise<number>;
     /**
-     * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
+     * Decrements the number stored at `key` by `decrement`, or set it to minus `decrement` if the value doesn't exist.
      *
      * @function decr
      * @param {string} key Key to decrement
+     * @param {number} decrement Value to decrement by. Defaults to 1.
      * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
      * for example, if there is a connection error or the key contains a string that can not be represented as integer.
      */
-    decr: (key: string) => Promise<number>;
+    decr: (key: string, decrement?: number) => Promise<number>;
     /** Queue operations */
     /**
      * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
@@ -262,41 +263,43 @@ export interface IImpressionsCacheBase {
 export interface IEventsCacheBase {
     track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
 }
-/** Impressions and events cache for standalone mode (sync) */
-export interface IRecorderCacheProducerSync<T> {
+export interface IImpressionCountsCacheBase {
+    track(featureName: string, timeFrame: number, amount: number): void;
+}
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
+}
+/** Impressions and events cache for standalone and partial consumer modes (sync methods) */
+export interface IRecorderCacheSync<T> {
     isEmpty(): boolean;
     clear(): void;
     pop(toMerge?: T): T;
 }
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
     track(data: ImpressionDTO[]): void;
     setOnFullQueueCb(cb: () => void): void;
 }
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
     track(data: SplitIO.EventData, size?: number): boolean;
     setOnFullQueueCb(cb: () => void): void;
 }
-/** Impressions and events cache for consumer and producer mode (async) */
-export interface IRecorderCacheProducerAsync<T> {
+export interface IImpressionCountsCacheSync extends IImpressionCountsCacheBase, IRecorderCacheSync<Record<string, number>> {
+}
+export interface IUniqueKeysCacheSync extends IUniqueKeysCacheBase, IRecorderCacheSync<UniqueKeysPayloadSs | UniqueKeysPayloadCs> {
+    setOnFullQueueCb(cb: () => void): void;
+}
+/** Impressions and events cache for consumer and producer modes (async methods) */
+export interface IRecorderCacheAsync<T> {
     count(): Promise<number>;
     drop(count?: number): Promise<void>;
     popNWithMetadata(count: number): Promise<T>;
 }
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
     track(data: ImpressionDTO[]): Promise<void>;
 }
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
     track(data: SplitIO.EventData, size?: number): Promise<boolean>;
 }
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-    track(featureName: string, timeFrame: number, amount: number): void;
-    isEmpty(): boolean;
-    pop(toMerge?: Record<string, number>): Record<string, number>;
-}
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -347,7 +350,7 @@ export interface ITelemetryEvaluationProducerSync {
 }
 export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
 }
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> {
 }
 /**
  * Telemetry storage interface for consumer mode.
@@ -368,32 +371,30 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
-    impressionCounts?: IImpressionCountsCacheSync;
+    impressionCounts?: TImpressionsCountCache;
     events: TEventsCache;
     telemetry?: TTelemetryCache;
+    uniqueKeys?: TUniqueKeysCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
-    log: ILogger;
-    impressionsQueueSize?: number;
-    eventsQueueSize?: number;
-    optimize?: boolean;
-    mode: SDKMode;
-    matchingKey?: string;
-    splitFiltersValidation?: ISplitFiltersValidation;
+    settings: ISettings;
+    /**
+     * Error-first callback invoked when the storage is ready to be used. An error means that the storage failed to connect and shouldn't be used.
+     * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
+     */
     onReadyCb: (error?: any) => void;
-    metadata: IMetadata;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/storages/utils.d.ts

@@ -0,0 +1,8 @@
+import { IMetadata } from '../dtos/types';
+import { Method } from '../sync/submitters/types';
+import { ImpressionDTO, ISettings } from '../types';
+export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;
+export declare function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[];
+export declare function parseMetadata(field: string): [metadata: string] | string;
+export declare function parseExceptionField(field: string): [metadata: string, method: Method] | string;
+export declare function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string;

package/types/sync/submitters/submitter.d.ts

@@ -1,11 +1,11 @@
 import { ISyncTask } from '../types';
-import { IRecorderCacheProducerSync } from '../../storages/types';
+import { IRecorderCacheSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IResponse } from '../../services/types';
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
+export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
 /**
  * Decorates a provided submitter with a first execution window
  */

package/types/sync/submitters/telemetrySubmitter.d.ts

@@ -1,15 +1,7 @@
-import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { ITelemetryCacheSync } from '../../storages/types';
+import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { ISettings, SDKMode } from '../../types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync): {
-    isEmpty(): boolean;
-    clear(): void;
-    pop(): TelemetryUsageStatsPayload;
-};
 export declare function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.

package/types/sync/submitters/types.d.ts

@@ -33,6 +33,23 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
+export declare type UniqueKeysItemSs = {
+    /** Split name */
+    f: string;
+    /** keyNames */
+    ks: string[];
+};
+export declare type UniqueKeysPayloadSs = {
+    keys: UniqueKeysItemSs[];
+};
+export declare type UniqueKeysPayloadCs = {
+    keys: {
+        /** keyNames */
+        k: string;
+        /** Split name */
+        fs: string[];
+    }[];
+};
 export declare type StoredImpressionWithMetadata = {
     /** Metadata */
     m: IMetadata;
@@ -52,6 +69,8 @@ export declare type StoredImpressionWithMetadata = {
         c: number;
         /** time */
         m: number;
+        /** previous time */
+        pt?: number;
     };
 };
 export declare type StoredEventWithMetadata = {
@@ -80,19 +99,19 @@ export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
 export declare type MY_SEGMENT = 'ms';
 export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
-export declare type LastSync = Record<OperationType, number | undefined>;
-export declare type HttpErrors = Record<OperationType, {
+export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
+export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;
-}>;
-export declare type HttpLatencies = Record<OperationType, Array<number>>;
+}>>;
+export declare type HttpLatencies = Partial<Record<OperationType, Array<number>>>;
 export declare type TREATMENT = 't';
 export declare type TREATMENTS = 'ts';
 export declare type TREATMENT_WITH_CONFIG = 'tc';
 export declare type TREATMENTS_WITH_CONFIG = 'tcs';
 export declare type TRACK = 'tr';
 export declare type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
-export declare type MethodLatencies = Record<Method, Array<number>>;
-export declare type MethodExceptions = Record<Method, number>;
+export declare type MethodLatencies = Partial<Record<Method, Array<number>>>;
+export declare type MethodExceptions = Partial<Record<Method, number>>;
 export declare type CONNECTION_ESTABLISHED = 0;
 export declare type OCCUPANCY_PRI = 10;
 export declare type OCCUPANCY_SEC = 20;
@@ -138,7 +157,8 @@ export declare type CONSUMER_PARTIAL_ENUM = 2;
 export declare type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_ENUM;
 export declare type OPTIMIZED_ENUM = 0;
 export declare type DEBUG_ENUM = 1;
-export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
+export declare type NONE_ENUM = 2;
+export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
 export declare type RefreshRates = {
     sp: number;
     se?: number;

package/types/sync/submitters/uniqueKeysSubmitter.d.ts

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

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

@@ -1,12 +1,4 @@
 import { ISettings } from '../../types';
-/**
- * Checks if impressions previous time should be added or not.
- */
-export declare function shouldAddPt(settings: ISettings): boolean;
-/**
- * Checks if it should dedupe impressions or not.
- */
-export declare function shouldBeOptimized(settings: ISettings): boolean;
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/types/trackers/impressionsTracker.d.ts

@@ -1,7 +1,6 @@
-import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker } from './types';
+import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
 import { ISettings } from '../types';
-import { IImpressionObserver } from './impressionObserver/types';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -9,7 +8,6 @@ import { IImpressionObserver } from './impressionObserver/types';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
- * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
+ * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/strategy/strategyDebug.d.ts

@@ -0,0 +1,9 @@
+import { IImpressionObserver } from '../impressionObserver/types';
+import { IStrategy } from '../types';
+/**
+ * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
+ * @returns IStrategyResult
+ */
+export declare function strategyDebugFactory(impressionsObserver: IImpressionObserver): IStrategy;

package/types/trackers/strategy/strategyNone.d.ts

@@ -0,0 +1,10 @@
+import { IImpressionCountsCacheBase } from '../../storages/types';
+import { IStrategy, IUniqueKeysTracker } from '../types';
+/**
+ * None strategy for impressions tracker.
+ *
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
+ * @returns IStrategyResult
+ */
+export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheBase, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;

package/types/trackers/strategy/strategyOptimized.d.ts

@@ -0,0 +1,11 @@
+import { IImpressionCountsCacheBase } from '../../storages/types';
+import { IImpressionObserver } from '../impressionObserver/types';
+import { IStrategy } from '../types';
+/**
+ * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @returns IStrategyResult
+ */
+export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheBase): IStrategy;

package/types/trackers/types.d.ts

@@ -38,3 +38,26 @@ export interface ITelemetryTracker {
      */
     addTag(tag: string): void;
 }
+export interface IFilterAdapter {
+    add(key: string, featureName: string): boolean;
+    contains(key: string, featureName: string): boolean;
+    clear(): void;
+    refreshRate?: number;
+}
+export interface IImpressionSenderAdapter {
+    recordUniqueKeys(data: Object): void;
+    recordImpressionCounts(data: Object): void;
+}
+/** Unique keys tracker */
+export interface IUniqueKeysTracker {
+    stop(): void;
+    track(key: string, featureName: string): void;
+}
+export interface IStrategyResult {
+    impressionsToStore: ImpressionDTO[];
+    impressionsToListener: ImpressionDTO[];
+    deduped: number;
+}
+export interface IStrategy {
+    process(impressions: ImpressionDTO[]): IStrategyResult;
+}

package/types/trackers/uniqueKeysTracker.d.ts

@@ -0,0 +1,13 @@
+import { ILogger } from '../logger/types';
+import { IUniqueKeysCacheBase } from '../storages/types';
+import { IFilterAdapter, IUniqueKeysTracker } from './types';
+/**
+ * Trackes uniques keys
+ * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ *
+ * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
+ */
+export declare function uniqueKeysTrackerFactory(log: ILogger, uniqueKeysCache: IUniqueKeysCacheBase, filterAdapter?: IFilterAdapter): IUniqueKeysTracker;

package/types/types.d.ts

@@ -715,7 +715,7 @@ export declare namespace SplitIO {
     * ImpressionsMode type
     * @typedef {string} ImpressionsMode
     */
-    type ImpressionsMode = 'OPTIMIZED' | 'DEBUG';
+    type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE';
     /**
      * Defines the format of Split data to preload on the factory storage (cache).
      */

package/types/utils/constants/index.d.ts

@@ -11,6 +11,7 @@ export declare const SPLIT_IMPRESSION = "IMPRESSION";
 export declare const SPLIT_EVENT = "EVENT";
 export declare const DEBUG = "DEBUG";
 export declare const OPTIMIZED = "OPTIMIZED";
+export declare const NONE = "NONE";
 export declare const LOCALHOST_MODE: SDKMode;
 export declare const STANDALONE_MODE: SDKMode;
 export declare const PRODUCER_MODE = "producer";
@@ -31,6 +32,7 @@ export declare const CONSUMER_ENUM = 1;
 export declare const CONSUMER_PARTIAL_ENUM = 2;
 export declare const OPTIMIZED_ENUM = 0;
 export declare const DEBUG_ENUM = 1;
+export declare const NONE_ENUM = 2;
 export declare const SPLITS = "sp";
 export declare const IMPRESSIONS = "im";
 export declare const IMPRESSIONS_COUNT = "ic";

package/types/utils/redis/RedisMock.d.ts

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

package/cjs/storages/metadataBuilder.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.metadataBuilder = void 0;
-var constants_1 = require("../utils/constants");
-function metadataBuilder(settings) {
-    return {
-        s: settings.version,
-        i: settings.runtime.ip || constants_1.UNKNOWN,
-        n: settings.runtime.hostname || constants_1.UNKNOWN,
-    };
-}
-exports.metadataBuilder = metadataBuilder;

package/esm/storages/metadataBuilder.js

@@ -1,8 +0,0 @@
-import { UNKNOWN } from '../utils/constants';
-export function metadataBuilder(settings) {
-    return {
-        s: settings.version,
-        i: settings.runtime.ip || UNKNOWN,
-        n: settings.runtime.hostname || UNKNOWN,
-    };
-}

package/src/storages/metadataBuilder.ts

@@ -1,11 +0,0 @@
-import { IMetadata } from '../dtos/types';
-import { ISettings } from '../types';
-import { UNKNOWN } from '../utils/constants';
-
-export function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata {
-  return {
-    s: settings.version,
-    i: settings.runtime.ip || UNKNOWN,
-    n: settings.runtime.hostname || UNKNOWN,
-  };
-}