@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
 import { IReadinessManager } from '../../readiness/types';
@@ -6,6 +6,7 @@ import { IFetchAuth } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
 import { IEventEmitter, ISettings } from '../../types';
 import { IPlatform } from '../../sdkFactory/types';
+import { ControlType } from './constants';
 
 // Internal SDK events, subscribed by SyncManager and PushManager
 export type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP'
@@ -15,6 +16,7 @@ export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
 export type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -23,33 +25,23 @@ export type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
+
+type IParsedData<T extends IPushEvent> =
+  T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
+  T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
+  T extends SEGMENT_UPDATE ? ISegmentUpdateData :
+  T extends SPLIT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_KILL ? ISplitKillData : undefined;
 
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
  */
 export interface IPushEventEmitter extends IEventEmitter {
-  once<T extends IPushEvent>(event: T, listener: (...args:
-    T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] :
-    T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] :
-    T extends SPLIT_UPDATE ? [changeNumber: number] :
-    T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] :
-    any[]) => void): this;
-
-  on<T extends IPushEvent>(event: T, listener: (...args:
-    T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] :
-    T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] :
-    T extends SPLIT_UPDATE ? [changeNumber: number] :
-    T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] :
-    any[]) => void): this;
-
-  emit<T extends IPushEvent>(event: T, ...args:
-    T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] :
-    T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] :
-    T extends SPLIT_UPDATE ? [changeNumber: number] :
-    T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] :
-    any[]): boolean;
+  once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+  on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+  emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
 }
 
 /**

package/src/sync/submitters/metricsSyncTask.ts

@@ -45,5 +45,5 @@ export function latenciesSyncTaskFactory(
 ): ISyncTask {
 
   // don't retry metrics.
-  return submitterSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache<number[]>('latencies'));
+  return submitterSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache<number[]>('latencies'), 0, true);
 }

package/src/sync/submitters/submitterSyncTask.ts

@@ -17,6 +17,7 @@ export function submitterSyncTaskFactory<TState extends { length?: number }>(
   latencyTracker?: ITimeTracker,
   fromCacheToPayload?: (cacheData: TState) => any,
   maxRetries: number = 0,
+  debugLogs?: boolean
 ): ISyncTask<[], void> {
 
   let retries = 0;
@@ -27,7 +28,7 @@ export function submitterSyncTaskFactory<TState extends { length?: number }>(
     const data = sourceCache.state();
 
     const dataCount: number | '' = typeof data.length === 'number' ? data.length : '';
-    log.info(SUBMITTERS_PUSH, [dataCount, dataName]);
+    log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCount, dataName]);
     const latencyTrackerStop = latencyTracker && latencyTracker.start();
 
     const jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);

package/src/sync/syncManagerFromFile.ts

@@ -0,0 +1,13 @@
+import { splitsParserFromFileFactory } from './offline/splitsParser/splitsParserFromFile';
+import { syncManagerOfflineFactory } from './syncManagerOffline';
+import { SplitIO } from '../types';
+import { LOCALHOST_MODE } from '../utils/constants';
+
+// Factory of Localhost SyncManager based on yaml file.
+// Requires Node 'fs' and 'path' APIs.
+export function LocalhostFromFile(): SplitIO.LocalhostFactory {
+  const localhost = syncManagerOfflineFactory(splitsParserFromFileFactory);
+  // @ts-ignore
+  localhost.type = LOCALHOST_MODE;
+  return localhost;
+}

package/src/sync/syncManagerFromObject.ts

@@ -0,0 +1,12 @@
+import { splitsParserFromSettingsFactory } from './offline/splitsParser/splitsParserFromSettings';
+import { syncManagerOfflineFactory } from './syncManagerOffline';
+import { SplitIO } from '../types';
+import { LOCALHOST_MODE } from '../utils/constants';
+
+// Factory of Localhost SyncManager based on JS object.
+export function LocalhostFromObject(): SplitIO.LocalhostFactory {
+  const localhost = syncManagerOfflineFactory(splitsParserFromSettingsFactory);
+  // @ts-ignore
+  localhost.type = LOCALHOST_MODE;
+  return localhost;
+}

package/src/sync/syncManagerOffline.ts

@@ -16,7 +16,7 @@ function flush() {
  * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
 export function syncManagerOfflineFactory(
-  splitsParser: ISplitsParser
+  splitsParserFactory: () => ISplitsParser
 ): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
 
   /**
@@ -29,7 +29,7 @@ export function syncManagerOfflineFactory(
   }: ISyncManagerFactoryParams): ISyncManagerCS {
 
     return objectAssign(
-      fromObjectSyncTaskFactory(splitsParser, storage, readiness, settings),
+      fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings),
       {
         // fake flush, that resolves immediately
         flush,
@@ -38,7 +38,7 @@ export function syncManagerOfflineFactory(
         shared(matchingKey: string, readinessManager: IReadinessManager): ISyncManager {
           return {
             start() {
-              // In LOCALHOST mode, shared clients are ready in the next event cycle than created
+              // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
               // SDK_READY cannot be emitted directly because this will not update the readiness status
               setTimeout(() => {
                 readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager

package/src/sync/syncManagerOnline.ts

@@ -75,6 +75,11 @@ export function syncManagerOnlineFactory(
       pollingManager.syncAll();
     }
 
+    if (pushManager) {
+      pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
+      pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
+    }
+
     let running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
     let startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
 
@@ -87,11 +92,9 @@ export function syncManagerOnlineFactory(
       start() {
         // start syncing splits and segments
         if (pushManager) {
-          // Avoid calling `syncAll` when the syncManager is resumed
+          // Doesn't call `syncAll` when the syncManager is resuming
           if (startFirstTime) {
             pollingManager.syncAll();
-            pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-            pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
             startFirstTime = false;
           }
           pushManager.start();

package/src/trackers/impressionObserver/ImpressionObserver.ts

@@ -2,18 +2,16 @@ import { ImpressionDTO } from '../../types';
 import LRUCache from '../../utils/LRUCache';
 import { IImpressionObserver } from './types';
 
-export default class ImpressionObserver implements IImpressionObserver {
-  private cache: LRUCache<string | null, number>;
-  private hasher: (impression: ImpressionDTO) => string | null;
+export default class ImpressionObserver<K extends string | number> implements IImpressionObserver {
+  private cache: LRUCache<K, number>;
+  private hasher: (impression: ImpressionDTO) => K;
 
-  constructor(size: number, hasher: (impression: ImpressionDTO) => string | null) {
+  constructor(size: number, hasher: (impression: ImpressionDTO) => K) {
     this.cache = new LRUCache(size);
     this.hasher = hasher;
   }
 
   testAndSet(impression: ImpressionDTO) {
-    if (!impression) return;
-
     const hash = this.hasher(impression);
     const previous = this.cache.get(hash);
     this.cache.set(hash, impression.time);

package/src/trackers/impressionObserver/buildKey.ts

@@ -1,19 +1,5 @@
 import { ImpressionDTO } from '../../types';
 
-const UNKNOWN = 'UNKNOWN';
-
-function _unknownIfNull(s: any) {
-  return s ? s : UNKNOWN;
-}
-
-function _zeroIfNull(l: any) {
-  return l ? l : 0;
-}
-
-export default function buildKey(impression: ImpressionDTO) {
-  return `${_unknownIfNull(impression.keyName)}
-    :${_unknownIfNull(impression.feature)}
-    :${_unknownIfNull(impression.treatment)}
-    :${_unknownIfNull(impression.label)}
-    :${_zeroIfNull(impression.changeNumber)}`;
+export function buildKey(impression: ImpressionDTO) {
+  return `${impression.keyName}:${impression.feature}:${impression.treatment}:${impression.label}:${impression.changeNumber}`;
 }

package/src/trackers/impressionObserver/impressionObserverCS.ts

@@ -1,10 +1,10 @@
 import ImpressionObserver from './ImpressionObserver';
 import { hash } from '../../utils/murmur3/murmur3';
-import buildKey from './buildKey';
+import { buildKey } from './buildKey';
 import { ImpressionDTO } from '../../types';
 
 export function hashImpression32(impression: ImpressionDTO) {
-  return impression ? hash(buildKey(impression)).toString() : null;
+  return hash(buildKey(impression));
 }
 
 const LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes

package/src/trackers/impressionObserver/impressionObserverSS.ts

@@ -1,10 +1,10 @@
 import ImpressionObserver from './ImpressionObserver';
-import { hash128 } from '../../utils/murmur3/murmur3_128';
-import buildKey from './buildKey';
+import { hash128 } from '../../utils/murmur3/murmur3_128_x86';
+import { buildKey } from './buildKey';
 import { ImpressionDTO } from '../../types';
 
 export function hashImpression128(impression: ImpressionDTO) {
-  return impression ? hash128(buildKey(impression)).toString() : null;
+  return hash128(buildKey(impression));
 }
 
 const LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes

package/src/types.ts

@@ -1,8 +1,10 @@
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 /* eslint-disable no-use-before-define */
 
-import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync } from './storages/types';
+import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync, IStorageSyncFactory } from './storages/types';
+import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 
 /**
  * EventEmitter interface with the minimal methods used by the SDK
@@ -55,6 +57,8 @@ export type SDKMode = 'standalone' | 'consumer' | 'localhost';
  * Settings interface. This is a representation of the settings the SDK expose, that's why
  * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
  * @interface ISettings
+ *
+ * NOTE: same ISettings interface from public type declarations extended with private properties.
  */
 export interface ISettings {
   readonly core: {
@@ -81,7 +85,7 @@ export interface ISettings {
     retriesOnFailureBeforeReady: number,
     eventsFirstPushWindow: number
   },
-  readonly storage: (params: IStorageFactoryParams) => IStorageSyncCS,
+  readonly storage: IStorageSyncFactory,
   readonly integrations?: Array<(params: IIntegrationFactoryParams) => IIntegration | void>,
   readonly urls: {
     events: string,
@@ -96,12 +100,15 @@ export interface ISettings {
   readonly sync: {
     splitFilters: SplitIO.SplitFilter[],
     impressionsMode: SplitIO.ImpressionsMode,
+    __splitFiltersValidation: ISplitFiltersValidation,
+    localhostMode: SplitIO.LocalhostFactory
   },
   readonly runtime: {
     ip: string | false
     hostname: string | false
   },
   readonly log: ILogger
+  readonly impressionListener?: unknown
 }
 /**
  * Log levels.
@@ -576,6 +583,13 @@ export namespace SplitIO {
    * @typedef {Promise<SplitNames>} SplitNamesAsync
    */
   export type SplitNamesAsync = Promise<SplitNames>;
+  /**
+   * Localhost mode factory.
+   */
+  export type LocalhostFactory = {
+    type?: 'localhost'
+    (params: ISyncManagerFactoryParams): ISyncManagerCS
+  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.

package/src/utils/constants/index.ts

@@ -1,3 +1,5 @@
+import { StorageType } from '../../storages/types';
+
 // Special treatments
 export const CONTROL = 'control';
 export const CONTROL_WITH_CONFIG = {
@@ -24,4 +26,7 @@ export const PRODUCER_MODE = 'producer';
 export const CONSUMER_MODE = 'consumer';
 
 // Storage types
-export const STORAGE_MEMORY = 'MEMORY';
+export const STORAGE_MEMORY: StorageType = 'MEMORY';
+export const STORAGE_LOCALSTORAGE: StorageType = 'LOCALSTORAGE';
+export const STORAGE_REDIS: StorageType = 'REDIS';
+export const STORAGE_CUSTOM: StorageType = 'CUSTOM';