Update data loader to support memberships

Author: EmilianoSanchez

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 } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -43,7 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const storage = storageFactory({
     settings,
-    onReadyCb: (error) => {
+    onReadyCb(error) {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -52,6 +52,9 @@ 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);
+    }
   });
 
   const clients: Record<string, IBasicClient> = {};

src/storages/__tests__/dataLoader.spec.ts

@@ -11,7 +11,7 @@ test('loadData & getSnapshot', () => {
   const serverStorage = InMemoryStorageFactory({ settings: fullSettings });
   serverStorage.splits.setChangeNumber(123); // @ts-expect-error
   serverStorage.splits.addSplits([['split1', { name: 'split1' }]]);
-  serverStorage.segments.addToSegment('segment1', [fullSettings.core.key as string]);
+  serverStorage.segments.update('segment1', [fullSettings.core.key as string], [], 123);
 
   const preloadedData = dataLoader.getSnapshot(serverStorage, [fullSettings.core.key as string]);
 
@@ -25,7 +25,7 @@ test('loadData & getSnapshot', () => {
   expect(preloadedData).toEqual({
     since: 123,
     splitsData: [{ name: 'split1' }],
-    mySegmentsData: { [fullSettings.core.key as string]: ['segment1'] },
+    membershipsData: { [fullSettings.core.key as string]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } } },
     segmentsData: undefined
   });
 });

src/storages/dataLoader.ts

@@ -1,7 +1,8 @@
 import { SplitIO } from '../types';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray, ISet } from '../utils/lang/sets';
+import { setToArray } from '../utils/lang/sets';
 import { getMatching } from '../utils/key';
+import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
 
 /**
  * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
@@ -37,19 +38,26 @@ export function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits
   }
 
   if (matchingKey) { // add mySegments data (client-side)
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
-    if (!mySegmentsData) {
-      // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-      mySegmentsData = Object.keys(segmentsData).filter(segmentName => {
-        const matchingKeys = segmentsData[segmentName];
-        return matchingKeys.indexOf(matchingKey) > -1;
-      });
+    let membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
+    if (!membershipsData && segmentsData) {
+      membershipsData = {
+        ms: {
+          k: Object.keys(segmentsData).filter(segmentName => {
+            const segmentKeys = segmentsData[segmentName];
+            return segmentKeys.indexOf(matchingKey) > -1;
+          }).map(segmentName => ({ n: segmentName }))
+        }
+      };
     }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
+    if (membershipsData) {
+      if (membershipsData.ms) storage.segments.resetSegments(membershipsData.ms);
+      if (membershipsData.ls && storage.largeSegments) storage.largeSegments.resetSegments(membershipsData.ls);
+    }
+
   } else { // add segments data (server-side)
-    Object.keys(segmentsData).filter(segmentName => {
-      const matchingKeys = segmentsData[segmentName];
-      storage.segments.addToSegment(segmentName, matchingKeys);
+    Object.keys(segmentsData).forEach(segmentName => {
+      const segmentKeys = segmentsData[segmentName];
+      storage.segments.update(segmentName, segmentKeys, [], -1);
     });
   }
 }
@@ -62,22 +70,43 @@ export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]
     segmentsData: userKeys ?
       undefined : // @ts-ignore accessing private prop
       Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
-        prev[cur] = setToArray(storage.segments.segmentCache[cur] as ISet<string>);
+        prev[cur] = setToArray(storage.segments.segmentCache[cur] as Set<string>);
         return prev;
       }, {}),
-    mySegmentsData: userKeys ?
-      userKeys.reduce<Record<string, string[]>>((prev, userKey) => {
-        prev[getMatching(userKey)] = storage.shared ?
+    membershipsData: userKeys ?
+      userKeys.reduce<Record<string, IMembershipsResponse>>((prev, userKey) => {
+        if (storage.shared) {
           // Client-side segments
           // @ts-ignore accessing private prop
-          Object.keys(storage.shared(userKey).segments.segmentCache) :
-          // Server-side segments
-          // @ts-ignore accessing private prop
-          Object.keys(storage.segments.segmentCache).reduce<string[]>((prev, segmentName) => { // @ts-ignore accessing private prop
-            return storage.segments.segmentCache[segmentName].has(userKey) ?
-              prev.concat(segmentName) :
-              prev;
-          }, []);
+          const sharedStorage = storage.shared(userKey);
+          prev[getMatching(userKey)] = {
+            ms: {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
+              // cn: sharedStorage.segments.getChangeNumber()
+            },
+            ls: sharedStorage.largeSegments ? {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
+              // cn: sharedStorage.largeSegments.getChangeNumber()
+            } : undefined
+          };
+        } else {
+          prev[getMatching(userKey)] = {
+            ms: {
+              // Server-side segments
+              // @ts-ignore accessing private prop
+              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore accessing private prop
+                return storage.segments.segmentCache[segmentName].has(userKey) ?
+                  prev!.concat({ n: segmentName }) :
+                  prev;
+              }, [])
+            },
+            ls: {
+              k: []
+            }
+          };
+        }
         return prev;
       }, {}) :
       undefined

src/storages/types.ts

@@ -495,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';

src/types.ts

@@ -1,4 +1,4 @@
-import { ISplit, 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';
@@ -783,15 +783,15 @@ export namespace SplitIO {
      */
     splitsData: ISplit[],
     /**
-     * Optional map of user keys to their list of segments.
+     * 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?: {