@splitsoftware/splitio-commons 1.17.1-rc.1 → 1.17.1-rc.3

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,6 +7,8 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
+import { loadData } from '../dataLoader';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -14,7 +16,7 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -42,11 +44,18 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
 
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-    shared() {
+    shared(matchingKey: string) {
+      const segments = new MySegmentsCacheInMemory();
+      const largeSegments = new MySegmentsCacheInMemory();
+
+      if (preloadedData) {
+        loadData(preloadedData, { segments, largeSegments }, matchingKey);
+      }
+
       return {
         splits: this.splits,
-        segments: new MySegmentsCacheInMemory(),
-        largeSegments: new MySegmentsCacheInMemory(),
+        segments,
+        largeSegments,
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -72,6 +81,12 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     if (storage.uniqueKeys) storage.uniqueKeys.track = noopTrack;
   }
 
+
+  if (preloadedData) {
+    loadData(preloadedData, storage, getMatching(params.settings.core.key));
+    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
+  }
+
   return storage;
 }
 

package/src/storages/inRedis/RedisAdapter.ts

@@ -20,7 +20,7 @@ const DEFAULT_OPTIONS = {
 const DEFAULT_LIBRARY_OPTIONS = {
   enableOfflineQueue: false,
   connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-  lazyConnect: false
+  lazyConnect: false // @TODO true to avoid side-effects on instantiation.
 };
 
 interface IRedisCommand {

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -62,11 +62,12 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory(params: IStorageFactoryParams) {
     const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
+    let connectPromise: Promise<void>;
 
     const isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
@@ -89,35 +90,6 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
       undefined;
 
-    // Connects to wrapper and emits SDK_READY event on main client
-    const connectPromise = wrapper.connect().then(() => {
-      if (isSyncronizer) {
-        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-        return wrapper.get(keys.buildHashKey()).then((hash) => {
-          const currentHash = getStorageHash(settings);
-          if (hash !== currentHash) {
-            log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-            return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
-              return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
-            }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
-          }
-        }).then(() => {
-          onReadyCb();
-        });
-      } else {
-        // Start periodic flush of async storages if not running synchronizer (producer mode)
-        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
-        if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
-
-        onReadyCb();
-      }
-    }).catch((e) => {
-      e = e || new Error('Error connecting wrapper');
-      onReadyCb(e);
-      return e; // Propagate error for shared clients
-    });
-
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
@@ -127,6 +99,39 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       telemetry,
       uniqueKeys: uniqueKeysCache,
 
+      init() {
+        if (connectPromise) return connectPromise;
+
+        // Connects to wrapper and emits SDK_READY event on main client
+        return connectPromise = wrapper.connect().then(() => {
+          if (isSyncronizer) {
+            // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+            return wrapper.get(keys.buildHashKey()).then((hash) => {
+              const currentHash = getStorageHash(settings);
+              if (hash !== currentHash) {
+                log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+                return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
+                  return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
+                }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
+              }
+            }).then(() => {
+              onReadyCb();
+            });
+          } else {
+            // Start periodic flush of async storages if not running synchronizer (producer mode)
+            if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+            if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+            if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+
+            onReadyCb();
+          }
+        }).catch((e) => {
+          e = e || new Error('Error connecting wrapper');
+          onReadyCb(e);
+          return e; // Propagate error for shared clients
+        });
+      },
+
       // Stop periodic flush and disconnect the underlying storage
       destroy() {
         return Promise.all(isSyncronizer ? [] : [
@@ -136,8 +141,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       },
 
       // emits SDK_READY event on shared clients and returns a reference to the storage
-      shared(_, onReadyCb) {
-        connectPromise.then(onReadyCb);
+      shared(_: string, onReadyCb: (error?: any) => void) {
+        this.init().then(onReadyCb);
 
         return {
           ...this,

package/src/storages/types.ts

@@ -208,8 +208,6 @@ export interface ISplitsCacheBase {
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
-  // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
-  checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
   getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>
 }
@@ -226,7 +224,6 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
-  checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
   getNamesByFlagSets(flagSets: string[]): ISet<string>[]
 }
@@ -243,7 +240,6 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
-  checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
   getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>
 }
@@ -466,6 +462,7 @@ export interface IStorageBase<
   events: TEventsCache,
   telemetry?: TTelemetryCache,
   uniqueKeys?: TUniqueKeysCache,
+  init?: () => void | Promise<void>,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -495,8 +492,6 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
-export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
-
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -504,6 +499,7 @@ export interface IStorageFactoryParams {
    * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
    */
   onReadyCb: (error?: any) => void,
+  onReadyFromCacheCb: (error?: any) => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

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

@@ -7,7 +7,7 @@ import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 
 /**
@@ -60,12 +60,8 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
-            // Emits SDK_READY_FROM_CACHE
-            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-            // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-          });
+          // Emits SDK_READY
+          readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }
         return true;
       });

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

@@ -4,7 +4,7 @@ import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } 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 { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 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';
 import { startsWith } from '../../../utils/lang';
@@ -153,7 +153,8 @@ export function splitChangesUpdaterFactory(
      */
     function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
-      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
+
+      return Promise.resolve(splitUpdateNotification ?
         { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
         splitChangesFetcher(since, noCache, till, _promiseDecorator)
       )
@@ -200,15 +201,6 @@ export function splitChangesUpdaterFactory(
           }
           return false;
         });
-
-      // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
-      // Wrapping in a promise since checkCache can be async.
-      if (splitsEventEmitter && startingUp) {
-        Promise.resolve(splits.checkCache()).then(isCacheReady => {
-          if (isCacheReady) splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
-        });
-      }
-      return fetcherPromise;
     }
 
     let sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error

package/src/trackers/eventTracker.ts

@@ -16,6 +16,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -32,13 +33,15 @@ export function eventTrackerFactory(
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
         // Wrap in a timeout because we don't want it to be blocking.
-        setTimeout(function () {
-          // copy of event, to avoid unexpected behaviour if modified by integrations
-          const eventDataCopy = objectAssign({}, eventData);
-          if (properties) eventDataCopy.properties = objectAssign({}, properties);
-          // integrationsManager does not throw errors (they are internally handled by each integration module)
-          integrationsManager.handleEvent(eventDataCopy);
-        }, 0);
+        whenInit(() => {
+          setTimeout(() => {
+            // copy of event, to avoid unexpected behaviour if modified by integrations
+            const eventDataCopy = objectAssign({}, eventData);
+            if (properties) eventDataCopy.properties = objectAssign({}, properties);
+            // integrationsManager does not throw errors (they are internally handled by each integration module)
+            integrationsManager.handleEvent(eventDataCopy);
+          });
+        });
       }
     } else {
       log.error(ERROR_EVENTS_TRACKER, [msg]);

package/src/trackers/impressionsTracker.ts

@@ -19,6 +19,7 @@ export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
   strategy: IStrategy,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IImpressionsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
@@ -67,16 +68,18 @@ export function impressionsTrackerFactory(
           };
 
           // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(function () {
-            // integrationsManager.handleImpression does not throw errors
-            if (integrationsManager) integrationsManager.handleImpression(impressionData);
+          whenInit(() => {
+            setTimeout(() => {
+              // integrationsManager.handleImpression does not throw errors
+              if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-              if (impressionListener) impressionListener.logImpression(impressionData);
-            } catch (err) {
-              log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-            }
-          }, 0);
+              try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                if (impressionListener) impressionListener.logImpression(impressionData);
+              } catch (err) {
+                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+              }
+            });
+          });
         }
       }
     }

