@splitsoftware/splitio-commons 1.6.2-rc.5 → 1.6.2-rc.6

package/esm/trackers/telemetryTracker.js

@@ -46,6 +46,11 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -56,6 +61,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }

package/esm/utils/constants/index.js

@@ -13,7 +13,6 @@ export var SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export var DEBUG = 'DEBUG';
 export var OPTIMIZED = 'OPTIMIZED';
-export var NONE = 'NONE';
 // SDK Modes
 export var LOCALHOST_MODE = 'localhost';
 export var STANDALONE_MODE = 'standalone';
@@ -38,7 +37,6 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
-export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
     impressionsMode = stringToUpperCase(impressionsMode);
-    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)
+    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
     return OPTIMIZED;
 }

package/esm/utils/settingsValidation/index.js

@@ -31,8 +31,6 @@ export var base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -111,7 +109,6 @@ export function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.5",
+  "version": "1.6.2-rc.6",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();// @ts-ignore
-          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();
+          if (impressionCounts) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

package/src/evaluator/index.ts

@@ -68,28 +68,28 @@ export function evaluateFeatures(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
+  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,7 +124,7 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
+  splits: Record<string, ISplit | null>,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,

package/src/integrations/ga/GaToSplit.ts

@@ -12,6 +12,7 @@ import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
 import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
+import { ITelemetryTracker } from '../../trackers/types';
 
 const logPrefix = 'ga-to-split: ';
 const logNameMapper = 'ga-to-split:mapper';
@@ -25,7 +26,7 @@ const logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
   // get reference to global command queue. Init it if not defined yet.
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
   window[gaAlias] = window[gaAlias] || function () {
@@ -35,10 +36,13 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
   // provides the plugin for use with analytics.js.
   window[gaAlias]('provide', pluginName, pluginConstructor);
 
-  if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-    // Expecting spy on ga.q push method but not found
+  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
     log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
+  if (telemetryTracker && hasAutoRequire) {
+    telemetryTracker.addTag('integration:ga-autorequire');
+  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -191,7 +195,7 @@ export function fixEventTypeId(log: ILogger, eventTypeId: any) {
  */
 export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
 
-  const { storage, settings: { core: coreSettings, log } } = params;
+  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
 
   const defaultOptions = {
     prefix: defaultPrefix,
@@ -291,5 +295,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/integrations/types.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 
 export interface IIntegration {
@@ -11,6 +11,7 @@ export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
   storage: { events: IEventsCacheBase }
   settings: ISettings
+  telemetryTracker: ITelemetryTracker
 }
 
 export type IntegrationFactory = {

package/src/listeners/browser.ts

@@ -7,7 +7,7 @@ import { fromImpressionCountsCollector } from '../sync/submitters/impressionCoun
 import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
-import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
@@ -88,10 +88,9 @@ export class BrowserSignalListener implements ISignalListener {
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
       const eventsUrl = this.settings.urls.events;
-      const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
-        sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
       };
 
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);

package/src/logger/constants.ts

@@ -143,5 +143,4 @@ export const LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
 export const LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export const LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export const LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
-export const LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';
 export const LOG_PREFIX_CLEANUP = 'cleanup: ';

package/src/sdkFactory/index.ts

@@ -13,11 +13,6 @@ import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -26,8 +21,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
   const log = settings.log;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
@@ -43,7 +37,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storageFactoryParams: IStorageFactoryParams = {
     impressionsQueueSize: settings.scheduler.impressionsQueueSize,
     eventsQueueSize: settings.scheduler.eventsQueueSize,
-    uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
     optimize: shouldBeOptimized(settings),
 
     // ATM, only used by InLocalStorage
@@ -52,7 +45,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
     // ATM, only used by PluggableStorage
     mode: settings.mode,
-    impressionsMode: settings.sync.impressionsMode,
 
     // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
     // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
@@ -68,31 +60,18 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
-
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
-
-  let strategy;
-  switch (storageFactoryParams.impressionsMode) {
-    case OPTIMIZED: 
-      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
-      break;
-    case NONE: 
-      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
-      break;
-    default: 
-      strategy = strategyDebugFactory(observer);
-  }
+  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+  // trackers
+  const observer = impressionsObserverFactory && impressionsObserverFactory();
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;

package/src/sdkFactory/types.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
@@ -44,7 +44,6 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker?: IUniqueKeysTracker,
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
@@ -97,11 +96,6 @@ export interface ISdkFactoryParams {
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
   sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
-  // Impression observer factory. If provided, will be used for impressions dedupe
-  impressionsObserverFactory: () => IImpressionObserver
-  
-  filterAdapterFactory?: () => IFilterAdapter
-
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.
   SignalListener?: new (
@@ -113,6 +107,9 @@ export interface ISdkFactoryParams {
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 
+  // Impression observer factory. If provided, will be used for impressions dedupe
+  impressionsObserverFactory?: () => IImpressionObserver
+
   // Optional function to assign additional properties to the factory instance
   extraProps?: (params: ISdkFactoryContext) => object
 }

package/src/sdkManager/index.ts

@@ -18,16 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
-  let splitObject: ISplit | null;
-
-  try {
-    // @ts-expect-error
-    splitObject = JSON.parse(json);
-  } catch (e) {
-    return null;
-  }
-
+function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -40,10 +31,10 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(jsons: string[]) {
+function objectsToViews(splitObjects: ISplit[]) {
   let views: SplitIO.SplitView[] = [];
 
-  jsons.forEach(split => {
+  splitObjects.forEach(split => {
     const view = objectToView(split);
     if (view) views.push(view);
   });

package/src/services/splitApi.ts

@@ -106,28 +106,6 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
-    
-    /**
-     * Post unique keys for client side.
-     *
-     * @param body  unique keys payload
-     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/cs`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
-    
-    /**
-     * Post unique keys for server side.
-     *
-     * @param body  unique keys payload
-     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/ss`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
 
     postMetricsConfig(body: string) {
       const url = `${urls.telemetry}/v1/metrics/config`;

package/src/services/types.ts

@@ -43,10 +43,6 @@ export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => P
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
 export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
@@ -63,8 +59,6 @@ export interface ISplitApi {
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
-	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
-	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs
 	postTestImpressionsBulk: IPostTestImpressionsBulk
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -7,14 +8,15 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  abstract addSplit(name: string, split: string): Promise<boolean>
-  abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>
+  // Implement addSplits and removeSplits here and others like AbstractSplitsCacheSync, to reuse code between redis and pluggable implementations
+  abstract addSplit(name: string, split: ISplit): Promise<boolean>
+  abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>
   abstract removeSplits(names: string[]): Promise<boolean[] | void>
-  abstract getSplit(name: string): Promise<string | null>
-  abstract getSplits(names: string[]): Promise<Record<string, string | null>>
+  abstract getSplit(name: string): Promise<ISplit | null>
+  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
   abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<string[]>
+  abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
@@ -47,16 +49,13 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
     return this.getSplit(name).then(split => {
 
-      if (split) {
-        const parsedSplit: ISplit = JSON.parse(split);
-        if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-          parsedSplit.killed = true;
-          parsedSplit.defaultTreatment = defaultTreatment;
-          parsedSplit.changeNumber = changeNumber;
-          const newSplit = JSON.stringify(parsedSplit);
+      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+        const newSplit = objectAssign({}, split);
+        newSplit.killed = true;
+        newSplit.defaultTreatment = defaultTreatment;
+        newSplit.changeNumber = changeNumber;
 
-          return this.addSplit(name, newSplit);
-        }
+        return this.addSplit(name, newSplit);
       }
       return false;
     }).catch(() => false);

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -7,9 +8,9 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: string): boolean;
+  abstract addSplit(name: string, split: ISplit): boolean
 
-  addSplits(entries: [string, string][]): boolean[] {
+  addSplits(entries: [string, ISplit][]): boolean[] {
     return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
   }
 
@@ -19,10 +20,10 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return names.map(name => this.removeSplit(name));
   }
 
-  abstract getSplit(name: string): string | null
+  abstract getSplit(name: string): ISplit | null
 
-  getSplits(names: string[]): Record<string, string | null> {
-    const splits: Record<string, string | null> = {};
+  getSplits(names: string[]): Record<string, ISplit | null> {
+    const splits: Record<string, ISplit | null> = {};
     names.forEach(name => {
       splits[name] = this.getSplit(name);
     });
@@ -33,8 +34,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract getChangeNumber(): number
 
-  getAll(): string[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as string);
+  getAll(): ISplit[] {
+    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
   }
 
   abstract getSplitNames(): string[]
@@ -66,16 +67,13 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
     const split = this.getSplit(name);
 
-    if (split) {
-      const parsedSplit: ISplit = JSON.parse(split);
-      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-        parsedSplit.killed = true;
-        parsedSplit.defaultTreatment = defaultTreatment;
-        parsedSplit.changeNumber = changeNumber;
-        const newSplit = JSON.stringify(parsedSplit);
+    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+      const newSplit = objectAssign({}, split);
+      newSplit.killed = true;
+      newSplit.defaultTreatment = defaultTreatment;
+      newSplit.changeNumber = changeNumber;
 
-        return this.addSplit(name, newSplit);
-      }
+      return this.addSplit(name, newSplit);
     }
     return false;
   }

package/src/storages/KeyBuilderSS.ts

@@ -27,14 +27,6 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.impressions`;
   }
 
-  buildImpressionsCountKey() {
-    return `${this.prefix}.impressions.count`;
-  }
-  
-  buildUniqueKeysKey() {
-    return `${this.prefix}.uniquekeys`;
-  }
-
   buildEventsKey() {
     return `${this.prefix}.events`;
   }

package/src/storages/dataLoader.ts

@@ -39,7 +39,7 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => [splitName, splitsData[splitName]]));
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -38,7 +38,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     else localStorage.removeItem(key);
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: ISplit | null) {
     try {
       if (split) {
         if (split.trafficTypeName) {
@@ -99,18 +99,16 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(name: string, split: string) {
+  addSplit(name: string, split: ISplit) {
     try {
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
       this._decrementCounts(previousSplit);
 
-      localStorage.setItem(splitKey, split);
+      localStorage.setItem(splitKey, JSON.stringify(split));
 
-      const parsedSplit = split ? JSON.parse(split) : null;
-
-      this._incrementCounts(parsedSplit);
+      this._incrementCounts(split);
 
       return true;
     } catch (e) {
@@ -124,8 +122,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const split = this.getSplit(name);
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
-      const parsedSplit = JSON.parse(split as string);
-      this._decrementCounts(parsedSplit);
+      this._decrementCounts(split);
 
       return true;
     } catch (e) {
@@ -135,7 +132,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getSplit(name: string) {
-    return localStorage.getItem(this.keys.buildSplitKey(name));
+    const item = localStorage.getItem(this.keys.buildSplitKey(name));
+    return item && JSON.parse(item);
   }
 
   setChangeNumber(changeNumber: number): boolean {
@@ -184,7 +182,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return n;
   }
 
-  getSplitNames() {
+  getSplitNames(): string[] {
     const len = localStorage.length;
     const accum = [];