@splitsoftware/splitio-commons 2.1.0-rc.2 → 2.1.0

package/esm/sync/syncManagerOnline.js

@@ -3,7 +3,6 @@ import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -17,7 +16,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker;
         /** Polling Manager */
         var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
@@ -65,11 +64,6 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
              */
             start: function () {
                 running = true;
-                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
@@ -78,6 +72,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                             // Doesn't call `syncAll` when the syncManager is resuming
                             if (startFirstTime) {
                                 pollingManager.syncAll();
+                                startFirstTime = false;
                             }
                             pushManager.start();
                         }
@@ -88,12 +83,12 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     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/trackers/uniqueKeysTracker.js

@@ -5,7 +5,7 @@ var noopFilterAdapter = {
     clear: function () { }
 };
 /**
- * Trackes uniques keys
+ * Tracks uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *

package/esm/utils/constants/browser.js

@@ -0,0 +1,2 @@
+// This value might be eventually set via a config parameter
+export var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days

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 true; }; // to emit SDK_READY_FROM_CACHE
+    result.splits.checkCache = 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.1.0-rc.2",
+  "version": "2.1.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/readiness/readinessManager.ts

@@ -3,7 +3,6 @@ import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
-import { STORAGE_LOCALSTORAGE } from '../utils/constants';
 
 function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
@@ -115,10 +114,6 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
-          if (!isReadyFromCache && settings.storage?.type === STORAGE_LOCALSTORAGE) {
-            isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE);
-          }
           gate.emit(SDK_READY);
         } catch (e) {
           // throws user callback exceptions in next tick

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -27,6 +27,14 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     return Promise.resolve(true);
   }
 
+  /**
+   * Check if the splits information is already stored in cache.
+   * Noop, just keeping the interface. This is used by client-side implementations only.
+   */
+  checkCache(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/AbstractSplitsCacheSync.ts

@@ -47,6 +47,14 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract clear(): void
 
+  /**
+   * Check if the splits information is already stored in cache. This data can be preloaded.
+   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+   */
+  checkCache(): boolean {
+    return false;
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/KeyBuilderCS.ts

@@ -43,10 +43,6 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   buildTillKey() {
     return `${this.prefix}.${this.matchingKey}.segments.till`;
   }
-
-  buildLastClear() {
-    return `${this.prefix}.lastClear`;
-  }
 }
 
 export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {

package/src/storages/dataLoader.ts

@@ -1,9 +1,7 @@
 import { PreloadedData } from '../types';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 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
-
 /**
  * Factory of client-side storage loader
  *

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -5,6 +5,7 @@ import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
+import { getStorageHash } from '../KeyBuilder';
 import { setToArray } from '../../utils/lang/sets';
 
 /**
@@ -14,14 +15,21 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
+  private readonly storageHash: string;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
+  private updateNewFilter?: boolean;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number) {
     super();
     this.keys = keys;
     this.log = settings.log;
+    this.storageHash = getStorageHash(settings);
     this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+
+    this._checkExpiration(expirationTimestamp);
+
+    this._checkFilterQuery();
   }
 
   private _decrementCount(key: string) {
@@ -71,6 +79,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
    */
   clear() {
+    this.log.info(LOG_PREFIX + 'Flushing Splits data from localStorage');
+
     // collect item keys
     const len = localStorage.length;
     const accum = [];
@@ -128,6 +138,19 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   setChangeNumber(changeNumber: number): boolean {
+
+    // when using a new split query, we must update it at the store
+    if (this.updateNewFilter) {
+      this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
+      const storageHashKey = this.keys.buildHashKey();
+      try {
+        localStorage.setItem(storageHashKey, this.storageHash);
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
+      this.updateNewFilter = false;
+    }
+
     try {
       localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
@@ -189,6 +212,48 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
+  /**
+   * Check if the splits information is already stored in browser LocalStorage.
+   * In this function we could add more code to check if the data is valid.
+   * @override
+   */
+  checkCache(): boolean {
+    return this.getChangeNumber() > -1;
+  }
+
+  /**
+   * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+   *
+   * @param expirationTimestamp - if the value is not a number, data will not be cleaned
+   */
+  private _checkExpiration(expirationTimestamp?: number) {
+    let value: string | number | null = localStorage.getItem(this.keys.buildLastUpdatedKey());
+    if (value !== null) {
+      value = parseInt(value, 10);
+      if (!isNaNNumber(value) && expirationTimestamp && value < expirationTimestamp) this.clear();
+    }
+  }
+
+  // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
+  private _checkFilterQuery() {
+    const storageHashKey = this.keys.buildHashKey();
+    const storageHash = localStorage.getItem(storageHashKey);
+
+    if (storageHash !== this.storageHash) {
+      try {
+        // mark cache to update the new query filter on first successful splits fetch
+        this.updateNewFilter = true;
+
+        // if there is cache, clear it
+        if (this.checkCache()) this.clear();
+
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
+    }
+    // if the filter didn't change, nothing is done
+  }
+
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);

package/src/storages/inLocalStorage/index.ts

@@ -7,19 +7,22 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
 import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
-import SplitIO from '../../../types/splitio';
+
+export interface InLocalStorageOptions {
+  prefix?: string
+}
 
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): IStorageSyncFactory {
+export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
@@ -34,8 +37,9 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
+    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    const splits = new SplitsCacheInLocal(settings, keys);
+    const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
     const segments = new MySegmentsCacheInLocal(log, keys);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
@@ -49,10 +53,6 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
-      validateCache() {
-        return validateCache(options, settings, keys, splits, segments, largeSegments);
-      },
-
       destroy() { },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).

package/src/storages/inRedis/constants.ts

@@ -1,4 +1,4 @@
 export const LOG_PREFIX = 'storage:redis: ';
 export const DEFAULT_CACHE_SIZE = 30000;
-export const REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
+export const REFRESH_RATE = 300000; // 300000 ms = start after 5 mins
 export const TTL_REFRESH = 3600; // 1hr

package/src/storages/pluggable/index.ts

@@ -88,8 +88,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     // Connects to wrapper and emits SDK_READY event on main client
     const connectPromise = wrapper.connect().then(() => {
       if (isSynchronizer) {
-        // @TODO reuse InLocalStorage::validateCache logic
-        // In standalone or producer mode, clear storage if SDK key, flags filter criteria or flags spec version was modified
+        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
         return wrapper.get(keys.buildHashKey()).then((hash) => {
           const currentHash = getStorageHash(settings);
           if (hash !== currentHash) {

package/src/storages/types.ts

@@ -191,6 +191,8 @@ export interface ISplitsCacheBase {
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
+  // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
+  checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
   getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
 }
@@ -207,6 +209,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
+  checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
   getNamesByFlagSets(flagSets: string[]): Set<string>[]
 }
@@ -223,6 +226,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
+  checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
   getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
@@ -453,7 +457,6 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => boolean, // @TODO support async
   largeSegments?: ISegmentsCacheSync,
 }
 

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

@@ -1,6 +1,6 @@
 import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
-import { IStorageSync } from '../../../storages/types';
+import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
 import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
@@ -15,7 +15,7 @@ import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/c
  */
 export function fromObjectUpdaterFactory(
   splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: { splits: ISplitsCacheSync },
   readiness: IReadinessManager,
   settings: ISettings,
 ): () => Promise<boolean> {
@@ -60,10 +60,9 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-          Promise.resolve().then(() => {
+          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
           });
@@ -81,7 +80,7 @@ export function fromObjectUpdaterFactory(
  */
 export function fromObjectSyncTaskFactory(
   splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: { splits: ISplitsCacheSync },
   readiness: IReadinessManager,
   settings: ISettings
 ): ISyncTask<[], boolean> {

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

@@ -3,7 +3,7 @@ import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { 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';
@@ -153,7 +153,7 @@ export function splitChangesUpdaterFactory(
      */
     function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
-      return Promise.resolve(splitUpdateNotification ?
+      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
         { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
         splitChangesFetcher(since, noCache, till, _promiseDecorator)
       )
@@ -200,6 +200,15 @@ export function splitChangesUpdaterFactory(
           }
           return false;
         });
+
+      // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+      // Wrapping in a promise since checkCache can be async.
+      if (splitsEventEmitter && startingUp) {
+        Promise.resolve(splits.checkCache()).then(isCacheReady => {
+          if (isCacheReady) splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+        });
+      }
+      return fetcherPromise;
     }
 
     let sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error

package/src/sync/syncManagerOnline.ts

@@ -9,7 +9,6 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 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';
 
 /**
  * Online SyncManager factory.
@@ -29,7 +28,7 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } },  telemetryTracker } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
@@ -88,11 +87,6 @@ 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); });
-        }
-
         // start syncing splits and segments
         if (pollingManager) {
 
@@ -102,6 +96,7 @@ export function syncManagerOnlineFactory(
               // Doesn't call `syncAll` when the syncManager is resuming
               if (startFirstTime) {
                 pollingManager.syncAll();
+                startFirstTime = false;
               }
               pushManager.start();
             } else {
@@ -110,14 +105,13 @@ export function syncManagerOnlineFactory(
           } else {
             if (startFirstTime) {
               pollingManager.syncAll();
+              startFirstTime = false;
             }
           }
         }
 
         // start periodic data recording (events, impressions, telemetry).
         submitterManager.start(!isConsentGranted(settings));
-
-        startFirstTime = false;
       },
 
       /**

package/src/trackers/uniqueKeysTracker.ts

@@ -10,7 +10,7 @@ const noopFilterAdapter = {
 };
 
 /**
- * Trackes uniques keys
+ * Tracks uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *

package/src/utils/constants/browser.ts

@@ -0,0 +1,2 @@
+// This value might be eventually set via a config parameter
+export const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days

package/src/utils/lang/index.ts

@@ -120,7 +120,7 @@ export function isBoolean(val: any): boolean {
  * Unlike `Number.isFinite`, it also tests Number object instances.
  * Unlike global `isFinite`, it returns false if the value is not a number or Number object instance.
  */
-export function isFiniteNumber(val: any): val is number {
+export function isFiniteNumber(val: any): boolean {
   if (val instanceof Number) val = val.valueOf();
   return typeof val === 'number' ?
     Number.isFinite ? Number.isFinite(val) : isFinite(val) :

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -8,7 +8,7 @@ import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
   const result = InMemoryStorageCSFactory(params);
-  result.validateCache = () => true; // to emit SDK_READY_FROM_CACHE
+  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
   return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/types/splitio.d.ts

@@ -910,18 +910,6 @@ declare namespace SplitIO {
      * @defaultValue `'SPLITIO'`
      */
     prefix?: string;
-    /**
-     * Number of days before cached data expires if it was not updated. If cache expires, it is cleared on initialization.
-     *
-     * @defaultValue `10`
-     */
-    expirationDays?: number;
-    /**
-     * Optional settings to clear the cache. If set to `true`, the SDK clears the cached data on initialization, unless the cache was cleared within the last 24 hours.
-     *
-     * @defaultValue `false`
-     */
-    clearOnInit?: boolean;
   }
   /**
    * Storage for asynchronous (consumer) SDK.
@@ -1245,23 +1233,11 @@ declare namespace SplitIO {
        */
       type?: BrowserStorage;
       /**
-       * Optional prefix to prevent any kind of data collision between SDK versions when using 'LOCALSTORAGE'.
+       * Optional prefix to prevent any kind of data collision between SDK versions.
        *
        * @defaultValue `'SPLITIO'`
        */
       prefix?: string;
-      /**
-       * Optional settings for the 'LOCALSTORAGE' storage type. It specifies the number of days before cached data expires if it was not updated. If cache expires, it is cleared on initialization.
-       *
-       * @defaultValue `10`
-       */
-      expirationDays?: number;
-      /**
-       * Optional settings for the 'LOCALSTORAGE' storage type. If set to `true`, the SDK clears the cached data on initialization, unless the cache was cleared within the last 24 hours.
-       *
-       * @defaultValue `false`
-       */
-      clearOnInit?: boolean;
     };
   }
   /**

package/cjs/storages/inLocalStorage/validateCache.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCache = void 0;
-var lang_1 = require("../../utils/lang");
-var KeyBuilder_1 = require("../KeyBuilder");
-var constants_1 = require("./constants");
-var DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
-var MILLIS_IN_A_DAY = 86400000;
-/**
- * Validates if cache should be cleared and sets the cache `hash` if needed.
- *
- * @returns `true` if cache should be cleared, `false` otherwise
- */
-function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
-    // Check expiration
-    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
-    if (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp)) {
-        var cacheExpirationInDays = (0, lang_1.isFiniteNumber)(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
-        var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
-        if (lastUpdatedTimestamp < expirationTimestamp) {
-            log.info(constants_1.LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
-            return true;
-        }
-    }
-    // Check hash
-    var storageHashKey = keys.buildHashKey();
-    var storageHash = localStorage.getItem(storageHashKey);
-    var currentStorageHash = (0, KeyBuilder_1.getStorageHash)(settings);
-    if (storageHash !== currentStorageHash) {
-        try {
-            localStorage.setItem(storageHashKey, currentStorageHash);
-        }
-        catch (e) {
-            log.error(constants_1.LOG_PREFIX + e);
-        }
-        if (isThereCache) {
-            log.info(constants_1.LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
-            return true;
-        }
-        return false; // No cache to clear
-    }
-    // Clear on init
-    if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
-        if ((0, lang_1.isNaNNumber)(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
-            log.info(constants_1.LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
-            return true;
-        }
-    }
-}
-/**
- * Clean cache if:
- * - it has expired, i.e., its `lastUpdated` timestamp is older than the given `expirationTimestamp`
- * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
- * - `clearOnInit` was set and cache was not cleared in the last 24 hours
- *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
- */
-function validateCache(options, settings, keys, splits, segments, largeSegments) {
-    var currentTimestamp = Date.now();
-    var isThereCache = splits.getChangeNumber() > -1;
-    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
-        splits.clear();
-        segments.clear();
-        largeSegments.clear();
-        // Update last clear timestamp
-        try {
-            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
-        }
-        catch (e) {
-            settings.log.error(constants_1.LOG_PREFIX + e);
-        }
-        return false;
-    }
-    // Check if ready from cache
-    return isThereCache;
-}
-exports.validateCache = validateCache;