@splitsoftware/splitio-commons 2.4.2-rc.2 → 2.5.0-rc.0

package/esm/storages/inLocalStorage/validateCache.js

@@ -8,10 +8,10 @@ var MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
+function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
     var log = settings.log;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!isNaNNumber(lastUpdatedTimestamp)) {
         var cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
         var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -22,11 +22,11 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Check hash
     var storageHashKey = keys.buildHashKey();
-    var storageHash = storage.getItem(storageHashKey);
+    var storageHash = localStorage.getItem(storageHashKey);
     var currentStorageHash = getStorageHash(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            storage.setItem(storageHashKey, currentStorageHash);
+            localStorage.setItem(storageHashKey, currentStorageHash);
         }
         catch (e) {
             log.error(LOG_PREFIX + e);
@@ -39,7 +39,7 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Clear on init
     if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()), 10);
+        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
         if (isNaNNumber(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
             log.info(LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
             return true;
@@ -54,25 +54,23 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
-    return Promise.resolve(storage.load && storage.load()).then(function () {
-        var currentTimestamp = Date.now();
-        var isThereCache = splits.getChangeNumber() > -1;
-        if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            splits.clear();
-            rbSegments.clear();
-            segments.clear();
-            largeSegments.clear();
-            // Update last clear timestamp
-            try {
-                storage.setItem(keys.buildLastClear(), currentTimestamp + '');
-            }
-            catch (e) {
-                settings.log.error(LOG_PREFIX + e);
-            }
-            return false;
+export function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
+    var currentTimestamp = Date.now();
+    var isThereCache = splits.getChangeNumber() > -1;
+    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
+        splits.clear();
+        rbSegments.clear();
+        segments.clear();
+        largeSegments.clear();
+        // Update last clear timestamp
+        try {
+            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
+        }
+        catch (e) {
+            settings.log.error(LOG_PREFIX + e);
         }
-        // Check if ready from cache
-        return isThereCache;
-    });
+        return false;
+    }
+    // Check if ready from cache
+    return isThereCache;
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,6 +6,8 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
+import { setCache } from '../dataLoader';
 import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -13,7 +15,8 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
+    var _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var storages = {};
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
@@ -30,19 +33,27 @@ export function InMemoryStorageCSFactory(params) {
         uniqueKeys: new UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
-            return {
-                splits: this.splits,
-                rbSegments: this.rbSegments,
-                segments: new MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory(),
-                impressions: this.impressions,
-                impressionCounts: this.impressionCounts,
-                events: this.events,
-                telemetry: this.telemetry,
-                uniqueKeys: this.uniqueKeys,
-                destroy: function () { }
-            };
+        shared: function (matchingKey) {
+            if (!storages[matchingKey]) {
+                var segments_1 = new MySegmentsCacheInMemory();
+                var largeSegments_1 = new MySegmentsCacheInMemory();
+                if (preloadedData) {
+                    setCache(log, preloadedData, { segments: segments_1, largeSegments: largeSegments_1 }, matchingKey);
+                }
+                storages[matchingKey] = {
+                    splits: this.splits,
+                    rbSegments: this.rbSegments,
+                    segments: segments_1,
+                    largeSegments: largeSegments_1,
+                    impressions: this.impressions,
+                    impressionCounts: this.impressionCounts,
+                    events: this.events,
+                    telemetry: this.telemetry,
+                    uniqueKeys: this.uniqueKeys,
+                    destroy: function () { }
+                };
+            }
+            return storages[matchingKey];
         },
     };
     // @TODO revisit storage logic in localhost mode
@@ -54,6 +65,13 @@ export function InMemoryStorageCSFactory(params) {
         storage.impressionCounts.track = noopTrack;
         storage.uniqueKeys.track = noopTrack;
     }
+    var matchingKey = getMatching(params.settings.core.key);
+    storages[matchingKey] = storage;
+    if (preloadedData) {
+        setCache(log, preloadedData, storage, matchingKey);
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 InMemoryStorageCSFactory.type = STORAGE_MEMORY;

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -42,6 +42,10 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.get = function (name) {
         return this.cache[name] || null;
     };
+    RBSegmentsCacheInMemory.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
     RBSegmentsCacheInMemory.prototype.contains = function (names) {
         var namesArray = setToArray(names);
         var namesInStorage = this.getNames();

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -42,9 +42,10 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    var isCacheLoaded_1 = storage.validateCache ? storage.validateCache() : false;
+                    Promise.resolve().then(function () {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
+                        if (isCacheLoaded_1)
                             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);

package/esm/sync/syncManagerOnline.js

@@ -66,39 +66,35 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
              */
             start: function () {
                 running = true;
-                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
-                submitterManager.start(!isConsentGranted(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
-                    if (!running)
-                        return;
-                    if (startFirstTime) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-                    }
-                    // start syncing splits and segments
-                    if (pollingManager) {
-                        // If synchronization is disabled pushManager and pollingManager should not start
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                // Doesn't call `syncAll` when the syncManager is resuming
-                                if (startFirstTime) {
-                                    pollingManager.syncAll();
-                                }
-                                pushManager.start();
-                            }
-                            else {
-                                pollingManager.start();
-                            }
-                        }
-                        else {
+                if (startFirstTime) {
+                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+                    if (isCacheLoaded)
+                        Promise.resolve().then(function () { readiness.splits.emit(SDK_SPLITS_CACHE_LOADED); });
+                }
+                // start syncing splits and segments
+                if (pollingManager) {
+                    // If synchronization is disabled pushManager and pollingManager should not start
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            // Doesn't call `syncAll` when the syncManager is resuming
                             if (startFirstTime) {
                                 pollingManager.syncAll();
                             }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
+                        if (startFirstTime) {
+                            pollingManager.syncAll();
                         }
                     }
-                    startFirstTime = false;
-                });
+                }
+                // start periodic data recording (events, impressions, telemetry).
+                submitterManager.start(!isConsentGranted(settings));
+                startFirstTime = false;
             },
             /**
              * Method used to stop/pause the syncManager.

package/esm/utils/env/isLocalStorageAvailable.js

@@ -1,33 +1,12 @@
+/* eslint-disable no-undef */
 export function isLocalStorageAvailable() {
-    try {
-        // eslint-disable-next-line no-undef
-        return isValidStorageWrapper(localStorage);
-    }
-    catch (e) {
-        return false;
-    }
-}
-export function isValidStorageWrapper(wrapper) {
     var mod = '__SPLITSOFTWARE__';
     try {
-        wrapper.setItem(mod, mod);
-        wrapper.getItem(mod);
-        wrapper.removeItem(mod);
+        localStorage.setItem(mod, mod);
+        localStorage.removeItem(mod);
         return true;
     }
     catch (e) {
         return false;
     }
 }
-export function isWebStorage(wrapper) {
-    if (typeof wrapper.length === 'number') {
-        try {
-            wrapper.key(0);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    return false;
-}

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

@@ -3,7 +3,7 @@ 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.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/package.json

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

package/src/sdkFactory/index.ts

@@ -43,7 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   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,10 +52,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb: () => {
+    onReadyFromCacheCb() {
       readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
     }
   });
+
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
   const clients: Record<string, SplitIO.IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -49,10 +49,12 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(segmentsData.cn);
+
     const { added, removed } = segmentsData as MySegmentsData;
-    let isDiff = false;
 
     if (added && removed) {
+      let isDiff = false;
 
       added.forEach(segment => {
         isDiff = this.addSegment(segment) || isDiff;
@@ -61,40 +63,32 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
       removed.forEach(segment => {
         isDiff = this.removeSegment(segment) || isDiff;
       });
-    } else {
 
-      const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-      const storedSegmentKeys = this.getRegisteredSegments().sort();
+      return isDiff;
+    }
 
-      // Extreme fast => everything is empty
-      if (!names.length && !storedSegmentKeys.length) {
-        isDiff = false;
-      } else {
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
 
-        let index = 0;
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
 
-        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+    let index = 0;
 
-        // Quick path => no changes
-        if (index === names.length && index === storedSegmentKeys.length) {
-          isDiff = false;
-        } else {
+    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
 
-          // Slowest path => add and/or remove segments
-          for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeSegment(storedSegmentKeys[removeIndex]);
-          }
+    // Quick path => no changes
+    if (index === names.length && index === storedSegmentKeys.length) return false;
 
-          for (let addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
-          }
+    // Slowest path => add and/or remove segments
+    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeSegment(storedSegmentKeys[removeIndex]);
+    }
 
-          isDiff = true;
-        }
-      }
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addSegment(names[addIndex]);
     }
 
-    this.setChangeNumber(segmentsData.cn);
-    return isDiff;
+    return true;
   }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -14,10 +14,9 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
   update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
-    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    return updated;
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null

package/src/storages/dataLoader.ts

@@ -1,55 +1,113 @@
-import { PreloadedData } from '../types';
-import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
-
-// This value might be eventually set via a config parameter
-const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
+import SplitIO from '../../types/splitio';
+import { IRBSegmentsCacheSync, ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
+import { IMembershipsResponse, IMySegmentsResponse, IRBSegment, ISplit } from '../dtos/types';
+import { ILogger } from '../logger/types';
 
 /**
- * Factory of client-side storage loader
- *
- * @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
+ * Sets the given synchronous storage with the provided preloaded data snapshot.
+ * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
+ * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
-export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
-
-  /**
-   * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-   * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-   *
-   * @param storage - object containing `splits` and `segments` cache (client-side variant)
-   * @param userId - user key string of the provided MySegmentsCache
-   */
-  // @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-  // @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.
-  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0) return;
-
-    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
-
-    const storedSince = storage.splits.getChangeNumber();
-    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-
-    // Do not load data if current localStorage data is more recent,
-    // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-    if (storedSince > since || lastUpdated < expirationTimestamp) return;
-
-    // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
-    storage.splits.clear();
-
-    // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.update(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])), [], since);
-
-    // add mySegments data
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-    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 userIds = JSON.parse(segmentsData[segmentName]).added;
-        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
-      });
+export function setCache(log: ILogger, preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  // Do not load data if current preloadedData is empty
+  if (Object.keys(preloadedData).length === 0) return;
+
+  const { splits, rbSegments, segments, largeSegments } = storage;
+
+  log.debug(`set cache${matchingKey ? ` for key ${matchingKey}` : ''}`);
+
+  if (splits) {
+    splits.clear();
+    splits.update(preloadedData.flags as ISplit[] || [], [], preloadedData.since || -1);
+  }
+
+  if (rbSegments) {
+    rbSegments.clear();
+    rbSegments.update(preloadedData.rbSegments as IRBSegment[] || [], [], preloadedData.rbSince || -1);
+  }
+
+  const segmentsData = preloadedData.segments || {};
+  if (matchingKey) { // add memberships data (client-side)
+    let memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
+    if (!memberships && segmentsData) {
+      memberships = {
+        ms: {
+          k: Object.keys(segmentsData).filter(segmentName => {
+            const segmentKeys = segmentsData[segmentName];
+            return segmentKeys.indexOf(matchingKey) > -1;
+          }).map(segmentName => ({ n: segmentName }))
+        }
+      };
+    }
+
+    if (memberships) {
+      if ((memberships as IMembershipsResponse).ms) segments.resetSegments((memberships as IMembershipsResponse).ms!);
+      if ((memberships as IMembershipsResponse).ls && largeSegments) largeSegments.resetSegments((memberships as IMembershipsResponse).ls!);
     }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
+  } else { // add segments data (server-side)
+    Object.keys(segmentsData).forEach(segmentName => {
+      const segmentKeys = segmentsData[segmentName];
+      segments.update(segmentName, segmentKeys, [], -1);
+    });
+  }
+}
+
+/**
+ * Gets the preloaded data snapshot from the given synchronous storage.
+ * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
+ * Otherwise, the segments data is returned.
+ */
+export function getCache(log: ILogger, storage: IStorageSync, keys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
+
+  log.debug(`get cache${keys ? ` for keys ${keys}` : ''}`);
+
+  return {
+    since: storage.splits.getChangeNumber(),
+    flags: storage.splits.getAll(),
+    rbSince: storage.rbSegments.getChangeNumber(),
+    rbSegments: storage.rbSegments.getAll(),
+    segments: keys ?
+      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 Set<string>);
+        return prev;
+      }, {}),
+    memberships: keys ?
+      keys.reduce<Record<string, IMembershipsResponse>>((prev, key) => {
+        if (storage.shared) {
+          // Client-side segments
+          // @ts-ignore accessing private prop
+          const sharedStorage = storage.shared(key);
+          prev[getMatching(key)] = {
+            ms: {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
+            },
+            ls: sharedStorage.largeSegments ? {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
+            } : undefined
+          };
+        } else {
+          prev[getMatching(key)] = {
+            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(key) ?
+                  prev!.concat({ n: segmentName }) :
+                  prev;
+              }, [])
+            },
+            ls: {
+              k: []
+            }
+          };
+        }
+        return prev;
+      }, {}) :
+      undefined
   };
 }