package/src/trackers/types.ts

@@ -65,6 +65,7 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+  start(): void;
   stop(): void;
   track(key: string, featureName: string): void;
 }

package/src/trackers/uniqueKeysTracker.ts

@@ -25,10 +25,6 @@ export function uniqueKeysTrackerFactory(
 ): IUniqueKeysTracker {
   let intervalId: any;
 
-  if (filterAdapter.refreshRate) {
-    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-  }
-
   return {
 
     track(key: string, featureName: string): void {
@@ -39,6 +35,12 @@ export function uniqueKeysTrackerFactory(
       uniqueKeysCache.track(key, featureName);
     },
 
+    start(): void {
+      if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+      }
+    },
+
     stop(): void {
       clearInterval(intervalId);
     }

package/src/types.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from './dtos/types';
+import { ISplit, ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -98,6 +98,7 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
+  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -771,21 +772,20 @@ export namespace SplitIO {
      * 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,
+    // 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 feature flags to their stringified definitions.
+     * List of feature flag definitions.
+     * @TODO rename to flags
      */
-    splitsData: {
-      [splitName: string]: string
-    },
+    splitsData: ISplit[],
     /**
      * Optional map of user keys to their list of segments.
-     * @TODO remove when releasing first version
+     * @TODO rename to memberships
      */
     mySegmentsData?: {
       [key: string]: string[]
@@ -793,9 +793,10 @@ export namespace SplitIO {
     /**
      * Optional map of segments to their stringified definitions.
      * This property is ignored if `mySegmentsData` was provided.
+     * @TODO rename to segments
      */
     segmentsData?: {
-      [segmentName: string]: string
+      [segmentName: string]: string[]
     },
   }
   /**

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -3,14 +3,6 @@ import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
-import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
-
-export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
-  const result = InMemoryStorageCSFactory(params);
-  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
-  return result;
-}
-__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 
 /**
  * This function validates `settings.storage` object
@@ -30,11 +22,6 @@ export function validateStorageCS(settings: { log: ILogger, storage?: any, mode:
     log.error(ERROR_STORAGE_INVALID);
   }
 
-  // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
-  if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
-    return __InLocalStorageMockFactory;
-  }
-
   if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
     // Consumer modes require an async storage
     if (storage.type !== STORAGE_PLUGGABLE) throw new Error('A PluggableStorage instance is required on consumer mode');

package/types/readiness/types.d.ts

@@ -46,6 +46,7 @@ export interface IReadinessManager {
     timeout(): void;
     setDestroyed(): void;
     destroy(): void;
+    init(): void;
     /** for client-side */
     shared(): IReadinessManager;
 }

package/types/sdkFactory/types.d.ts

@@ -48,6 +48,7 @@ export interface ISdkFactoryContext {
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
     clients: Record<string, IBasicClient>;
+    whenInit(cb: () => void): void;
 }
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
     storage: IStorageSync;
@@ -63,6 +64,7 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+    isPure?: boolean;
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -19,11 +19,6 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
     usesSegments(): Promise<boolean>;
-    /**
-     * Check if the splits information is already stored in cache.
-     * Noop, just keeping the interface. This is used by client-side implementations only.
-     */
-    checkCache(): Promise<boolean>;
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -19,11 +19,6 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;
     abstract clear(): void;
-    /**
-     * Check if the splits information is already stored in cache. This data can be preloaded.
-     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-     */
-    checkCache(): boolean;
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/types/storages/dataLoader.d.ts

@@ -1,10 +1,21 @@
 import { SplitIO } from '../types';
-import { DataLoader } from './types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
 /**
- * Factory of client-side storage loader
+ * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+ * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
+ * @param storage object containing `splits` and `segments` cache (client-side variant)
+ * @param userKey user key (matching key) of the provided MySegmentsCache
+ *
+ * @TODO extend to load largeSegments
+ * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+ * @TODO add logs, and input validation in this module, in favor of size reduction.
+ * @TODO unit tests
  */
-export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;
+export declare function loadData(preloadedData: SplitIO.PreloadedData, storage: {
+    splits?: ISplitsCacheSync;
+    segments: ISegmentsCacheSync;
+    largeSegments?: ISegmentsCacheSync;
+}, matchingKey?: string): void;
+export declare function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -35,12 +35,6 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    /**
-     * Check if the splits information is already stored in browser LocalStorage.
-     * In this function we could add more code to check if the data is valid.
-     * @override
-     */
-    checkCache(): boolean;
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *

package/types/storages/types.d.ts

@@ -192,7 +192,6 @@ export interface ISplitsCacheBase {
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
-    checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
     getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
 }
@@ -208,7 +207,6 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
     clear(): void;
-    checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
     getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
@@ -224,7 +222,6 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
     clear(): Promise<boolean | void>;
-    checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
     getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
 }
@@ -385,6 +382,7 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
+    init?: () => void | Promise<void>;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
@@ -394,7 +392,6 @@ export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCa
 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 {
     settings: ISettings;
     /**
@@ -402,6 +399,7 @@ export interface IStorageFactoryParams {
      * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
      */
     onReadyCb: (error?: any) => void;
+    onReadyFromCacheCb: (error?: any) => void;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -54,6 +54,7 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+    start(): void;
     stop(): void;
     track(key: string, featureName: string): void;
 }