@splitsoftware/splitio-commons 1.6.2-rc.4 → 1.6.2-rc.7

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
@@ -49,22 +49,22 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.wrapper.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.wrapper.set(splitKey, stringifiedNewSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type and segment count of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -76,7 +76,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -88,8 +88,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
@@ -109,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name));
+  getSplit(name: string): Promise<ISplit | null> {
+    return this.wrapper.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -118,13 +118,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, string | null> = {};
+      const splits: Record<string, ISplit | null> = {};
       names.forEach((name, idx) => {
-        splits[name] = splitDefinitions[idx];
+        const split = splitDefinitions[idx];
+        splits[name] = split && JSON.parse(split);
       });
       return Promise.resolve(splits);
     });
@@ -135,10 +136,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => Promise.all(listOfKeys.map(this.wrapper.get) as Promise<string>[])
-    );
+  getAll(): Promise<ISplit[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';

package/src/storages/pluggable/index.ts

@@ -1,5 +1,5 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
-import { StorageAsyncFactory } from '../../types';
+import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
@@ -58,7 +58,7 @@ function promisifyEventsTrack(events: any) {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export function PluggableStorage(options: PluggableStorageOptions): StorageAsyncFactory {
+export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory {
 
   validatePluggableStorageOptions(options);
 

package/src/storages/pluggable/wrapperAdapter.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IPluggableStorageWrapper } from '../types';
 import { LOG_PREFIX } from './constants';
 

package/src/storages/types.ts

@@ -1,6 +1,7 @@
-import { MaybeThenable, IMetadata } from '../dtos/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
-import { ImpressionDTO, SDKMode, ILogger, EventData, ISplitFiltersValidation } from '../types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
+import { ILogger } from '../logger/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -190,14 +191,14 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
   removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
-  getSplit(name: string): MaybeThenable<string | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, string | null>>, // `fetchMany` in spec
+  getSplit(name: string): MaybeThenable<ISplit | null>,
+  getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
   setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<string[]>,
+  getAll(): MaybeThenable<ISplit[]>,
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
@@ -210,13 +211,13 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): boolean[],
+  addSplits(entries: [string, ISplit][]): boolean[],
   removeSplits(names: string[]): boolean[],
-  getSplit(name: string): string | null,
-  getSplits(names: string[]): Record<string, string | null>,
+  getSplit(name: string): ISplit | null,
+  getSplits(names: string[]): Record<string, ISplit | null>,
   setChangeNumber(changeNumber: number): boolean,
   getChangeNumber(): number,
-  getAll(): string[],
+  getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
@@ -226,13 +227,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): Promise<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
   removeSplits(names: string[]): Promise<boolean[] | void>,
-  getSplit(name: string): Promise<string | null>,
-  getSplits(names: string[]): Promise<Record<string, string | null>>,
+  getSplit(name: string): Promise<ISplit | null>,
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
   setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<string[]>,
+  getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
@@ -288,7 +289,7 @@ export interface IImpressionsCacheBase {
 
 export interface IEventsCacheBase {
   // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
-  track(data: EventData, size?: number): MaybeThenable<boolean>
+  track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
 }
 
 /** Impressions and events cache for standalone mode (sync) */
@@ -311,8 +312,8 @@ export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderC
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<EventData[]> {
-  track(data: EventData, size?: number): boolean
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+  track(data: SplitIO.EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
@@ -338,7 +339,7 @@ export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorder
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
-  track(data: EventData, size?: number): Promise<boolean>
+  track(data: SplitIO.EventData, size?: number): Promise<boolean>
 }
 
 /**
@@ -346,14 +347,25 @@ export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProdu
  * Only in memory. Named `ImpressionsCounter` in spec.
  */
 export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  // Used by impressions tracker
+// Used by impressions tracker
   track(featureName: string, timeFrame: number, amount: number): void
 
   // Used by impressions count submitter in standalone and producer mode
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
+  pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
 }
 
+export interface IUniqueKeysCacheBase {
+  // Used by unique Keys tracker
+  track(key: string, value: string): void
+
+  // Used by unique keys submitter in standalone and producer mode
+  isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
+  pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs // pop cache data
+  /* Registers callback for full queue */
+  setOnFullQueueCb(cb: () => void): void,
+  clear(): void
+}
 
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
@@ -443,15 +455,18 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheSync,
   TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
+  TUniqueKeysCache extends IUniqueKeysCacheBase
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: IImpressionCountsCacheSync,
+  impressionCounts?: TImpressionsCountCache,
   events: TEventsCache,
-  telemetry?: TTelemetryCache
+  telemetry?: TTelemetryCache,
+  uniqueKeys?: TUniqueKeysCache,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -460,16 +475,20 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheSync,
-  ITelemetryCacheSync
+  ITelemetryCacheSync,
+  IUniqueKeysCacheBase
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync
+  ITelemetryCacheAsync,
+  IUniqueKeysCacheBase
   > { }
 
 /** StorageFactory */
@@ -479,10 +498,14 @@ export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 export interface IStorageFactoryParams {
   log: ILogger,
   impressionsQueueSize?: number,
+  impressionCountsQueueSize?: number,
+  impressionCountsRefreshRate?: number,
+  uniqueKeysRefreshRate?: number,
+  uniqueKeysCacheSize?: number,
   eventsQueueSize?: number,
   optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
   mode: SDKMode,
-
+  impressionsMode?: string,
   // ATM, only used by InLocalStorage
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,
@@ -494,39 +517,14 @@ export interface IStorageFactoryParams {
   metadata: IMetadata,
 }
 
-/**
- * Defines the format of Split data to preload on the factory storage (cache).
- */
-export interface PreloadedData {
-  /**
-   * Timestamp of the last moment the data was synchronized with Split servers.
-   * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
-   * @TODO configurable expiration time policy?
-   */
-  lastUpdated: number,
-  /**
-   * Change number of the preloaded data.
-   * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
-   */
-  since: number,
-  /**
-   * Map of splits to their serialized definitions.
-   */
-  splitsData: {
-    [splitName: string]: string
-  },
-  /**
-   * Optional map of user keys to their list of segments.
-   * @TODO remove when releasing first version
-   */
-  mySegmentsData?: {
-    [key: string]: string[]
-  },
-  /**
-   * Optional map of segments to their serialized definitions.
-   * This property is ignored if `mySegmentsData` was provided.
-   */
-  segmentsData?: {
-    [segmentName: string]: string
-  },
+export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
+
+export type IStorageSyncFactory = {
+  readonly type: StorageType,
+  (params: IStorageFactoryParams): IStorageSync
+}
+
+export type IStorageAsyncFactory = {
+  type: StorageType,
+  (params: IStorageFactoryParams): IStorageAsync
 }

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,12 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { LocalhostFactory } from '../../types';
+import { SplitIO } from '../../types';
 
 // Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject: any = syncManagerOfflineFactory(splitsParserFromSettingsFactory);
+const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
 localhostFromObject.type = 'LocalhostFromObject';
 
-export function LocalhostFromObject() {
-  return localhostFromObject as LocalhostFactory;
+export function LocalhostFromObject(): SplitIO.LocalhostFactory {
+  return localhostFromObject;
 }

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,23 +1,23 @@
 import { ISplitPartial } from '../../../dtos/types';
-import { ISettings, MockedFeaturesMap, TreatmentWithConfig } from '../../../types';
+import { ISettings, SplitIO } from '../../../types';
 import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
-function hasTreatmentChanged(prev: string | TreatmentWithConfig, curr: string | TreatmentWithConfig) {
+function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
   if (typeof prev !== typeof curr) return true;
 
   if (typeof prev === 'string') { // strings treatments, just compare
     return prev !== curr;
   } else { // has treatment and config, compare both
-    return prev.treatment !== (curr as TreatmentWithConfig).treatment || prev.config !== (curr as TreatmentWithConfig).config;
+    return prev.treatment !== (curr as SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
   }
 }
 
 export function splitsParserFromSettingsFactory() {
 
-  let previousMock: MockedFeaturesMap = { 'emptyMock': '1' };
+  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
 
-  function mockUpdated(currentData: MockedFeaturesMap) {
+  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
     const names = Object.keys(currentData);
 
     // Different amount of items
@@ -42,7 +42,7 @@ export function splitsParserFromSettingsFactory() {
    * @param settings validated object with mocked features mapping.
    */
   return function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
-    const features = settings.features as MockedFeaturesMap || {};
+    const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;
 
@@ -53,8 +53,8 @@ export function splitsParserFromSettingsFactory() {
       let config = null;
 
       if (isObject(data)) {
-        treatment = (data as TreatmentWithConfig).treatment;
-        config = (data as TreatmentWithConfig).config || config;
+        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
+        config = (data as SplitIO.TreatmentWithConfig).config || config;
       }
       const configurations: Record<string, string> = {};
       if (config !== null) configurations[treatment as string] = config;

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -2,7 +2,7 @@ import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
-import { ISplitPartial } from '../../../dtos/types';
+import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, string][] = [];
+    const splits: [string, ISplit][] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -38,9 +38,8 @@ export function fromObjectUpdaterFactory(
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
       forOwn(splitsMock, function (val, name) {
-        splits.push([
-          name,
-          JSON.stringify({
+        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+          name, {
             name,
             status: 'ACTIVE',
             killed: false,
@@ -49,7 +48,7 @@ export function fromObjectUpdaterFactory(
             conditions: val.conditions || [],
             configurations: val.configurations,
             trafficTypeName: val.trafficTypeName
-          })
+          }
         ]);
       });
 

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -4,7 +4,7 @@ import { IReadinessManager } from '../../../readiness/types';
 import { MaybeThenable } from '../../../dtos/types';
 import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { thenable } from '../../../utils/promise/thenable';
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -5,7 +5,7 @@ import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>
@@ -40,7 +40,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
 }
 
 interface ISplitMutations {
-  added: [string, string][],
+  added: [string, ISplit][],
   removed: string[],
   segments: string[]
 }
@@ -54,7 +54,7 @@ export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE') {
-      accum.added.push([split.name, JSON.stringify(split)]);
+      accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);

package/src/sync/streaming/SSEHandler/index.ts

@@ -4,7 +4,7 @@ import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_S
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 import { ITelemetryTracker } from '../../../trackers/types';

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';

package/src/sync/submitters/submitter.ts

@@ -1,7 +1,7 @@
 import { syncTaskFactory } from '../syncTask';
 import { ISyncTask } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
 

package/src/sync/submitters/submitterManager.ts

@@ -4,6 +4,7 @@ import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
+import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 
 export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
@@ -15,6 +16,7 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
+  if (params.uniqueKeysTracker) submitters.push(uniqueKeysSubmitterFactory(params));
 
   return {
     // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -52,8 +52,9 @@ const OPERATION_MODE_MAP = {
 
 const IMPRESSIONS_MODE_MAP = {
   [OPTIMIZED]: OPTIMIZED_ENUM,
-  [DEBUG]: DEBUG_ENUM
-} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
+  [DEBUG]: DEBUG_ENUM,
+  [NONE]: NONE_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1 | 2)>;
 
 const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,

package/src/sync/submitters/types.ts

@@ -1,5 +1,5 @@
 import { IMetadata } from '../../dtos/types';
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -35,6 +35,24 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
+export type UniqueKeysPayloadSs = {
+  keys: {
+    /** Split name */
+    f: string
+    /** keyNames */
+    ks: string[]
+  }[]
+}
+
+export type UniqueKeysPayloadCs = {
+  keys: {
+    /** keyNames */
+    k: string
+    /** Split name */
+    fs: string[]
+  }[]
+}
+
 export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
@@ -61,7 +79,7 @@ export type StoredEventWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored event */
-  e: EventData
+  e: SplitIO.EventData
 }
 
 /**
@@ -148,7 +166,8 @@ export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_E
 
 export type OPTIMIZED_ENUM = 0;
 export type DEBUG_ENUM = 1;
-export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
+export type NONE_ENUM = 2;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits