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

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,6 +7,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';
 
 /**
@@ -15,7 +17,9 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
+  const { settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
+
+  const storages: Record<string, IStorageSync> = {};
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
@@ -36,20 +40,31 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     destroy() { },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared() {
-      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,
+    shared(matchingKey: string) {
+      if (!storages[matchingKey]) {
+        const segments = new MySegmentsCacheInMemory();
+        const largeSegments = new MySegmentsCacheInMemory();
+
+        if (preloadedData) {
+          setCache(log, preloadedData, { segments, largeSegments }, matchingKey);
+        }
+
+        storages[matchingKey] = {
+          splits: this.splits,
+          rbSegments: this.rbSegments,
+          segments,
+          largeSegments,
+          impressions: this.impressions,
+          impressionCounts: this.impressionCounts,
+          events: this.events,
+          telemetry: this.telemetry,
+          uniqueKeys: this.uniqueKeys,
+
+          destroy() { }
+        };
+      }
 
-        destroy() { }
-      };
+      return storages[matchingKey];
     },
   };
 
@@ -63,6 +78,14 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     storage.uniqueKeys.track = noopTrack;
   }
 
+  const matchingKey = getMatching(params.settings.core.key);
+  storages[matchingKey] = storage;
+
+  if (preloadedData) {
+    setCache(log, preloadedData, storage, matchingKey);
+    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
+  }
+
   return storage;
 }
 

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -51,6 +51,10 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     return this.cache[name] || null;
   }
 
+  getAll(): IRBSegment[] {
+    return this.getNames().map(key => this.get(key)!);
+  }
+
   contains(names: Set<string>): boolean {
     const namesArray = setToArray(names);
     const namesInStorage = this.getNames();

package/src/storages/types.ts

@@ -4,22 +4,6 @@ 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.
  */
@@ -251,6 +235,7 @@ export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean,
   get(name: string): IRBSegment | null,
   getChangeNumber(): number,
+  getAll(): IRBSegment[],
   clear(): void,
   contains(names: Set<string>): boolean,
   // Used only for smart pausing in client-side standalone. Returns true if the storage contains a RBSegment using segments or large segments matchers
@@ -481,7 +466,7 @@ export interface IStorageBase<
   telemetry?: TTelemetryCache,
   uniqueKeys: TUniqueKeysCache,
   destroy(): void | Promise<void>,
-  shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
+  shared?: (matchingKey: string, onReadyCb?: (error?: any) => void) => this
 }
 
 export interface IStorageSync extends IStorageBase<
@@ -495,7 +480,7 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => Promise<boolean>,
+  validateCache?: () => boolean, // @TODO support async
   largeSegments?: ISegmentsCacheSync,
 }
 
@@ -512,8 +497,6 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
-export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
-
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -521,6 +504,9 @@ export interface IStorageFactoryParams {
    * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
    */
   onReadyCb: (error?: any) => void,
+  /**
+   * For emitting SDK_READY_FROM_CACHE event in consumer mode with Redis and standalone mode with preloaded data
+   */
   onReadyFromCacheCb: () => void,
 }
 

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

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

package/src/sync/syncManagerOnline.ts

