@splitsoftware/splitio-commons 1.17.1-rc.2 → 1.17.1-rc.4

package/esm/sync/polling/pollingManagerSS.js

@@ -1,6 +1,5 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -19,9 +18,10 @@ export function pollingManagerSSFactory(params) {
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -1,7 +1,5 @@
-import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { thenable } from '../../../utils/promise/thenable';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -20,27 +18,16 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            if (fetchOnlyNew && since !== -1)
-                return -1;
-            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-                var changeNumber = -1;
-                var results = [];
-                changes.forEach(function (x) {
-                    if (x.added.length > 0)
-                        results.push(segments.addToSegment(segmentName, x.added));
-                    if (x.removed.length > 0)
-                        results.push(segments.removeFromSegment(segmentName, x.removed));
-                    if (x.added.length > 0 || x.removed.length > 0) {
-                        results.push(segments.setChangeNumber(segmentName, x.till));
-                        changeNumber = x.till;
-                    }
-                    log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+            return fetchOnlyNew && since !== -1 ?
+                false :
+                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                    return Promise.all(changes.map(function (x) {
+                        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                        return segments.update(x.name, x.added, x.removed, x.till);
+                    })).then(function (updates) {
+                        return updates.some(function (update) { return update; });
+                    });
                 });
-                // If at least one storage operation result is a promise, join all in a single promise.
-                if (results.some(function (result) { return thenable(result); }))
-                    return Promise.all(results).then(function () { return changeNumber; });
-                return changeNumber;
-            });
         });
     }
     /**
@@ -59,14 +46,11 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers are collected here.
-            var updaters = [];
-            for (var index = 0; index < segmentNames.length; index++) {
-                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-            }
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if (findIndex(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
+                if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -1,6 +1,6 @@
 import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 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';
 import { IN_SEGMENT } from '../../../utils/constants';
@@ -121,7 +121,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            return Promise.resolve(splitUpdateNotification ?
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,6 +165,15 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 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(function (isCacheReady) {
+                    if (isCacheReady)
+                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+                });
+            }
+            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/esm/sync/syncManagerOnline.js

@@ -115,33 +115,32 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                return {
-                    isRunning: mySegmentsSyncTask.isRunning,
-                    start: function () {
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                if (pollingManager.isRunning()) {
-                                    // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
-                                }
-                                else {
-                                    // if not polling, we must execute the sync task for the initial fetch
-                                    // of segments since `syncAll` was already executed when starting the main client
-                                    mySegmentsSyncTask.execute();
-                                }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
-                            }
-                            else {
+                if (running) {
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            if (pollingManager.isRunning()) {
+                                // if doing polling, we must start the periodic fetch of data
                                 if (storage.splits.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
+                            else {
+                                // if not polling, we must execute the sync task for the initial fetch
+                                // of segments since `syncAll` was already executed when starting the main client
+                                mySegmentsSyncTask.execute();
+                            }
+                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (storage.splits.usesSegments())
+                                mySegmentsSyncTask.start();
                         }
-                    },
+                    }
+                    else {
+                        if (!readinessManager.isReady())
+                            mySegmentsSyncTask.execute();
+                    }
+                }
+                return {
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
                         var mySegmentsSyncTask = pollingManager.get(matchingKey);

package/esm/trackers/eventTracker.js

@@ -9,7 +9,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -19,15 +19,17 @@ export function eventTrackerFactory(settings, eventsCache, integrationsManager,
         if (tracked) {
             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
-                    var 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(function () {
+                    // 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
+                        var 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 {

package/esm/trackers/impressionsTracker.js

@@ -11,7 +11,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -50,19 +50,21 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    // 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);
-                        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);
+                    whenInit(function () {
+                        // 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);
+                            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]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/esm/trackers/uniqueKeysTracker.js

@@ -16,9 +16,6 @@ var noopFilterAdapter = {
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -27,6 +24,11 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -1,6 +1,12 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+export function __InLocalStorageMockFactory(params) {
+    var result = InMemoryStorageCSFactory(params);
+    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -17,6 +23,10 @@ export function validateStorageCS(settings) {
         storage = InMemoryStorageCSFactory;
         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)

package/package.json

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

package/src/readiness/readinessManager.ts

@@ -7,6 +7,8 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
     splitsArrived: false,
     splitsCacheLoaded: false,
+    initialized: false,
+    initCallbacks: []
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
@@ -56,8 +58,8 @@ export function readinessManagerFactory(
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
 
-  function timeout() {
-    if (hasTimedout) return;
+  function timeout() { // eslint-disable-next-line no-use-before-define
+    if (hasTimedout || isReady) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
@@ -65,7 +67,8 @@ export function readinessManagerFactory(
 
   let readyTimeoutId: ReturnType<typeof setTimeout>;
   if (readyTimeout > 0) {
-    readyTimeoutId = setTimeout(timeout, readyTimeout);
+    if (splits.initialized) readyTimeoutId = setTimeout(timeout, readyTimeout);
+    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
   }
 
   // emit SDK_READY and SDK_UPDATE
@@ -132,6 +135,12 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
+    init() {
+      if (splits.initialized) return;
+      splits.initialized = true;
+      splits.initCallbacks.forEach(cb => cb());
+    },
+
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/types.ts

@@ -12,6 +12,8 @@ export interface ISplitsEventEmitter extends IEventEmitter {
   once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
   splitsArrived: boolean
   splitsCacheLoaded: boolean
+  initialized: boolean,
+  initCallbacks: (() => void)[]
 }
 
 /** Segments data emitter */
@@ -59,6 +61,7 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
+  init(): void,
 
   /** for client-side */
   shared(): IReadinessManager,

package/src/sdkClient/sdkClientMethodCS.ts

@@ -75,8 +75,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validKey
       );
 
-      sharedSyncManager && sharedSyncManager.start();
-
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -86,8 +86,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validTrafficType
       );
 
-      sharedSyncManager && sharedSyncManager.start();
-
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/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 { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -23,14 +23,20 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    filterAdapterFactory, lazyInit } = params;
   const { log, sync: { impressionsMode } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-  validateAndTrackApiKey(log, settings.core.authorizationKey);
+  // initialization
+  let hasInit = false;
+  const initCallbacks: (() => void)[] = [];
+
+  function whenInit(cb: () => void) {
+    if (hasInit) cb();
+    else initCallbacks.push(cb);
+  }
 
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
@@ -46,11 +52,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb: () => {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-    }
   });
-
+  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
@@ -70,8 +73,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
@@ -88,8 +91,21 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-  syncManager && syncManager.start();
-  signalListener && signalListener.start();
+
+  function init() {
+    if (hasInit) return;
+    hasInit = true;
+
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    readiness.init();
+    uniqueKeysTracker && uniqueKeysTracker.start();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
+
+    initCallbacks.forEach((cb) => cb());
+    initCallbacks.length = 0;
+  }
 
   log.info(NEW_FACTORY);
 
@@ -110,7 +126,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     settings,
 
     destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => {});
+      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
-  }, extraProps && extraProps(ctx));
+  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
 }

package/src/sdkFactory/types.ts

@@ -68,6 +68,8 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
+  lazyInit?: boolean,
 
   // The settings must be already validated
   settings: ISettings,

package/src/storages/{AbstractSegmentsCacheSync.ts → AbstractMySegmentsCacheSync.ts}

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-unused-vars */
 import { IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
@@ -8,18 +6,11 @@ import { ISegmentsCacheSync } from './types';
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
-  /**
-   * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
-   * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.
-   */
-  abstract addToSegment(name: string, segmentKeys?: string[]): boolean
+export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync {
 
-  /**
-   * For server-side synchronizer: remove `segmentKeys` list of keys from `name` segment.
-   * For client-side synchronizer: remove `name` segment from the cache. `segmentKeys` is undefined.
-   */
-  abstract removeFromSegment(name: string, segmentKeys?: string[]): boolean
+  protected abstract addSegment(name: string): boolean
+  protected abstract removeSegment(name: string): boolean
+  protected abstract setChangeNumber(changeNumber?: number): boolean | void
 
   /**
    * For server-side synchronizer: check if `key` is in `name` segment.
@@ -34,11 +25,10 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
     this.resetSegments({});
   }
 
-  /**
-   * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
-   * For client-side synchronizer: the method is not used.
-   */
-  registerSegments(names: string[]): boolean { return false; }
+
+  // No-op. Not used in client-side.
+  registerSegments(): boolean { return false; }
+  update() { return false; }
 
   /**
    * For server-side synchronizer: get the list of segments to fetch changes.
@@ -52,11 +42,6 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
    */
   abstract getKeysCount(): number
 
-  /**
-   * For server-side synchronizer: change number of `name` segment.
-   * For client-side synchronizer: change number of mySegments.
-   */
-  abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void
   abstract getChangeNumber(name: string): number
 
   /**
@@ -64,7 +49,7 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
-    this.setChangeNumber(undefined, segmentsData.cn);
+    this.setChangeNumber(segmentsData.cn);
 
     const { added, removed } = segmentsData as MySegmentsData;
 
@@ -72,11 +57,11 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
       let isDiff = false;
 
       added.forEach(segment => {
-        isDiff = this.addToSegment(segment) || isDiff;
+        isDiff = this.addSegment(segment) || isDiff;
       });
 
       removed.forEach(segment => {
-        isDiff = this.removeFromSegment(segment) || isDiff;
+        isDiff = this.removeSegment(segment) || isDiff;
       });
 
       return isDiff;
@@ -97,11 +82,11 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
 
     // Slowest path => add and/or remove segments
     for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-      this.removeFromSegment(storedSegmentKeys[removeIndex]);
+      this.removeSegment(storedSegmentKeys[removeIndex]);
     }
 
     for (let addIndex = index; addIndex < names.length; addIndex++) {
-      this.addToSegment(names[addIndex]);
+      this.addSegment(names[addIndex]);
     }
 
     return true;

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -28,6 +28,14 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     return Promise.resolve(true);
   }
 
+  /**
+   * 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> {
+    return Promise.resolve(false);
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/AbstractSplitsCacheSync.ts

@@ -48,6 +48,14 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   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 {
+    return false;
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.