@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

package/cjs/storages/inLocalStorage/index.js

@@ -30,32 +30,24 @@ function InLocalStorage(options) {
             params.settings.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         }
-        var onReadyFromCacheCb = params.onReadyFromCacheCb, settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
-        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
         return {
             splits: splits,
             segments: segments,
-            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== constants_2.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
-            init: function () {
-                if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-                    Promise.resolve().then(onReadyFromCacheCb);
-                }
-            },
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -63,10 +55,10 @@ function InLocalStorage(options) {
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
+                var childKeysBuilder = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey)),
-                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey)),
+                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, childKeysBuilder),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -74,7 +66,6 @@ function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                        this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
                     }
                 };
             },

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,22 +9,18 @@ var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory")
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
-var key_1 = require("../../utils/key");
-var dataLoader_1 = require("../dataLoader");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-    var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
-        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
@@ -34,23 +30,16 @@ function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
-            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-            var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-            if (preloadedData) {
-                (0, dataLoader_1.loadData)(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
-            }
+        shared: function () {
             return {
                 splits: this.splits,
-                segments: segments,
-                largeSegments: largeSegments,
+                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -59,7 +48,6 @@ function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
-                    this.largeSegments.clear();
                 }
             };
         },
@@ -75,11 +63,6 @@ function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
-    if (preloadedData) {
-        (0, dataLoader_1.loadData)(preloadedData, storage, (0, key_1.getMatching)(params.settings.core.key));
-        if (splits.getChangeNumber() > -1)
-            onReadyFromCacheCb();
-    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

package/cjs/storages/inMemory/MySegmentsCacheInMemory.js

@@ -14,26 +14,57 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
+    MySegmentsCacheInMemory.prototype.clear = function () {
+        this.segmentCache = {};
+    };
     MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
-        if (this.segmentCache[name])
-            return false;
         this.segmentCache[name] = true;
         return true;
     };
     MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
-        if (!this.segmentCache[name])
-            return false;
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
-        this.cn = changeNumber;
-    };
-    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.cn || -1;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInMemory.prototype.resetSegments = function (names) {
+        var _this = this;
+        var isDiff = false;
+        var index;
+        var storedSegmentKeys = Object.keys(this.segmentCache);
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentKeys.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentKeys.length !== names.length) {
+            isDiff = true;
+            this.segmentCache = {};
+            names.forEach(function (s) {
+                _this.addToSegment(s);
+            });
+        }
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                this.segmentCache = {};
+                names.forEach(function (s) {
+                    _this.addToSegment(s);
+                });
+            }
+        }
+        return isDiff;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -69,7 +69,7 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
     };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return (0, lang_1.isIntegerNumber)(value) ? value : -1;
