@splitsoftware/splitio-commons 2.0.0-rc.0 → 2.0.0-rc.2

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -22,33 +22,20 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
   }
 
   /**
-   * Add a list of `segmentKeys` to the given segment `name`.
-   * The returned promise is resolved when the operation success
-   * or rejected if wrapper operation fails.
-   */
-  addToSegment(name: string, segmentKeys: string[]) {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    if (segmentKeys.length) {
-      return this.wrapper.addItems(segmentKey, segmentKeys);
-    } else {
-      return Promise.resolve();
-    }
-  }
-
-  /**
-   * Remove a list of `segmentKeys` from the given segment `name`.
-   * The returned promise is resolved when the operation success
-   * or rejected if wrapper operation fails.
+   * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+   * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+   * or rejected if it fails (e.g., wrapper operation fails).
    */
-  removeFromSegment(name: string, segmentKeys: string[]) {
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    if (segmentKeys.length) {
-      return this.wrapper.removeItems(segmentKey, segmentKeys);
-    } else {
-      return Promise.resolve();
-    }
+    return Promise.all<any>([
+      addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+      removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+      this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+    ]).then(() => {
+      return addedKeys.length > 0 || removedKeys.length > 0;
+    });
   }
 
   /**
@@ -59,17 +46,6 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
   }
 
-  /**
-   * Set till number for the given segment `name`.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  setChangeNumber(name: string, changeNumber: number) {
-    return this.wrapper.set(
-      this.keys.buildSegmentTillKey(name), changeNumber + ''
-    );
-  }
-
   /**
    * Get till number or -1 if it's not defined.
    * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -4,6 +4,7 @@ import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
@@ -27,7 +28,7 @@ export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements
     if (!featureNames.length) return Promise.resolve(false);
 
     const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = Array.from(this.uniqueKeysTracker[featureName]);
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
       const uniqueKeysPayload = {
         f: featureName,
         ks: featureKeys

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -1,5 +1,6 @@
 import { IPluggableStorageWrapper } from '../types';
 import { startsWith, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
@@ -107,7 +108,7 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getItems(key: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve([]);
-      if (set instanceof Set) return Promise.resolve(Array.from(set));
+      if (set instanceof Set) return Promise.resolve(setToArray(set));
       return Promise.reject('key is not a set');
     },
 

package/src/storages/types.ts

@@ -250,38 +250,32 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 /** Segments cache */
 
 export interface ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void> // different signature on Server and Client-Side
-  removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void> // different signature on Server and Client-Side
   isInSegment(name: string, key?: string): MaybeThenable<boolean> // different signature on Server and Client-Side
   registerSegments(names: string[]): MaybeThenable<boolean | void> // only for Server-Side
   getRegisteredSegments(): MaybeThenable<string[]> // only for Server-Side
-  setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void> // only for Server-Side
   getChangeNumber(name: string): MaybeThenable<number> // only for Server-Side
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean> // only for Server-Side
   clear(): MaybeThenable<boolean | void>
 }
 
 // Same API for both variants: SegmentsCache and MySegmentsCache (client-side API)
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys?: string[]): boolean
-  removeFromSegment(name: string, segmentKeys?: string[]): boolean
   isInSegment(name: string, key?: string): boolean
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean | void
   getChangeNumber(name?: string): number
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean // only for Server-Side
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
-  removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
   isInSegment(name: string, key: string): Promise<boolean>
   registerSegments(names: string[]): Promise<boolean | void>
   getRegisteredSegments(): Promise<string[]>
-  setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>
   getChangeNumber(name: string): Promise<number>
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>
   clear(): Promise<boolean | void>
 }
 
@@ -494,8 +488,6 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
-export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
-
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -503,6 +495,10 @@ 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,
+  /**
+   * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
+   */
+  onReadyFromCacheCb: () => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/sync/offline/syncManagerOffline.ts

@@ -1,4 +1,4 @@
-import { ISyncManager, ISyncManagerCS } from '../types';
+import { ISyncManagerCS } from '../types';
 import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { ISplitsParser } from './splitsParser/types';
@@ -29,26 +29,34 @@ export function syncManagerOfflineFactory(
     storage,
   }: ISdkFactoryContextSync): ISyncManagerCS {
 
+    const mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
+    const mainStart = mainSyncManager.start;
+    const sharedStarts: Array<() => void> = [];
+
     return objectAssign(
-      fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings),
+      mainSyncManager,
       {
+        start() {
+          mainStart();
+          sharedStarts.forEach(cb => cb());
+          sharedStarts.length = 0;
+        },
         // fake flush, that resolves immediately
         flush,
 
         // [Only used for client-side]
-        shared(matchingKey: string, readinessManager: IReadinessManager): ISyncManager {
+        shared(matchingKey: string, readinessManager: IReadinessManager) {
+          // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+          // SDK_READY cannot be emitted directly because this will not update the readiness status
+          function emitSdkReady() {
+            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+          }
+
+          if (mainSyncManager.isRunning()) setTimeout(emitSdkReady);
+          else sharedStarts.push(emitSdkReady);
+
           return {
-            start() {
-              // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-              // SDK_READY cannot be emitted directly because this will not update the readiness status
-              setTimeout(() => {
-                readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-              }, 0);
-            },
             stop() { },
-            isRunning() {
-              return true;
-            },
             flush,
           };
         }

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

@@ -1,12 +1,9 @@
 import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { MaybeThenable } from '../../../dtos/types';
-import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { thenable } from '../../../utils/promise/thenable';
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -30,31 +27,22 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean) {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
     let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
     return sincePromise.then(since => {
       // if fetchOnlyNew flag, avoid processing already fetched segments
-      if (fetchOnlyNew && since !== -1) return -1;
-
-      return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-        let changeNumber = -1;
-        const results: MaybeThenable<boolean | void>[] = [];
-        changes.forEach(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((changes) => {
+          return Promise.all(changes.map(x => {
+            log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            return segments.update(segmentName, x.added, x.removed, x.till);
+          })).then((updates) => {
+            return updates.some(update => update);
+          });
         });
-        // If at least one storage operation result is a promise, join all in a single promise.
-        if (results.some(result => thenable(result))) return Promise.all(results).then(() => changeNumber);
-        return changeNumber;
-      });
     });
   }
   /**
@@ -75,16 +63,12 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      // Async fetchers are collected here.
-      const updaters: Promise<number>[] = [];
-
-      for (let index = 0; index < segmentNames.length; index++) {
-        updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-      }
+      // Async fetchers
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready
-        if (findIndex(shouldUpdateFlags, v => v !== -1) !== -1 || readyOnAlreadyExistentState) {
+        if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
           if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }

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

@@ -8,6 +8,7 @@ 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';
 import { IN_SEGMENT } from '../../../utils/constants';
+import { setToArray } from '../../../utils/lang/sets';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -88,7 +89,7 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
     return accum;
   }, { added: [], removed: [], segments: [] } as ISplitMutations);
 
-  computed.segments = Array.from(segments);
+  computed.segments = setToArray(segments);
 
   return computed;
 }

package/src/sync/syncManagerOnline.ts

@@ -143,27 +143,27 @@ export function syncManagerOnlineFactory(
 
         const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
 
-        return {
-          isRunning: mySegmentsSyncTask.isRunning,
-          start() {
-            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() {
             // check in case `client.destroy()` has been invoked more than once for the same client
             const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);

package/src/sync/types.ts

@@ -44,5 +44,5 @@ export interface ISyncManager extends ITask {
 }
 
 export interface ISyncManagerCS extends ISyncManager {
-  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined
+  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined
 }

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 {
@@ -31,14 +32,16 @@ export function eventTrackerFactory(
     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
-          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(() => {
+          // Wrap in a timeout because we don't want it to be blocking.
+          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 {
@@ -66,17 +67,19 @@ export function impressionsTrackerFactory(
             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);
+          whenInit(() => {
+            // Wrap in a timeout because we don't want it to be blocking.
+            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 { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -97,6 +97,7 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
+  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -770,31 +771,31 @@ 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
+     * Optional map of user keys to their memberships.
+     * @TODO rename to memberships
      */
-    mySegmentsData?: {
-      [key: string]: string[]
+    membershipsData?: {
+      [key: string]: IMembershipsResponse
     },
     /**
-     * Optional map of segments to their stringified definitions.
-     * This property is ignored if `mySegmentsData` was provided.
+     * Optional map of segments to their list of keys.
+     * This property is ignored if `membershipsData` was provided.
+     * @TODO rename to segments
      */
     segmentsData?: {
-      [segmentName: string]: string
+      [segmentName: string]: string[]
     },
   }
   /**

package/src/utils/lang/sets.ts

@@ -1,5 +1,15 @@
+export function setToArray<T>(set: Set<T>): T[] {
+  if (Array.from) return Array.from(set);
+
+  const array: T[] = [];
+  set.forEach((value: T) => {
+    array.push(value);
+  });
+  return array;
+}
+
 export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
-  return new Set(Array.from(set).concat(Array.from(set2)));
+  return new Set(setToArray(set).concat(setToArray(set2)));
 }
 
 export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {

package/types/readiness/types.d.ts

@@ -9,6 +9,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 */
 declare type SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';
@@ -46,6 +48,7 @@ export interface IReadinessManager {
     timeout(): void;
     setDestroyed(): void;
     destroy(): void;
+    init(): void;
     /** for client-side */
     shared(): IReadinessManager;
 }

package/types/sdkFactory/types.d.ts

@@ -63,6 +63,7 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+    lazyInit?: boolean;
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;

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/MySegmentsCacheInLocal.d.ts

@@ -1,15 +1,15 @@
 import { ILogger } from '../../logger/types';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     private readonly keys;
     private readonly log;
     constructor(log: ILogger, keys: MySegmentsKeyBuilder);
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
 }

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

@@ -1,15 +1,15 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
  */
-export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
     private segmentCache;
     private cn?;
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
     getRegisteredSegments(): string[];
     getKeysCount(): number;