@@ -89,41 +89,36 @@ export function syncManagerOnlineFactory(
       start() {
         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((isCacheLoaded) => {
-          if (!running) return;
-
-          if (startFirstTime) {
-            // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+        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) {
 
-          // 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 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();
             }
           }
+        }
+
+        // start periodic data recording (events, impressions, telemetry).
+        submitterManager.start(!isConsentGranted(settings));
 
-          startFirstTime = false;
-        });
+        startFirstTime = false;
       },
 
       /**

package/src/types.ts

@@ -42,38 +42,3 @@ export interface IBasicClient extends SplitIO.IBasicClient {
   isClientSide?: boolean;
   key?: SplitIO.SplitKey;
 }
-/**
- * Defines the format of rollout plan data to preload the factory storage (cache).
- */
-export interface PreloadedData {
-  /**
-   * Timestamp of the last moment the data was synchronized with Split servers.
-   * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
-   */
-  // @TODO configurable expiration time policy?
-  lastUpdated: number;
-  /**
-   * Change number of the preloaded data.
-   * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
-   */
-  since: number;
-  /**
-   * Map of feature flags to their stringified definitions.
-   */
-  splitsData: {
-    [splitName: string]: string;
-  };
-  /**
-   * Optional map of user keys to their list of segments.
-   */
-  mySegmentsData?: {
-    [key: string]: string[];
-  };
-  /**
-   * Optional map of segments to their stringified definitions.
-   * This property is ignored if `mySegmentsData` was provided.
-   */
-  segmentsData?: {
-    [segmentName: string]: string;
-  };
-}

package/src/utils/env/isLocalStorageAvailable.ts

