@splitsoftware/splitio-commons 1.8.2-rc.1 → 1.8.2-rc.2

package/CHANGES.txt

@@ -1,42 +1,44 @@
-1.8.2 (May 12, 2023)
- - Updated README file, code comments and log messages, to replace the terms "split" with "feature flag", "API Key" with "SDK Key" and "Split Web console" with "Split user interface", for improved clarity and consistency with industry terminology.
+1.8.2 (May 15, 2023)
+ - Updated terminology on the SDKs codebase to be more aligned with current standard without causing a breaking change. The core change is the term split for feature flag on things like logs and intensense comments.
+ - Updated split storage modules to optimize some operations when using Redis and pluggable storages.
+ - Updated some transitive dependencies for vulnerability fixes.
 
 1.8.1 (February 7, 2023)
-- Updated a module import to remove a trailing comma that can cause issues with some bundlers.
+ - Updated a module import to remove a trailing comma that can cause issues with some bundlers.
 
 1.8.0 (February 3, 2023)
-- Added flush data method to client
+ - Added flush data method to client.
 
 1.7.3 (December 16, 2022)
-- Updated unique keys cache for Redis and Pluggable storages to optimize the usage of the underlying storage.
-- Updated some transitive dependencies for vulnerability fixes.
-- Bugfixing - Updated events and impressions cache in localhost mode in order to avoid memory leaks (Related to issue https://github.com/splitio/javascript-commons/issues/181).
+ - Updated unique keys cache for Redis and Pluggable storages to optimize the usage of the underlying storage.
+ - Updated some transitive dependencies for vulnerability fixes.
+ - Bugfixing - Updated events and impressions cache in localhost mode in order to avoid memory leaks (Related to issue https://github.com/splitio/javascript-commons/issues/181).
 
 1.7.2 (October 14, 2022)
-- Bugfixing - Handle `Navigator.sendBeacon` API exceptions in the browser, and fallback to regular Fetch/XHR transport in case of error.
+ - Bugfixing - Handle `Navigator.sendBeacon` API exceptions in the browser, and fallback to regular Fetch/XHR transport in case of error.
 
 1.7.1 (October 5, 2022)
-- Updated default value of `scheduler.featuresRefreshRate` config parameter to 60 seconds.
+ - Updated default value of `scheduler.featuresRefreshRate` config parameter to 60 seconds.
 
 1.7.0 (October 4, 2022)
-- Added a new impressions mode for the SDK called NONE, to be used in factory when there is no desire to capture impressions on an SDK factory to feed Split's analytics engine. Running NONE mode, the SDK will only capture unique keys evaluated for a particular feature flag instead of full blown impressions.
-- Updated SDK telemetry to support pluggable storage, partial consumer mode, and synchronizer.
-- Updated storage implementations to improve the performance of feature flag evaluations (i.e., `getTreatment(s)` method calls) when using the default storage in memory.
-- Updated evaluation flow to avoid unnecessarily storage calls when the SDK is not ready.
+ - Added a new impressions mode for the SDK called NONE, to be used in factory when there is no desire to capture impressions on an SDK factory to feed Split's analytics engine. Running NONE mode, the SDK will only capture unique keys evaluated for a particular feature flag instead of full blown impressions.
+ - Updated SDK telemetry to support pluggable storage, partial consumer mode, and synchronizer.
+ - Updated storage implementations to improve the performance of feature flag evaluations (i.e., `getTreatment(s)` method calls) when using the default storage in memory.
+ - Updated evaluation flow to avoid unnecessarily storage calls when the SDK is not ready.
 
 1.6.1 (July 22, 2022)
-- Updated GoogleAnalyticsToSplit integration to validate `autoRequire` config parameter and avoid some wrong warning logs when mapping GA hit fields to Split event properties.
+ - Updated GoogleAnalyticsToSplit integration to validate `autoRequire` config parameter and avoid some wrong warning logs when mapping GA hit fields to Split event properties.
 
 1.6.0 (July 21, 2022)
-- Added `autoRequire` configuration option to the Google Analytics to Split integration, which takes care of requiring the splitTracker plugin on trackers dynamically created by Google tag managers (See https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js).
-- Updated browser listener to push remaining impressions and events on 'visibilitychange' and 'pagehide' DOM events, instead of 'unload', which is not reliable in modern mobile and desktop Web browsers.
-- Updated the synchronization flow to be more reliable in the event of an edge case generating delay in cache purge propagation, keeping the SDK cache properly synced.
-- Bugfixing - Removed js-yaml dependency to avoid resolution to an incompatible version on certain npm versions when installing third-party dependencies that also define js-yaml as transitive dependency (Related to issue https://github.com/splitio/javascript-client/issues/662).
+ - Added `autoRequire` configuration option to the Google Analytics to Split integration, which takes care of requiring the splitTracker plugin on trackers dynamically created by Google tag managers (See https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js).
+ - Updated browser listener to push remaining impressions and events on 'visibilitychange' and 'pagehide' DOM events, instead of 'unload', which is not reliable in modern mobile and desktop Web browsers.
+ - Updated the synchronization flow to be more reliable in the event of an edge case generating delay in cache purge propagation, keeping the SDK cache properly synced.
+ - Bugfixing - Removed js-yaml dependency to avoid resolution to an incompatible version on certain npm versions when installing third-party dependencies that also define js-yaml as transitive dependency (Related to issue https://github.com/splitio/javascript-client/issues/662).
 
 1.5.0 (June 29, 2022)
-- Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online, Split SDK will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.
-- Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.
-- Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while its periodic post of impressions is running.
+ - Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online, Split SDK will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.
+ - Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.
+ - Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while its periodic post of impressions is running.
 
 1.4.1 (June 13, 2022)
  - Bugfixing - Updated submitters logic, to avoid dropping impressions and events that are being tracked while POST request is pending.

package/cjs/services/splitApi.js

@@ -20,6 +20,7 @@ function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform.getFetch, platform.getOptions);
     return {
+        // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = urls.sdk + "/version";
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -37,10 +37,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._decrementCounts = function (split) {
         try {
             if (split) {
-                if (split.trafficTypeName) {
-                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-                    this._decrementCount(ttKey);
-                }
+                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+                this._decrementCount(ttKey);
                 if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     this._decrementCount(segmentsCountKey);
@@ -54,11 +52,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
             if (split) {
-                if (split.trafficTypeName) {
-                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-                    // @ts-expect-error
-                    localStorage.setItem(ttKey, (0, lang_1.toNumber)(localStorage.getItem(ttKey)) + 1);
-                }
+                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+                // @ts-expect-error
+                localStorage.setItem(ttKey, (0, lang_1.toNumber)(localStorage.getItem(ttKey)) + 1);
                 if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     // @ts-expect-error
@@ -95,9 +91,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var splitKey = this.keys.buildSplitKey(name);
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-            this._decrementCounts(previousSplit);
             localStorage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
+            this._decrementCounts(previousSplit);
             return true;
         }
         catch (e) {

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -27,12 +27,10 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
         if (previousSplit) { // We had this Split already
-            if (previousSplit.trafficTypeName) {
-                var previousTtName = previousSplit.trafficTypeName;
-                this.ttCache[previousTtName]--;
-                if (!this.ttCache[previousTtName])
-                    delete this.ttCache[previousTtName];
-            }
+            var previousTtName = previousSplit.trafficTypeName;
+            this.ttCache[previousTtName]--;
+            if (!this.ttCache[previousTtName])
+                delete this.ttCache[previousTtName];
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit)) { // Substract from segments count for the previous version of this Split.
                 this.splitsWithSegmentsCount--;
             }
@@ -42,11 +40,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.splitsCache[name] = split;
             // Update TT cache
             var ttName = split.trafficTypeName;
-            if (ttName) { // safeguard
-                if (!this.ttCache[ttName])
-                    this.ttCache[ttName] = 0;
-                this.ttCache[ttName]++;
-            }
+            this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             // Add to segments count for the new version of the Split
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount++;
@@ -62,11 +56,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             // Delete the Split
             delete this.splitsCache[name];
             var ttName = split.trafficTypeName;
-            if (ttName) { // safeguard
-                this.ttCache[ttName]--; // Update tt cache
-                if (!this.ttCache[ttName])
-                    delete this.ttCache[ttName];
-            }
+            this.ttCache[ttName]--; // Update tt cache
+            if (!this.ttCache[ttName])
+                delete this.ttCache[ttName];
             // Update the segments count.
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount--;

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -38,19 +38,15 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     }
     SplitsCacheInRedis.prototype._decrementCounts = function (split) {
         var _this = this;
-        if (split.trafficTypeName) {
-            var ttKey_1 = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.redis.decr(ttKey_1).then(function (count) {
-                if (count === 0)
-                    return _this.redis.del(ttKey_1);
-            });
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.redis.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.redis.del(ttKey);
+        });
     };
     SplitsCacheInRedis.prototype._incrementCounts = function (split) {
-        if (split.trafficTypeName) {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.redis.incr(ttKey);
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.redis.incr(ttKey);
     };
     /**
      * Add a given split.
@@ -70,16 +66,17 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return Promise.all([
-                _this.redis.set(splitKey, newStringifiedSplit),
-                _this._incrementCounts(split),
-                // If it's an update, we decrement the traffic type of the existing split,
-                parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
-            ]);
-        }).then(function (_a) {
-            var status = _a[0];
-            return status === 'OK';
-        });
+            return _this.redis.set(splitKey, newStringifiedSplit).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(split).then(function () {
+                    if (parsedPreviousSplit)
+                        return _this._decrementCounts(parsedPreviousSplit);
+                });
+            });
+        }).then(function () { return true; });
     };
     /**
      * Add a list of splits.

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -25,19 +25,15 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
     }
     SplitsCachePluggable.prototype._decrementCounts = function (split) {
         var _this = this;
-        if (split.trafficTypeName) {
-            var ttKey_1 = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.wrapper.decr(ttKey_1).then(function (count) {
-                if (count === 0)
-                    return _this.wrapper.del(ttKey_1);
-            });
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.wrapper.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.wrapper.del(ttKey);
+        });
     };
     SplitsCachePluggable.prototype._incrementCounts = function (split) {
-        if (split.trafficTypeName) {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.wrapper.incr(ttKey);
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.wrapper.incr(ttKey);
     };
     /**
      * Add a given split.
@@ -57,12 +53,16 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return Promise.all([
-                _this.wrapper.set(splitKey, stringifiedNewSplit),
-                _this._incrementCounts(split),
-                // If it's an update, we decrement the traffic type and segment count of the existing split,
-                parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
-            ]);
+            return _this.wrapper.set(splitKey, stringifiedNewSplit).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(split).then(function () {
+                    if (parsedPreviousSplit)
+                        return _this._decrementCounts(parsedPreviousSplit);
+                });
+            });
         }).then(function () { return true; });
     };
     /**

package/esm/services/splitApi.js

@@ -17,6 +17,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);
     return {
+        // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = urls.sdk + "/version";
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -34,10 +34,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._decrementCounts = function (split) {
         try {
             if (split) {
-                if (split.trafficTypeName) {
-                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-                    this._decrementCount(ttKey);
-                }
+                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+                this._decrementCount(ttKey);
                 if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     this._decrementCount(segmentsCountKey);
@@ -51,11 +49,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
             if (split) {
-                if (split.trafficTypeName) {
-                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-                    // @ts-expect-error
-                    localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-                }
+                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+                // @ts-expect-error
+                localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
                 if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     // @ts-expect-error
@@ -92,9 +88,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var splitKey = this.keys.buildSplitKey(name);
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-            this._decrementCounts(previousSplit);
             localStorage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
+            this._decrementCounts(previousSplit);
             return true;
         }
         catch (e) {

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -24,12 +24,10 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
         if (previousSplit) { // We had this Split already
-            if (previousSplit.trafficTypeName) {
-                var previousTtName = previousSplit.trafficTypeName;
-                this.ttCache[previousTtName]--;
-                if (!this.ttCache[previousTtName])
-                    delete this.ttCache[previousTtName];
-            }
+            var previousTtName = previousSplit.trafficTypeName;
+            this.ttCache[previousTtName]--;
+            if (!this.ttCache[previousTtName])
+                delete this.ttCache[previousTtName];
             if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
                 this.splitsWithSegmentsCount--;
             }
@@ -39,11 +37,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.splitsCache[name] = split;
             // Update TT cache
             var ttName = split.trafficTypeName;
-            if (ttName) { // safeguard
-                if (!this.ttCache[ttName])
-                    this.ttCache[ttName] = 0;
-                this.ttCache[ttName]++;
-            }
+            this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             // Add to segments count for the new version of the Split
             if (usesSegments(split))
                 this.splitsWithSegmentsCount++;
@@ -59,11 +53,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             // Delete the Split
             delete this.splitsCache[name];
             var ttName = split.trafficTypeName;
-            if (ttName) { // safeguard
-                this.ttCache[ttName]--; // Update tt cache
-                if (!this.ttCache[ttName])
-                    delete this.ttCache[ttName];
-            }
+            this.ttCache[ttName]--; // Update tt cache
+            if (!this.ttCache[ttName])
+                delete this.ttCache[ttName];
             // Update the segments count.
             if (usesSegments(split))
                 this.splitsWithSegmentsCount--;

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -35,19 +35,15 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     }
     SplitsCacheInRedis.prototype._decrementCounts = function (split) {
         var _this = this;
-        if (split.trafficTypeName) {
-            var ttKey_1 = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.redis.decr(ttKey_1).then(function (count) {
-                if (count === 0)
-                    return _this.redis.del(ttKey_1);
-            });
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.redis.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.redis.del(ttKey);
+        });
     };
     SplitsCacheInRedis.prototype._incrementCounts = function (split) {
-        if (split.trafficTypeName) {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.redis.incr(ttKey);
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.redis.incr(ttKey);
     };
     /**
      * Add a given split.
@@ -67,16 +63,17 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return Promise.all([
-                _this.redis.set(splitKey, newStringifiedSplit),
-                _this._incrementCounts(split),
-                // If it's an update, we decrement the traffic type of the existing split,
-                parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
-            ]);
-        }).then(function (_a) {
-            var status = _a[0];
-            return status === 'OK';
-        });
+            return _this.redis.set(splitKey, newStringifiedSplit).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(split).then(function () {
+                    if (parsedPreviousSplit)
+                        return _this._decrementCounts(parsedPreviousSplit);
+                });
+            });
+        }).then(function () { return true; });
     };
     /**
      * Add a list of splits.

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -22,19 +22,15 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
     }
     SplitsCachePluggable.prototype._decrementCounts = function (split) {
         var _this = this;
-        if (split.trafficTypeName) {
-            var ttKey_1 = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.wrapper.decr(ttKey_1).then(function (count) {
-                if (count === 0)
-                    return _this.wrapper.del(ttKey_1);
-            });
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.wrapper.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.wrapper.del(ttKey);
+        });
     };
     SplitsCachePluggable.prototype._incrementCounts = function (split) {
-        if (split.trafficTypeName) {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            return this.wrapper.incr(ttKey);
-        }
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.wrapper.incr(ttKey);
     };
     /**
      * Add a given split.
@@ -54,12 +50,16 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return Promise.all([
-                _this.wrapper.set(splitKey, stringifiedNewSplit),
-                _this._incrementCounts(split),
-                // If it's an update, we decrement the traffic type and segment count of the existing split,
-                parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
-            ]);
+            return _this.wrapper.set(splitKey, stringifiedNewSplit).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(split).then(function () {
+                    if (parsedPreviousSplit)
+                        return _this._decrementCounts(parsedPreviousSplit);
+                });
+            });
         }).then(function () { return true; });
     };
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.8.2-rc.1",
+  "version": "1.8.2-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/services/splitApi.ts

@@ -30,6 +30,7 @@ export function splitApiFactory(
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);
 
   return {
+    // @TODO throw errors if health check requests fail, to log them in the Synchronizer
     getSdkAPIHealthCheck() {
       const url = `${urls.sdk}/version`;
       return splitHttpClient(url).then(() => true).catch(() => false);

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -41,10 +41,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private _decrementCounts(split: ISplit | null) {
     try {
       if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          this._decrementCount(ttKey);
-        }
+        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        this._decrementCount(ttKey);
 
         if (usesSegments(split)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
@@ -59,11 +57,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private _incrementCounts(split: ISplit) {
     try {
       if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          // @ts-expect-error
-          localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-        }
+        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        // @ts-expect-error
+        localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
 
         if (usesSegments(split)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
@@ -104,11 +100,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-      this._decrementCounts(previousSplit);
 
       localStorage.setItem(splitKey, JSON.stringify(split));
 
       this._incrementCounts(split);
+      this._decrementCounts(previousSplit);
 
       return true;
     } catch (e) {

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -24,11 +24,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
 
-      if (previousSplit.trafficTypeName) {
-        const previousTtName = previousSplit.trafficTypeName;
-        this.ttCache[previousTtName]--;
-        if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
-      }
+      const previousTtName = previousSplit.trafficTypeName;
+      this.ttCache[previousTtName]--;
+      if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
 
       if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
         this.splitsWithSegmentsCount--;
@@ -40,10 +38,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.splitsCache[name] = split;
       // Update TT cache
       const ttName = split.trafficTypeName;
-      if (ttName) { // safeguard
-        if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
-        this.ttCache[ttName]++;
-      }
+      this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
 
       // Add to segments count for the new version of the Split
       if (usesSegments(split)) this.splitsWithSegmentsCount++;
@@ -61,11 +56,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       delete this.splitsCache[name];
 
       const ttName = split.trafficTypeName;
-
-      if (ttName) { // safeguard
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      }
+      this.ttCache[ttName]--; // Update tt cache
+      if (!this.ttCache[ttName]) delete this.ttCache[ttName];
 
       // Update the segments count.
       if (usesSegments(split)) this.splitsWithSegmentsCount--;

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -45,19 +45,15 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   private _decrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.redis.decr(ttKey).then(count => {
-        if (count === 0) return this.redis.del(ttKey);
-      });
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.redis.decr(ttKey).then(count => {
+      if (count === 0) return this.redis.del(ttKey);
+    });
   }
 
   private _incrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.redis.incr(ttKey);
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.redis.incr(ttKey);
   }
 
   /**
@@ -70,7 +66,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     return this.redis.get(splitKey).then(splitFromStorage => {
 
       // handling parsing errors
-      let parsedPreviousSplit, newStringifiedSplit;
+      let parsedPreviousSplit: ISplit, newStringifiedSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
         newStringifiedSplit = JSON.stringify(split);
@@ -78,13 +74,16 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return Promise.all([
-        this.redis.set(splitKey, newStringifiedSplit),
-        this._incrementCounts(split),
-        // If it's an update, we decrement the traffic type of the existing split,
-        parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
-      ]);
-    }).then(([status]) => status === 'OK');
+      return this.redis.set(splitKey, newStringifiedSplit).then(() => {
+        // avoid unnecessary increment/decrement operations
+        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
+
+        // update traffic type counts
+        return this._incrementCounts(split).then(() => {
+          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
+        });
+      });
+    }).then(() => true);
   }
 
   /**

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -29,19 +29,15 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   }
 
   private _decrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.wrapper.decr(ttKey).then(count => {
-        if (count === 0) return this.wrapper.del(ttKey);
-      });
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.wrapper.decr(ttKey).then(count => {
+      if (count === 0) return this.wrapper.del(ttKey);
+    });
   }
 
   private _incrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.wrapper.incr(ttKey);
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.wrapper.incr(ttKey);
   }
 
   /**
@@ -54,7 +50,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, stringifiedNewSplit;
+      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
         stringifiedNewSplit = JSON.stringify(split);
@@ -62,12 +58,15 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return Promise.all([
-        this.wrapper.set(splitKey, stringifiedNewSplit),
-        this._incrementCounts(split),
-        // If it's an update, we decrement the traffic type and segment count of the existing split,
-        parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
-      ]);
+      return this.wrapper.set(splitKey, stringifiedNewSplit).then(() => {
+        // avoid unnecessary increment/decrement operations
+        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
+
+        // update traffic type counts
+        return this._incrementCounts(split).then(() => {
+          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
+        });
+      });
     }).then(() => true);
   }