@splitsoftware/splitio-commons 2.4.2-rc.1 → 2.4.2-rc.2

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -6,29 +6,28 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
 import { setToArray } from '../../utils/lang/sets';
+import { StorageAdapter } from '../types';
 
-/**
- * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
- */
 export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
+  private readonly storage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
     super();
     this.keys = keys;
     this.log = settings.log;
     this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+    this.storage = storage;
   }
 
   private _decrementCount(key: string) {
-    const count = toNumber(localStorage.getItem(key)) - 1;
-    // @ts-expect-error
-    if (count > 0) localStorage.setItem(key, count);
-    else localStorage.removeItem(key);
+    const count = toNumber(this.storage.getItem(key)) - 1;
+    if (count > 0) this.storage.setItem(key, count + '');
+    else this.storage.removeItem(key);
   }
 
   private _decrementCounts(split: ISplit) {
@@ -48,13 +47,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private _incrementCounts(split: ISplit) {
     try {
       const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      // @ts-expect-error
-      localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+      this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
 
       if (usesSegments(split)) {
         const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        // @ts-expect-error
-        localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+        this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
       }
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -68,15 +65,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    */
   clear() {
     // collect item keys
-    const len = localStorage.length;
+    const len = this.storage.length;
     const accum = [];
     for (let cur = 0; cur < len; cur++) {
-      const key = localStorage.key(cur);
+      const key = this.storage.key(cur);
       if (key != null && this.keys.isSplitsCacheKey(key)) accum.push(key);
     }
     // remove items
     accum.forEach(key => {
-      localStorage.removeItem(key);
+      this.storage.removeItem(key);
     });
 
     this.hasSync = false;
@@ -86,15 +83,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     try {
       const name = split.name;
       const splitKey = this.keys.buildSplitKey(name);
-      const splitFromLocalStorage = localStorage.getItem(splitKey);
-      const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
+      const splitFromStorage = this.storage.getItem(splitKey);
+      const previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
 
       if (previousSplit) {
         this._decrementCounts(previousSplit);
         this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
       }
 
-      localStorage.setItem(splitKey, JSON.stringify(split));
+      this.storage.setItem(splitKey, JSON.stringify(split));
 
       this._incrementCounts(split);
       this.addToFlagSets(split);
@@ -111,7 +108,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const split = this.getSplit(name);
       if (!split) return false;
 
-      localStorage.removeItem(this.keys.buildSplitKey(name));
+      this.storage.removeItem(this.keys.buildSplitKey(name));
 
       this._decrementCounts(split);
       this.removeFromFlagSets(split.name, split.sets);
@@ -124,15 +121,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getSplit(name: string): ISplit | null {
-    const item = localStorage.getItem(this.keys.buildSplitKey(name));
+    const item = this.storage.getItem(this.keys.buildSplitKey(name));
     return item && JSON.parse(item);
   }
 
   setChangeNumber(changeNumber: number): boolean {
     try {
-      localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+      this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
       this.hasSync = true;
       return true;
     } catch (e) {
@@ -143,7 +140,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   getChangeNumber(): number {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildSplitsTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildSplitsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);
@@ -155,13 +152,13 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getSplitNames(): string[] {
-    const len = localStorage.length;
+    const len = this.storage.length;
     const accum = [];
 
     let cur = 0;
 
     while (cur < len) {
-      const key = localStorage.key(cur);
+      const key = this.storage.key(cur);
 
       if (key != null && this.keys.isSplitKey(key)) accum.push(this.keys.extractKey(key));
 
@@ -172,7 +169,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   trafficTypeExists(trafficType: string): boolean {
-    const ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+    const ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
     return isFiniteNumber(ttCount) && ttCount > 0;
   }
 
@@ -180,7 +177,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     // If cache hasn't been synchronized with the cloud, assume we need them.
     if (!this.hasSync) return true;
 
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     return isFiniteNumber(splitsWithSegmentsCount) ?
@@ -191,9 +188,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+      const flagSetFromStorage = this.storage.getItem(flagSetKey);
 
-      return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
     });
   }
 
@@ -206,12 +203,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
       const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
 
-      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+      const flagSetFromStorage = this.storage.getItem(flagSetKey);
 
-      const flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      const flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
       flagSetCache.add(featureFlag.name);
 
-      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+      this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
     });
   }
 
@@ -226,19 +223,19 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private removeNames(flagSetName: string, featureFlagName: string) {
     const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
 
-    const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+    const flagSetFromStorage = this.storage.getItem(flagSetKey);
 
-    if (!flagSetFromLocalStorage) return;
+    if (!flagSetFromStorage) return;
 
-    const flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
+    const flagSetCache = new Set(JSON.parse(flagSetFromStorage));
     flagSetCache.delete(featureFlagName);
 
     if (flagSetCache.size === 0) {
-      localStorage.removeItem(flagSetKey);
+      this.storage.removeItem(flagSetKey);
       return;
     }
 
-    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
   }
 
 }

package/src/storages/inLocalStorage/index.ts

@@ -1,10 +1,10 @@
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
+import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory, StorageAdapter } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
-import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
+import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -15,7 +15,24 @@ import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/Telem
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
 import { validateCache } from './validateCache';
+import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
+import { storageAdapter } from './storageAdapter';
+
+function validateStorage(log: ILogger, prefix: string, wrapper?: SplitIO.StorageWrapper): StorageAdapter | undefined {
+  if (wrapper) {
+    if (isValidStorageWrapper(wrapper)) {
+      return isWebStorage(wrapper) ?
+        wrapper as StorageAdapter: // localStorage and sessionStorage don't need adapter
+        storageAdapter(log, prefix, wrapper);
+    }
+    log.warn(LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
+  }
+
+  if (isLocalStorageAvailable()) return localStorage;
+
+  log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+}
 
 /**
  * InLocal storage factory for standalone client-side SplitFactory
@@ -25,21 +42,19 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
   const prefix = validatePrefix(options.prefix);
 
   function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
 
-    // Fallback to InMemoryStorage if LocalStorage API is not available
-    if (!isLocalStorageAvailable()) {
-      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-      return InMemoryStorageCSFactory(params);
-    }
+    const storage = validateStorage(log, prefix, options.wrapper);
+    if (!storage) return InMemoryStorageCSFactory(params);
 
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
 
-    const splits = new SplitsCacheInLocal(settings, keys);
-    const rbSegments = new RBSegmentsCacheInLocal(settings, keys);
-    const segments = new MySegmentsCacheInLocal(log, keys);
-    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
+    const splits = new SplitsCacheInLocal(settings, keys, storage);
+    const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
+    const segments = new MySegmentsCacheInLocal(log, keys, storage);
+    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
+    let validateCachePromise: Promise<boolean> | undefined;
 
     return {
       splits,
@@ -53,10 +68,12 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
       validateCache() {
-        return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
+        return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
       },
 
-      destroy() { },
+      destroy() {
+        return storage.save && storage.save();
+      },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
@@ -64,8 +81,8 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
         return {
           splits: this.splits,
           rbSegments: this.rbSegments,
-          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
+          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),
           impressions: this.impressions,
           impressionCounts: this.impressionCounts,
           events: this.events,

package/src/storages/inLocalStorage/storageAdapter.ts

@@ -0,0 +1,50 @@
+import { ILogger } from '../../logger/types';
+import SplitIO from '../../../types/splitio';
+import { LOG_PREFIX } from './constants';
+import { StorageAdapter } from '../types';
+
+function isTillKey(key: string) {
+  return key.endsWith('.till');
+}
+
+export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.StorageWrapper): StorageAdapter {
+  let cache: Record<string, string> = {};
+
+  let connectPromise: Promise<void> | undefined;
+  let disconnectPromise = Promise.resolve();
+
+  return {
+    load() {
+      return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then((storedCache) => {
+        cache = JSON.parse(storedCache || '{}');
+      }).catch((e) => {
+        log.error(LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+      }));
+    },
+    save() {
+      return disconnectPromise = disconnectPromise.then(() => {
+        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch((e) => {
+          log.error(LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
+        });
+      });
+    },
+
+    get length() {
+      return Object.keys(cache).length;
+    },
+    getItem(key: string) {
+      return cache[key] || null;
+    },
+    key(index: number) {
+      return Object.keys(cache)[index] || null;
+    },
+    removeItem(key: string) {
+      delete cache[key];
+      if (isTillKey(key)) this.save!();
+    },
+    setItem(key: string, value: string) {
+      cache[key] = value;
+      if (isTillKey(key)) this.save!();
+    }
+  };
+}

package/src/storages/inLocalStorage/validateCache.ts

@@ -7,6 +7,7 @@ import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import SplitIO from '../../../types/splitio';
+import { StorageAdapter } from '../types';
 
 const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
 const MILLIS_IN_A_DAY = 86400000;
@@ -16,11 +17,11 @@ const MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
+function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
   const { log } = settings;
 
   // Check expiration
-  const lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()) as string, 10);
+  const lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()) as string, 10);
   if (!isNaNNumber(lastUpdatedTimestamp)) {
     const cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
     const expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -32,12 +33,12 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: IS
 
   // Check hash
   const storageHashKey = keys.buildHashKey();
-  const storageHash = localStorage.getItem(storageHashKey);
+  const storageHash = storage.getItem(storageHashKey);
   const currentStorageHash = getStorageHash(settings);
 
   if (storageHash !== currentStorageHash) {
     try {
-      localStorage.setItem(storageHashKey, currentStorageHash);
+      storage.setItem(storageHashKey, currentStorageHash);
     } catch (e) {
       log.error(LOG_PREFIX + e);
     }
@@ -50,7 +51,7 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: IS
 
   // Clear on init
   if (options.clearOnInit) {
-    const lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()) as string, 10);
+    const lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()) as string, 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');
@@ -67,27 +68,29 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: IS
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
+export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
 
-  const currentTimestamp = Date.now();
-  const isThereCache = splits.getChangeNumber() > -1;
+  return Promise.resolve(storage.load && storage.load()).then(() => {
+    const currentTimestamp = Date.now();
+    const isThereCache = splits.getChangeNumber() > -1;
 
-  if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
-    splits.clear();
-    rbSegments.clear();
-    segments.clear();
-    largeSegments.clear();
+    if (validateExpiration(options, storage, 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);
-    }
+      // Update last clear timestamp
+      try {
+        storage.setItem(keys.buildLastClear(), currentTimestamp + '');
+      } catch (e) {
+        settings.log.error(LOG_PREFIX + e);
+      }
 
-    return false;
-  }
+      return false;
+    }
 
-  // Check if ready from cache
-  return isThereCache;
+    // Check if ready from cache
+    return isThereCache;
+  });
 }

package/src/storages/types.ts

@@ -4,6 +4,22 @@ import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { ISettings } from '../types';
 
+/**
+ * Internal interface based on a subset of the Web Storage API interface
+ * (https://developer.mozilla.org/en-US/docs/Web/API/Storage) used by the SDK
+ */
+export interface StorageAdapter {
+  // Methods to support async storages
+  load?: () => Promise<void>;
+  save?: () => Promise<void>;
+  // Methods based on https://developer.mozilla.org/en-US/docs/Web/API/Storage
+  readonly length: number;
+  getItem(key: string): string | null;
+  key(index: number): string | null;
+  removeItem(key: string): void;
+  setItem(key: string, value: string): void;
+}
+
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -479,7 +495,7 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => boolean, // @TODO support async
+  validateCache?: () => Promise<boolean>,
   largeSegments?: ISegmentsCacheSync,
 }
 

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

@@ -59,8 +59,7 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-          Promise.resolve().then(() => {
+          Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
             // Emits SDK_READY_FROM_CACHE
             if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY

package/src/sync/polling/pollingManagerCS.ts

@@ -8,6 +8,7 @@ import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -43,7 +44,7 @@ export function pollingManagerCSFactory(
   // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
     if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
-    const usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+    const usingSegments = usesSegmentsSync(storage);
     if (usingSegments !== mySegmentsSyncTask.isRunning()) {
       log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
       if (usingSegments) {
@@ -59,9 +60,9 @@ export function pollingManagerCSFactory(
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     }
-    if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) setTimeout(smartReady, 0);
+    if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
     else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
     mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
@@ -77,7 +78,7 @@ export function pollingManagerCSFactory(
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) startMySegmentsSyncTasks();
+      if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)

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

@@ -8,6 +8,7 @@ import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
+import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
 
 type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -27,7 +28,7 @@ export function mySegmentsUpdaterFactory(
   matchingKey: string
 ): IMySegmentsUpdater {
 
-  const { splits, rbSegments, segments, largeSegments } = storage;
+  const { segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -51,7 +52,7 @@ export function mySegmentsUpdaterFactory(
     }
 
     // Notify update if required
-    if ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
       segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }

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

@@ -59,7 +59,7 @@ interface ISplitMutations<T extends ISplit | IRBSegment> {
 
 /**
  * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there are set filter defined, names filter is ignored
+ * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
  *
  * @param featureFlag - feature flag to be evaluated
  * @param filters - splitFiltersValidation bySet | byName

package/src/sync/syncManagerOnline.ts

@@ -10,6 +10,7 @@ import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
 
 /**
  * Online SyncManager factory.
@@ -88,36 +89,41 @@ export function syncManagerOnlineFactory(
       start() {
         running = true;
 
-        if (startFirstTime) {
-          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-          if (isCacheLoaded) Promise.resolve().then(() => { readiness.splits.emit(SDK_SPLITS_CACHE_LOADED); });
-        }
+        // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
+        submitterManager.start(!isConsentGranted(settings));
 
-        // start syncing splits and segments
-        if (pollingManager) {
+        return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
+          if (!running) return;
 
-          // 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) {
+            // 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) {
                 pollingManager.syncAll();
               }
-              pushManager.start();
-            } else {
-              pollingManager.start();
-            }
-          } else {
-            if (startFirstTime) {
-              pollingManager.syncAll();
             }
           }
-        }
-
-        // start periodic data recording (events, impressions, telemetry).
-        submitterManager.start(!isConsentGranted(settings));
 
-        startFirstTime = false;
+          startFirstTime = false;
+        });
       },
 
       /**
@@ -155,14 +161,14 @@ export function syncManagerOnlineFactory(
             if (pushManager) {
               if (pollingManager.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
-                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+                if (usesSegmentsSync(storage)) 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();
               }
             } else {
-              if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+              if (usesSegmentsSync(storage)) mySegmentsSyncTask.start();
             }
           } else {
             if (!readinessManager.isReady()) mySegmentsSyncTask.execute();