@@ -1,32 +1,11 @@
+/* eslint-disable no-undef */
 export function isLocalStorageAvailable(): boolean {
-  try {
-    // eslint-disable-next-line no-undef
-    return isValidStorageWrapper(localStorage);
-  } catch (e) {
-    return false;
-  }
-}
-
-export function isValidStorageWrapper(wrapper: any): boolean {
   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: any): boolean {
-  if (typeof wrapper.length === 'number') {
-    try {
-      wrapper.key(0);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  return false;
-}

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

package/types/splitio.d.ts

@@ -350,6 +350,10 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
    * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#localhost-mode}
    */
   features?: SplitIO.MockedFeaturesMap;
+  /**
+   * Data to initialize the SDK storage with. If provided and valid, the SDK will be ready from cache immediately.
+   */
+  preloadedData?: SplitIO.PreloadedData;
   /**
    * SDK Startup settings.
    */
@@ -458,21 +462,6 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
  */
 declare namespace SplitIO {
 
-  interface StorageWrapper {
-    /**
-     * Returns a promise that resolves to the current value associated with the given key, or null if the given key does not exist.
-     */
-    getItem(key: string): Promise<string | null> | string | null;
-    /**
-     * Returns a promise that resolves when the value of the pair identified by key is set to value, creating a new key/value pair if none existed for key previously.
-     */
-    setItem(key: string, value: string): Promise<void> | void;
-    /**
-     * Returns a promise that resolves when the key/value pair with the given key is removed, if a key/value pair with the given key exists.
-     */
-    removeItem(key: string): Promise<void> | void;
-  }
-
   /**
    * EventEmitter interface based on a subset of the Node.js EventEmitter methods.
    */
@@ -570,6 +559,7 @@ declare namespace SplitIO {
       eventsFirstPushWindow: number;
     };
     readonly storage: StorageSyncFactory | StorageAsyncFactory | StorageOptions;
+    readonly preloadedData?: SplitIO.PreloadedData;
     readonly urls: {
       events: string;
       sdk: string;
@@ -987,12 +977,6 @@ declare namespace SplitIO {
      * @defaultValue `false`
      */
     clearOnInit?: boolean;
-    /**
-     * Optional storage wrapper to persist rollout plan related data. If not provided, the SDK will use the default localStorage Web API.
-     *
-     * @defaultValue `window.localStorage`
-     */
-    wrapper?: StorageWrapper;
   }
   /**
    * Storage for asynchronous (consumer) SDK.
@@ -1042,6 +1026,40 @@ declare namespace SplitIO {
     prefix?: string;
     options?: Object;
   }
+  /**
+   * Defines the format of rollout plan data to preload the factory storage (cache).
+   */
+  type PreloadedData = {
+    /**
+     * Change number of feature flags.
+     */
+    since: number;
+    /**
+     * List of feature flags.
+     */
+    flags: Object[],
+    /**
+     * Change number of rule-based segments.
+     */
+    rbSince?: number,
+    /**
+     * List of rule-based segments.
+     */
+    rbSegments?: Object[],
+    /**
+     * Optional map of user keys to their memberships.
+     */
+    memberships?: {
+      [key: string]: Object
+    },
+    /**
+     * Optional map of segments to their list of keys.
+     * This property is ignored if `memberships` is provided.
+     */
+    segments?: {
+      [segmentName: string]: string[]
+    },
+  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -1333,12 +1351,6 @@ declare namespace SplitIO {
        * @defaultValue `false`
        */
       clearOnInit?: boolean;
-      /**
-       * Optional storage wrapper to persist rollout plan related data. If not provided, the SDK will use the default localStorage Web API.
-       *
-       * @defaultValue `window.localStorage`
-       */
-      wrapper?: StorageWrapper;
     };
   }
   /**
@@ -1591,6 +1603,13 @@ declare namespace SplitIO {
      * @returns The manager instance.
      */
     manager(): IManager;
+    /**
+     * Returns the current snapshot of the SDK rollout plan in cache.
+     *
+     * @param keys - Optional list of keys to generate the rollout plan snapshot with the memberships of the given keys, rather than the complete segments data.
+     * @returns The current snapshot of the SDK rollout plan.
+     */
+    getCache(keys?: SplitKey[]): PreloadedData,
   }
   /**
    * This represents the interface for the SDK instance for server-side with asynchronous storage.

package/cjs/storages/inLocalStorage/storageAdapter.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageAdapter = void 0;
-var constants_1 = require("./constants");
-function isTillKey(key) {
-    return key.endsWith('.till');
-}
-function storageAdapter(log, prefix, wrapper) {
-    var cache = {};
-    var connectPromise;
-    var disconnectPromise = Promise.resolve();
-    return {
-        load: function () {
-            return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then(function (storedCache) {
-                cache = JSON.parse(storedCache || '{}');
-            }).catch(function (e) {
-                log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
-            }));
-        },
-        save: function () {
-            return disconnectPromise = disconnectPromise.then(function () {
-                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch(function (e) {
-                    log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
-                });
-            });
-        },
-        get length() {
-            return Object.keys(cache).length;
-        },
-        getItem: function (key) {
-            return cache[key] || null;
-        },
-        key: function (index) {
-            return Object.keys(cache)[index] || null;
-        },
-        removeItem: function (key) {
-            delete cache[key];
-            if (isTillKey(key))
-                this.save();
-        },
-        setItem: function (key, value) {
-            cache[key] = value;
-            if (isTillKey(key))
-                this.save();
-        }
-    };
-}
-exports.storageAdapter = storageAdapter;

package/esm/storages/inLocalStorage/storageAdapter.js

@@ -1,44 +0,0 @@
-import { LOG_PREFIX } from './constants';
-function isTillKey(key) {
-    return key.endsWith('.till');
-}
-export function storageAdapter(log, prefix, wrapper) {
-    var cache = {};
-    var connectPromise;
-    var disconnectPromise = Promise.resolve();
-    return {
-        load: function () {
-            return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then(function (storedCache) {
-                cache = JSON.parse(storedCache || '{}');
-            }).catch(function (e) {
-                log.error(LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
-            }));
-        },
-        save: function () {
-            return disconnectPromise = disconnectPromise.then(function () {
-                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch(function (e) {
-                    log.error(LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
-                });
-            });
-        },
-        get length() {
-            return Object.keys(cache).length;
-        },
-        getItem: function (key) {
-            return cache[key] || null;
-        },
-        key: function (index) {
-            return Object.keys(cache)[index] || null;
-        },
-        removeItem: function (key) {
-            delete cache[key];
-            if (isTillKey(key))
-                this.save();
-        },
-        setItem: function (key, value) {
-            cache[key] = value;
-            if (isTillKey(key))
-                this.save();
-        }
-    };
-}

package/src/storages/inLocalStorage/storageAdapter.ts

@@ -1,50 +0,0 @@
-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!();
-    }
-  };
-}