+        return (0, lang_1.isIntegerNumber)(value) ? value : undefined;
     };
     return SegmentsCacheInMemory;
 }(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -16,7 +16,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.segmentsCount = 0;
+        _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -25,7 +25,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.segmentsCount = 0;
+        this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -35,9 +35,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit))
-                this.segmentsCount--;
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -48,7 +48,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
-                this.segmentsCount++;
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -67,7 +67,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
-                this.segmentsCount--;
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -91,7 +91,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         return (0, lang_1.isFiniteNumber)(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
     SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -23,10 +23,9 @@ function shouldRecordTelemetry(_a) {
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+    function TelemetryCacheInMemory(splits, segments) {
         this.splits = splits;
         this.segments = segments;
-        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -42,7 +41,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -62,8 +64,6 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(constants_1.QUEUED),
             eD: this.getEventStats(constants_1.DROPPED),
@@ -195,11 +195,14 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+        this.updatesFromSSE[type]++;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/cjs/storages/inRedis/RedisAdapter.js

@@ -20,7 +20,7 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false // @TODO true to avoid side-effects on instantiation.
+    lazyConnect: false
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -37,10 +37,10 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/cjs/storages/inRedis/index.js

@@ -12,17 +12,23 @@ var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
 var UniqueKeysCacheInRedis_1 = require("./UniqueKeysCacheInRedis");
 var ImpressionCountsCacheInRedis_1 = require("./ImpressionCountsCacheInRedis");
 var utils_1 = require("../utils");
+var RD;
+try {
+    // Using `require` to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
+    // Redis storage is not supported with .mjs files.
+    RD = require('./RedisAdapter').RedisAdapter;
+}
+catch (error) { /* empty */ }
 /**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
+ * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
 function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
-    // Lazy loading to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
-    // Redis storage is not supported with .mjs files.
-    var RD = require('./RedisAdapter').RedisAdapter;
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     function InRedisStorageFactory(params) {
+        if (!RD)
+            throw new Error('The SDK Redis storage is unavailable. Make sure your runtime environment supports CommonJS (`require`) so the `ioredis` dependency can be imported.');
         var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
         var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
@@ -30,7 +36,7 @@ function InRedisStorage(options) {
         var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
         var impressionCountsCache = impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInRedis_1.ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
         var uniqueKeysCache = impressionsMode === constants_1.NONE ? new UniqueKeysCacheInRedis_1.UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
-        // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
+        // Subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
             if (impressionCountsCache)

package/cjs/storages/pluggable/SegmentsCachePluggable.js

@@ -66,10 +66,10 @@ var SegmentsCachePluggable = /** @class */ (function () {
         var _this = this;
         return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     /**

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -8,7 +8,7 @@ var sets_1 = require("../../utils/lang/sets");
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

package/cjs/storages/pluggable/index.js

@@ -58,7 +58,6 @@ function PluggableStorage(options) {
         var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
-        var connectPromise;
         var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === constants_1.CONSUMER_PARTIAL_MODE;
         var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) || isSyncronizer ?
@@ -76,6 +75,37 @@ function PluggableStorage(options) {
                 settings.core.key === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
             undefined;
+        // Connects to wrapper and emits SDK_READY event on main client
+        var connectPromise = wrapper.connect().then(function () {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
+                    if (hash !== currentHash) {
+                        log.info(constants_2.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(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(function () {
+                    onReadyCb();
+                });
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+                onReadyCb();
+            }
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e; // Propagate error for shared clients
+        });
         return {
             splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
@@ -84,41 +114,6 @@ function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            init: function () {
-                if (connectPromise)
-                    return connectPromise;
-                // Connects to wrapper and emits SDK_READY event on main client
-                return connectPromise = wrapper.connect().then(function () {
-                    if (isSyncronizer) {
-                        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-                        return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                            var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
-                            if (hash !== currentHash) {
-                                log.info(constants_2.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(function (storageKeys) {
-                                    return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                                }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                            }
-                        }).then(function () {
-                            onReadyCb();
-                        });
-                    }
-                    else {
-                        // Start periodic flush of async storages if not running synchronizer (producer mode)
-                        if (impressionCountsCache && impressionCountsCache.start)
-                            impressionCountsCache.start();
-                        if (uniqueKeysCache && uniqueKeysCache.start)
-                            uniqueKeysCache.start();
-                        if (telemetry && telemetry.recordConfig)
-                            telemetry.recordConfig();
-                        onReadyCb();
-                    }
-                }).catch(function (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: function () {
                 return Promise.all(isSyncronizer ? [] : [
@@ -128,7 +123,7 @@ function PluggableStorage(options) {
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                this.init().then(onReadyCb);
+                connectPromise.then(onReadyCb);
                 return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -46,8 +46,13 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    // Emits SDK_READY
-                    readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (cacheReady)
+                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                        // Emits SDK_READY
+                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                    });
                 }
                 return true;
             });

package/cjs/sync/polling/fetchers/mySegmentsFetcher.js

@@ -5,14 +5,17 @@ exports.mySegmentsFetcherFactory = void 0;
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-function mySegmentsFetcherFactory(fetchMemberships) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
+function mySegmentsFetcherFactory(fetchMySegments) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, 
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
-        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
+        var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
         if (decorator)
             mySegmentsPromise = decorator(mySegmentsPromise);
-        return mySegmentsPromise.then(function (resp) { return resp.json(); });
+        // Extract segment names
+        return mySegmentsPromise
+            .then(function (resp) { return resp.json(); })
+            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
     };
 }
 exports.mySegmentsFetcherFactory = mySegmentsFetcherFactory;

package/cjs/sync/polling/fetchers/segmentChangesFetcher.js

@@ -23,7 +23,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTil
  */
 function segmentChangesFetcherFactory(fetchSegmentChanges) {
     return function segmentChangesFetcher(since, segmentName, noCache, till, 
-    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
         var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
         if (decorator)

package/cjs/sync/polling/pollingManagerCS.js

@@ -46,7 +46,7 @@ function pollingManagerCSFactory(params) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
             if (!readiness.isReady() && !storage.splits.usesSegments())

package/cjs/sync/polling/pollingManagerSS.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pollingManagerSSFactory = void 0;
 var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var segmentsSyncTask_1 = require("./syncTasks/segmentsSyncTask");
-var thenable_1 = require("../../utils/promise/thenable");
 var constants_1 = require("../../logger/constants");
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -22,9 +21,10 @@ function pollingManagerSSFactory(params) {
             log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if ((0, thenable_1.thenable)(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

package/cjs/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -7,7 +7,7 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-function mySegmentsSyncTaskFactory(fetchMemberships, storage, readiness, settings, matchingKey) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMemberships), storage, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;