@splitsoftware/splitio-commons 2.0.2 → 2.1.0-rc.0

package/src/storages/inLocalStorage/validateCache.ts

@@ -0,0 +1,92 @@
+import { ISettings } from '../../types';
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { getStorageHash } from '../KeyBuilder';
+import { LOG_PREFIX } from './constants';
+import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import SplitIO from '../../../types/splitio';
+
+// milliseconds in a day
+const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
+const 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: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
+  const { log } = settings;
+
+  // Check expiration
+  const lastUpdatedTimestamp = parseInt(localStorage.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;
+    if (lastUpdatedTimestamp < expirationTimestamp) {
+      log.info(LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
+      return true;
+    }
+  }
+
+  // Check hash
+  const storageHashKey = keys.buildHashKey();
+  const storageHash = localStorage.getItem(storageHashKey);
+  const currentStorageHash = getStorageHash(settings);
+
+  if (storageHash !== currentStorageHash) {
+    try {
+      localStorage.setItem(storageHashKey, currentStorageHash);
+    } catch (e) {
+      log.error(LOG_PREFIX + e);
+    }
+    if (isThereCache) {
+      log.info(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) {
+    const lastClearTimestamp = parseInt(localStorage.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');
+      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)
+ */
+export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
+
+  const currentTimestamp = Date.now();
+  const 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(LOG_PREFIX + e);
+    }
+
+    return false;
+  }
+
+  // Check if ready from cache
+  return isThereCache;
+}

package/src/storages/pluggable/index.ts

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

package/src/storages/types.ts

@@ -191,8 +191,6 @@ 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>[]>
 }
@@ -209,7 +207,6 @@ 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>[]
 }
@@ -226,7 +223,6 @@ 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>[]>
 }
@@ -457,6 +453,7 @@ 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 { ISplitsCacheSync } from '../../../storages/types';
+import { IStorageSync } 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: { splits: ISplitsCacheSync },
+  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings,
 ): () => Promise<boolean> {
@@ -60,9 +60,10 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
+          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+          Promise.resolve().then(() => {
             // Emits SDK_READY_FROM_CACHE
-            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
           });
@@ -80,7 +81,7 @@ export function fromObjectUpdaterFactory(
  */
 export function fromObjectSyncTaskFactory(
   splitsParser: ISplitsParser,
-  storage: { splits: ISplitsCacheSync },
+  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
   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, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED } 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]);
-      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
+      return Promise.resolve(splitUpdateNotification ?
         { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
         splitChangesFetcher(since, noCache, till, _promiseDecorator)
       )
@@ -200,15 +200,6 @@ 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/streaming/pushManager.ts

@@ -349,12 +349,14 @@ export function pushManagerFactory(
           // Reconnects in case of a new client.
           // Run in next event-loop cycle to save authentication calls
           // in case multiple clients are created in the current cycle.
-          setTimeout(function checkForReconnect() {
-            if (connectForNewClient) {
-              connectForNewClient = false;
-              connectPush();
-            }
-          }, 0);
+          if (this.isRunning()) {
+            setTimeout(function checkForReconnect() {
+              if (connectForNewClient) {
+                connectForNewClient = false;
+                connectPush();
+              }
+            }, 0);
+          }
         }
       },
       // [Only for client-side]

package/src/sync/syncManagerOnline.ts

@@ -9,6 +9,7 @@ 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.
@@ -28,7 +29,7 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } },  telemetryTracker } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
@@ -87,6 +88,11 @@ 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) {
 
@@ -96,7 +102,6 @@ export function syncManagerOnlineFactory(
               // Doesn't call `syncAll` when the syncManager is resuming
               if (startFirstTime) {
                 pollingManager.syncAll();
-                startFirstTime = false;
               }
               pushManager.start();
             } else {
@@ -105,13 +110,14 @@ export function syncManagerOnlineFactory(
           } else {
             if (startFirstTime) {
               pollingManager.syncAll();
-              startFirstTime = false;
             }
           }
         }
 
         // start periodic data recording (events, impressions, telemetry).
         submitterManager.start(!isConsentGranted(settings));
+
+        startFirstTime = false;
       },
 
       /**
@@ -142,11 +148,12 @@ export function syncManagerOnlineFactory(
         if (!pollingManager) return;
 
         const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
+        if (syncEnabled && pushManager) pushManager.add(matchingKey, mySegmentsSyncTask);
 
         if (running) {
           if (syncEnabled) {
             if (pushManager) {
-              if (pollingManager!.isRunning()) {
+              if (pollingManager.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
                 if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               } else {
@@ -154,7 +161,6 @@ export function syncManagerOnlineFactory(
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
-              pushManager.add(matchingKey, mySegmentsSyncTask);
             } else {
               if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }

package/src/trackers/eventTracker.ts

@@ -36,7 +36,7 @@ export function eventTrackerFactory(
         whenInit(() => {
           // Wrap in a timeout because we don't want it to be blocking.
           setTimeout(() => {
-            // copy of event, to avoid unexpected behaviour if modified by integrations
+            // copy of event, to avoid unexpected behavior if modified by integrations
             const eventDataCopy = objectAssign({}, eventData);
             if (properties) eventDataCopy.properties = objectAssign({}, properties);
             // integrationsManager does not throw errors (they are internally handled by each integration module)

package/src/trackers/impressionsTracker.ts

@@ -60,7 +60,7 @@ export function impressionsTrackerFactory(
       if (impressionListener || integrationsManager) {
         for (let i = 0; i < impressionsToListenerCount; i++) {
           const impressionData: SplitIO.ImpressionData = {
-            // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
+            // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
             impression: objectAssign({}, impressionsToListener[i]),
             attributes,
             ip,

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): boolean {
+export function isFiniteNumber(val: any): val is number {
   if (val instanceof Number) val = val.valueOf();
   return typeof val === 'number' ?
     Number.isFinite ? Number.isFinite(val) : isFinite(val) :

package/src/utils/settingsValidation/index.ts

@@ -159,7 +159,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
     if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
       withDefaults.core.key = 'localhost_key';
     } else {
-      // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+      // Keeping same behavior than JS SDK: if settings key or TT are invalid,
       // `false` value is used as bound key/TT of the default client, which leads to some issues.
       // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
       withDefaults.core.key = validateKey(log, maybeKey, LOG_PREFIX_CLIENT_INSTANTIATION);

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.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
+  result.validateCache = () => true; // to emit SDK_READY_FROM_CACHE
   return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/types/index.d.ts

@@ -1,5 +1,5 @@
 // Declaration file for JavaScript Browser Split Software SDK
-// Project: http://www.split.io/
+// Project: https://www.split.io/
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
 /// <reference path="./splitio.d.ts" />

package/types/splitio.d.ts

@@ -1,5 +1,5 @@
 // Type definitions for Split Software SDKs
-// Project: http://www.split.io/
+// Project: https://www.split.io/
 
 import { RedisOptions } from 'ioredis';
 import { RequestOptions } from 'http';
@@ -906,6 +906,18 @@ 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.
@@ -1229,11 +1241,23 @@ declare namespace SplitIO {
        */
       type?: BrowserStorage;
       /**
-       * Optional prefix to prevent any kind of data collision between SDK versions.
+       * Optional prefix to prevent any kind of data collision between SDK versions when using 'LOCALSTORAGE'.
        *
        * @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/utils/constants/browser.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = void 0;
-// This value might be eventually set via a config parameter
-exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days

package/esm/utils/constants/browser.js

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

package/src/utils/constants/browser.ts

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