@splitsoftware/splitio-commons 1.17.1-rc.3 → 2.0.0-rc.0

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
 /**
@@ -215,14 +215,14 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set,
    * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
       .then((results) => results.map(([e, value], index) => {
         if (e === null) return value;
 
         this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
       }))
-      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -6,7 +6,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 import type { RedisAdapter } from './RedisAdapter';
@@ -46,7 +45,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popLatencies(): Promise<MultiMethodLatencies> {
     return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
 
-      const result: MultiMethodLatencies = new _Map();
+      const result: MultiMethodLatencies = new Map();
 
       Object.keys(latencies).forEach(field => {
 
@@ -86,7 +85,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popExceptions(): Promise<MultiMethodExceptions> {
     return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
 
-      const result: MultiMethodExceptions = new _Map();
+      const result: MultiMethodExceptions = new Map();
 
       Object.keys(exceptions).forEach(field => {
 
@@ -119,7 +118,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popConfigs(): Promise<MultiConfigs> {
     return this.redis.hgetall(this.keys.initPrefix).then(configs => {
 
-      const result: MultiConfigs = new _Map();
+      const result: MultiConfigs = new Map();
 
       Object.keys(configs).forEach(field => {
 

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -1,6 +1,5 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
@@ -29,7 +28,7 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     if (!featureNames.length) return Promise.resolve(false);
 
     const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const featureKeys = Array.from(this.uniqueKeysTracker[featureName]);
       const uniqueKeysPayload = {
         f: featureName,
         ks: featureKeys

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -5,7 +5,6 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { _Set } from '../../utils/lang/sets';
 
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,7 +5,7 @@ import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -181,11 +181,11 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set.
    * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
    */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return Promise.all(flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       return this.wrapper.getItems(flagSetKey).catch(() => []);
-    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -6,7 +6,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { isString, isNaNNumber } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 
@@ -43,7 +42,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return latencyKeys.length ?
         this.wrapper.getMany(latencyKeys).then(latencies => {
 
-          const result: MultiMethodLatencies = new _Map();
+          const result: MultiMethodLatencies = new Map();
 
           for (let i = 0; i < latencyKeys.length; i++) {
             const field = latencyKeys[i].split('::')[1];
@@ -77,7 +76,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(latencyKeys.map((latencyKey) => this.wrapper.del(latencyKey))).then(() => result);
         }) :
         // If latencyKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 
@@ -90,7 +89,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return exceptionKeys.length ?
         this.wrapper.getMany(exceptionKeys).then(exceptions => {
 
-          const result: MultiMethodExceptions = new _Map();
+          const result: MultiMethodExceptions = new Map();
 
           for (let i = 0; i < exceptionKeys.length; i++) {
             const field = exceptionKeys[i].split('::')[1];
@@ -117,7 +116,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(exceptionKeys.map((exceptionKey) => this.wrapper.del(exceptionKey))).then(() => result);
         }) :
         // If exceptionKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 
@@ -130,7 +129,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return configKeys.length ?
         this.wrapper.getMany(configKeys).then(configs => {
 
-          const result: MultiConfigs = new _Map();
+          const result: MultiConfigs = new Map();
 
           for (let i = 0; i < configKeys.length; i++) {
             const field = configKeys[i].split('::')[1];
@@ -154,7 +153,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(configKeys.map((configKey) => this.wrapper.del(configKey))).then(() => result);
         }) :
         // If configKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 }

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -1,6 +1,5 @@
 import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
@@ -28,7 +27,7 @@ export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements
     if (!featureNames.length) return Promise.resolve(false);
 
     const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const featureKeys = Array.from(this.uniqueKeysTracker[featureName]);
       const uniqueKeysPayload = {
         f: featureName,
         ks: featureKeys

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -1,6 +1,5 @@
 import { IPluggableStorageWrapper } from '../types';
 import { startsWith, toNumber } from '../../utils/lang';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
@@ -9,9 +8,9 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
  *
  * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
-export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
+export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | Set<string>>, _setConnDelay(connDelay: number): void } {
 
-  let _cache: Record<string, string | string[] | ISet<string>> = {};
+  let _cache: Record<string, string | string[] | Set<string>> = {};
   let _connDelay = connDelay;
 
   return {
@@ -84,22 +83,22 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     itemContains(key: string, item: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve(false);
-      if (set instanceof _Set) return Promise.resolve(set.has(item));
+      if (set instanceof Set) return Promise.resolve(set.has(item));
       return Promise.reject('key is not a set');
     },
     addItems(key: string, items: string[]) {
-      if (!(key in _cache)) _cache[key] = new _Set();
+      if (!(key in _cache)) _cache[key] = new Set();
       const set = _cache[key];
-      if (set instanceof _Set) {
+      if (set instanceof Set) {
         items.forEach(item => set.add(item));
         return Promise.resolve();
       }
       return Promise.reject('key is not a set');
     },
     removeItems(key: string, items: string[]) {
-      if (!(key in _cache)) _cache[key] = new _Set();
+      if (!(key in _cache)) _cache[key] = new Set();
       const set = _cache[key];
-      if (set instanceof _Set) {
+      if (set instanceof Set) {
         items.forEach(item => set.delete(item));
         return Promise.resolve();
       }
@@ -108,7 +107,7 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getItems(key: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve([]);
-      if (set instanceof _Set) return Promise.resolve(setToArray(set));
+      if (set instanceof Set) return Promise.resolve(Array.from(set));
       return Promise.reject('key is not a set');
     },
 

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { IPluggableStorageWrapper, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -62,12 +62,11 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory(params: IStorageFactoryParams) {
+  function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
     const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
-    let connectPromise: Promise<void>;
 
     const isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
@@ -90,6 +89,35 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
       undefined;
 
+    // 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
+        return wrapper.get(keys.buildHashKey()).then((hash) => {
+          const currentHash = getStorageHash(settings);
+          if (hash !== currentHash) {
+            log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+            return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
+              return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
+            }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
+          }
+        }).then(() => {
+          onReadyCb();
+        });
+      } else {
+        // Start periodic flush of async storages if not running synchronizer (producer mode)
+        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+        if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+
+        onReadyCb();
+      }
+    }).catch((e) => {
+      e = e || new Error('Error connecting wrapper');
+      onReadyCb(e);
+      return e; // Propagate error for shared clients
+    });
+
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
@@ -99,39 +127,6 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       telemetry,
       uniqueKeys: uniqueKeysCache,
 
-      init() {
-        if (connectPromise) return connectPromise;
-
-        // Connects to wrapper and emits SDK_READY event on main client
-        return connectPromise = wrapper.connect().then(() => {
-          if (isSyncronizer) {
-            // 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) {
-                log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
-                  return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
-                }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
-              }
-            }).then(() => {
-              onReadyCb();
-            });
-          } else {
-            // Start periodic flush of async storages if not running synchronizer (producer mode)
-            if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-            if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
-            if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
-
-            onReadyCb();
-          }
-        }).catch((e) => {
-          e = e || new Error('Error connecting wrapper');
-          onReadyCb(e);
-          return e; // Propagate error for shared clients
-        });
-      },
-
       // Stop periodic flush and disconnect the underlying storage
       destroy() {
         return Promise.all(isSyncronizer ? [] : [
@@ -141,8 +136,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       },
 
       // emits SDK_READY event on shared clients and returns a reference to the storage
-      shared(_: string, onReadyCb: (error?: any) => void) {
-        this.init().then(onReadyCb);
+      shared(_, onReadyCb) {
+        connectPromise.then(onReadyCb);
 
         return {
           ...this,

package/src/storages/types.ts

@@ -2,7 +2,6 @@ import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
 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 { SplitIO, ImpressionDTO, ISettings } from '../types';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -208,8 +207,10 @@ 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<ISet<string>[]>
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -224,8 +225,9 @@ 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[]): ISet<string>[]
+  getNamesByFlagSets(flagSets: string[]): Set<string>[]
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -240,8 +242,9 @@ 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<ISet<string>[]>
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
 
 /** Segments cache */
@@ -462,7 +465,6 @@ export interface IStorageBase<
   events: TEventsCache,
   telemetry?: TTelemetryCache,
   uniqueKeys?: TUniqueKeysCache,
-  init?: () => void | Promise<void>,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -492,6 +494,8 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
+export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
+
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -499,7 +503,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,
-  onReadyFromCacheCb: (error?: any) => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

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

@@ -7,7 +7,7 @@ import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 
 /**
@@ -60,8 +60,12 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          // Emits SDK_READY
-          readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
+            // Emits SDK_READY_FROM_CACHE
+            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            // Emits SDK_READY
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          });
         }
         return true;
       });

package/src/sync/polling/pollingManagerSS.ts

@@ -1,7 +1,6 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -29,9 +28,9 @@ export function pollingManagerSSFactory(
       log.debug(LOG_PREFIX_SYNC_POLLING + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
 
       const startingUp = splitsSyncTask.start();
-      if (thenable(startingUp)) {
+      if (startingUp) {
         startingUp.then(() => {
-          segmentsSyncTask.start();
+          if (splitsSyncTask.isRunning()) segmentsSyncTask.start();
         });
       }
     },

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

@@ -1,10 +1,9 @@
-import { _Set, setToArray, ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 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';
@@ -27,8 +26,8 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
  * Collect segments from a raw split definition.
  * Exported for testing purposes.
  */
-export function parseSegments({ conditions }: ISplit): ISet<string> {
-  let segments = new _Set<string>();
+export function parseSegments({ conditions }: ISplit): Set<string> {
+  let segments = new Set<string>();
 
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
@@ -74,7 +73,7 @@ function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
  * Exported for testing purposes.
  */
 export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
-  const segments = new _Set<string>();
+  const segments = new Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
       accum.added.push([split.name, split]);
@@ -89,7 +88,7 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
     return accum;
   }, { added: [], removed: [], segments: [] } as ISplitMutations);
 
-  computed.segments = setToArray(segments);
+  computed.segments = Array.from(segments);
 
   return computed;
 }
@@ -153,8 +152,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)
       )
@@ -201,6 +199,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/streaming/parseUtils.ts

@@ -13,7 +13,6 @@ function Uint8ArrayToString(myUint8Arr: Uint8Array) { // @ts-ignore
 
 function StringToUint8Array(myString: string) {
   const charCodes = myString.split('').map((e) => e.charCodeAt(0));
-  // eslint-disable-next-line compat/compat
   return new Uint8Array(charCodes);
 }
 

package/src/sync/streaming/pushManager.ts

@@ -15,7 +15,6 @@ import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR,
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
-import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -254,11 +253,11 @@ export function pushManagerFactory(
         return;
       }
       case UpdateStrategy.KeyList: {
-        let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
+        let keyList: KeyList, added: Set<string>, removed: Set<string>;
         try {
           keyList = parseKeyList(parsedData.d!, parsedData.c!);
-          added = new _Set(keyList.a);
-          removed = new _Set(keyList.r);
+          added = new Set(keyList.a);
+          removed = new Set(keyList.r);
         } catch (e) {
           log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);
           break;

package/src/sync/submitters/types.ts

@@ -1,7 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
-import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -88,11 +87,11 @@ export type StoredEventWithMetadata = {
   e: SplitIO.EventData
 }
 
-export type MultiMethodLatencies = IMap<string, MethodLatencies>
+export type MultiMethodLatencies = Map<string, MethodLatencies>
 
-export type MultiMethodExceptions = IMap<string, MethodExceptions>
+export type MultiMethodExceptions = Map<string, MethodExceptions>
 
-export type MultiConfigs = IMap<string, TelemetryConfigStats>
+export type MultiConfigs = Map<string, TelemetryConfigStats>
 
 /**
  * Telemetry usage stats

package/src/trackers/eventTracker.ts

@@ -16,7 +16,6 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
-  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -33,15 +32,13 @@ export function eventTrackerFactory(
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
         // Wrap in a timeout because we don't want it to be blocking.
-        whenInit(() => {
-          setTimeout(() => {
-            // copy of event, to avoid unexpected behaviour 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)
-            integrationsManager.handleEvent(eventDataCopy);
-          });
-        });
+        setTimeout(function () {
+          // copy of event, to avoid unexpected behaviour 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)
+          integrationsManager.handleEvent(eventDataCopy);
+        }, 0);
       }
     } else {
       log.error(ERROR_EVENTS_TRACKER, [msg]);