@splitsoftware/splitio-commons 2.0.0-rc.2 → 2.0.0-rc.4

package/src/logger/messages/error.ts

@@ -32,7 +32,6 @@ export const codesError: [number, string][] = [
   [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
   // initialization / settings validation
   [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
-  [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
   [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': the provided storage is invalid.%s Falling back into default MEMORY storage'],
   [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
   [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the amount of flag sets provided are big causing uri length error.'],

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -43,7 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const storage = storageFactory({
     settings,
-    onReadyCb(error) {
+    onReadyCb: (error) => {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -52,11 +52,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb() {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-    }
   });
-
+  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });

package/src/storages/dataLoader.ts

@@ -1,114 +1,55 @@
 import { SplitIO } from '../types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
-import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
- * @param storage object containing `splits` and `segments` cache (client-side variant)
- * @param userKey user key (matching key) of the provided MySegmentsCache
- *
- * @TODO extend to load largeSegments
- * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
- * @TODO add logs, and input validation in this module, in favor of size reduction.
- * @TODO unit tests
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
+ * and extended with a `mySegmentsData` property.
+ * @returns function to preload the storage
  */
-export function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current preloadedData is empty
-  if (Object.keys(preloadedData).length === 0) return;
-
-  const { segmentsData = {}, since = -1, splitsData = [] } = preloadedData;
+export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+
+  /**
+   * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+   * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+   *
+   * @param storage object containing `splits` and `segments` cache (client-side variant)
+   * @param userId user key string of the provided MySegmentsCache
+   *
+   * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
+   * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+   */
+  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0) return;
+
+    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
 
-  if (storage.splits) {
     const storedSince = storage.splits.getChangeNumber();
+    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    // Do not load data if current data is more recent
-    if (storedSince > since) return;
+    // Do not load data if current localStorage data is more recent,
+    // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+    if (storedSince > since || lastUpdated < expirationTimestamp) return;
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(splitsData.map(split => ([split.name, split])));
-  }
-
-  if (matchingKey) { // add mySegments data (client-side)
-    let membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
-    if (!membershipsData && segmentsData) {
-      membershipsData = {
-        ms: {
-          k: Object.keys(segmentsData).filter(segmentName => {
-            const segmentKeys = segmentsData[segmentName];
-            return segmentKeys.indexOf(matchingKey) > -1;
-          }).map(segmentName => ({ n: segmentName }))
-        }
-      };
-    }
-    if (membershipsData) {
-      if (membershipsData.ms) storage.segments.resetSegments(membershipsData.ms);
-      if (membershipsData.ls && storage.largeSegments) storage.largeSegments.resetSegments(membershipsData.ls);
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+
+    // add mySegments data
+    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+    if (!mySegmentsData) {
+      // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
+      mySegmentsData = Object.keys(segmentsData).filter(segmentName => {
+        const userIds = JSON.parse(segmentsData[segmentName]).added;
+        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+      });
     }
-
-  } else { // add segments data (server-side)
-    Object.keys(segmentsData).forEach(segmentName => {
-      const segmentKeys = segmentsData[segmentName];
-      storage.segments.update(segmentName, segmentKeys, [], -1);
-    });
-  }
-}
-
-export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
-  return {
-    // lastUpdated: Date.now(),
-    since: storage.splits.getChangeNumber(),
-    splitsData: storage.splits.getAll(),
-    segmentsData: userKeys ?
-      undefined : // @ts-ignore accessing private prop
-      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
-        prev[cur] = setToArray(storage.segments.segmentCache[cur] as Set<string>);
-        return prev;
-      }, {}),
-    membershipsData: userKeys ?
-      userKeys.reduce<Record<string, IMembershipsResponse>>((prev, userKey) => {
-        if (storage.shared) {
-          // Client-side segments
-          // @ts-ignore accessing private prop
-          const sharedStorage = storage.shared(userKey);
-          prev[getMatching(userKey)] = {
-            ms: {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
-              // cn: sharedStorage.segments.getChangeNumber()
-            },
-            ls: sharedStorage.largeSegments ? {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
-              // cn: sharedStorage.largeSegments.getChangeNumber()
-            } : undefined
-          };
-        } else {
-          prev[getMatching(userKey)] = {
-            ms: {
-              // Server-side segments
-              // @ts-ignore accessing private prop
-              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore accessing private prop
-                return storage.segments.segmentCache[segmentName].has(userKey) ?
-                  prev!.concat({ n: segmentName }) :
-                  prev;
-              }, [])
-            },
-            ls: {
-              k: []
-            }
-          };
-        }
-        return prev;
-      }, {}) :
-      undefined
+    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,8 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { loadData } from '../dataLoader';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -16,7 +14,7 @@ import { loadData } from '../dataLoader';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -44,18 +42,11 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared(matchingKey: string) {
-      const segments = new MySegmentsCacheInMemory();
-      const largeSegments = new MySegmentsCacheInMemory();
-
-      if (preloadedData) {
-        loadData(preloadedData, { segments, largeSegments }, matchingKey);
-      }
-
+    shared() {
       return {
         splits: this.splits,
-        segments,
-        largeSegments,
+        segments: new MySegmentsCacheInMemory(),
+        largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -81,12 +72,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     if (storage.uniqueKeys) storage.uniqueKeys.track = noopTrack;
   }
 
-
-  if (preloadedData) {
-    loadData(preloadedData, storage, getMatching(params.settings.core.key));
-    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
-  }
-
   return storage;
 }
 

package/src/storages/types.ts

@@ -488,6 +488,8 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
+export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
+
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -495,10 +497,6 @@ 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,
-  /**
-   * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
-   */
-  onReadyFromCacheCb: () => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,6 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { SplitIO } from '../../types';
 
-// Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
+// Singleton instance of the factory function for offline SyncManager from object
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
-localhostFromObject.type = 'LocalhostFromObject';
-
-export function LocalhostFromObject(): SplitIO.LocalhostFactory {
-  return localhostFromObject;
-}
+export const localhostFromObjectFactory = syncManagerOfflineFactory(splitsParserFromSettingsFactory);

package/src/types.ts

@@ -1,11 +1,8 @@
-import { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
+/* eslint-disable no-use-before-define */
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
-import { ISdkFactoryContext } from './sdkFactory/types';
-/* eslint-disable no-use-before-define */
-
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
-import { ISyncManagerCS } from './sync/types';
 
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
@@ -97,7 +94,6 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
-  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -117,7 +113,6 @@ export interface ISettings {
     splitFilters: SplitIO.SplitFilter[],
     impressionsMode: SplitIO.ImpressionsMode,
     __splitFiltersValidation: ISplitFiltersValidation,
-    localhostMode?: SplitIO.LocalhostFactory,
     enabled: boolean,
     flagSpecVersion: string,
     requestOptions?: {
@@ -667,13 +662,6 @@ export namespace SplitIO {
    * @typedef {Promise<SplitNames>} SplitNamesAsync
    */
   export type SplitNamesAsync = Promise<SplitNames>;
-  /**
-   * Localhost mode factory.
-   */
-  export type LocalhostFactory = {
-    type: 'LocalhostFromObject' | 'LocalhostFromFile'
-    (params: ISdkFactoryContext): ISyncManagerCS
-  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -771,31 +759,31 @@ export namespace SplitIO {
      * 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,
+    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,
     /**
-     * List of feature flag definitions.
-     * @TODO rename to flags
+     * Map of feature flags to their stringified definitions.
      */
-    splitsData: ISplit[],
+    splitsData: {
+      [splitName: string]: string
+    },
     /**
-     * Optional map of user keys to their memberships.
-     * @TODO rename to memberships
+     * Optional map of user keys to their list of segments.
+     * @TODO remove when releasing first version
      */
-    membershipsData?: {
-      [key: string]: IMembershipsResponse
+    mySegmentsData?: {
+      [key: string]: string[]
     },
     /**
-     * Optional map of segments to their list of keys.
-     * This property is ignored if `membershipsData` was provided.
-     * @TODO rename to segments
+     * Optional map of segments to their stringified definitions.
+     * This property is ignored if `mySegmentsData` was provided.
      */
     segmentsData?: {
-      [segmentName: string]: string[]
+      [segmentName: string]: string
     },
   }
   /**

package/src/utils/settingsValidation/index.ts

@@ -80,7 +80,6 @@ export const base = {
     splitFilters: undefined,
     // impressions collection mode
     impressionsMode: OPTIMIZED,
-    localhostMode: undefined,
     enabled: true,
     flagSpecVersion: FLAG_SPEC_VERSION
   },
@@ -102,7 +101,7 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger, localhost, consent, flagSpec } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, consent, flagSpec } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
   const withDefaults = merge({}, base, defaults, config) as ISettings;
@@ -180,8 +179,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (integrations) withDefaults.integrations = integrations(withDefaults);
 
-  if (localhost) sync.localhostMode = localhost(withDefaults);
-
   // validate push options
   if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
     withDefaults.streamingEnabled = true;

package/src/utils/settingsValidation/types.ts

@@ -20,8 +20,6 @@ export interface ISettingsValidationParams {
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator (`settings.debug`) */
   logger: (settings: ISettings) => ISettings['log'],
-  /** Localhost mode validator (`settings.sync.localhostMode`) */
-  localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
   /** User consent validator (`settings.userConsent`) */
   consent?: (settings: ISettings) => ISettings['userConsent'],
   /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */

package/types/index.d.ts

@@ -1,5 +1,5 @@
-export { InMemoryStorageFactory } from './storages/inMemory/InMemoryStorage';
-export { InMemoryStorageCSFactory } from './storages/inMemory/InMemoryStorageCS';
-export { InLocalStorage } from './storages/inLocalStorage';
-export { PluggableStorage } from './storages/pluggable';
-export { InRedisStorage } from './storages/inRedis';
+// Declaration file for JavaScript Browser Split Software SDK
+// Project: http://www.split.io/
+// Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
+
+/// <reference path="./splitio.d.ts" />