@splitsoftware/splitio-commons 2.4.2-rc.2 → 2.5.0-rc.0

package/CHANGES.txt

@@ -1,5 +1,6 @@
 2.5.0 (August XX, 2025)
- - Added `storage.wrapper` configuration option to allow the SDK to use a custom storage wrapper for the storage type `LOCALSTORAGE`. Default value is `window.localStorage`.
+ - Added `factory.getCache()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
+ - Added `preloadedData` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
 
 2.4.1 (June 3, 2025)
  - Bugfix - Improved the Proxy fallback to flag spec version 1.2 to handle cases where the Proxy does not return an end-of-stream marker in 400 status code responses.
@@ -50,15 +51,6 @@
    - Removed internal ponyfills for `Map` and `Set` global objects, dropping support for IE and other outdated browsers. The SDK now requires the runtime environment to support these features natively or to provide a polyfill.
    - Removed the `sync.localhostMode` configuration option to plug the LocalhostMode module.
 
-1.17.1 (July 25, 2025)
- - Updated the Redis storage to avoid lazy require of the `ioredis` dependency when the SDK is initialized.
- - Updated some transitive dependencies for vulnerability fixes.
- - Bugfix - Enhanced HTTP client module to implement timeouts for failing requests that might otherwise remain pending indefinitely on some Fetch API implementations, pausing the SDK synchronization process.
- - Bugfix - Properly handle rejected promises when using targeting rules with segment matchers in consumer modes (e.g., Redis and Pluggable storages).
- - Bugfix - Sanitize the `SplitSDKMachineName` header value to avoid exceptions on HTTP/S requests when it contains non ISO-8859-1 characters (Related to issue https://github.com/splitio/javascript-client/issues/847).
- - Bugfix - Fixed an issue with the SDK_UPDATE event on server-side, where it was not being emitted if there was an empty segment and the SDK received a feature flag update notification.
- - Bugfix - Fixed an issue with the server-side polling manager that caused dangling timers when the SDK was destroyed before it was ready.
-
 1.17.0 (September 6, 2024)
  - Added `sync.requestOptions.getHeaderOverrides` configuration option to enhance SDK HTTP request Headers for Authorization Frameworks.
  - Added `isTimedout` and `lastUpdate` properties to IStatusInterface to keep track of the timestamp of the last SDK event, used on React and Redux SDKs.

package/cjs/storages/AbstractMySegmentsCacheSync.js

@@ -23,45 +23,37 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
-        var isDiff = false;
         if (added && removed) {
+            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff = _this.addSegment(segment) || isDiff;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff = _this.removeSegment(segment) || isDiff;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
+            return isDiff_1;
         }
-        else {
-            var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-            var storedSegmentKeys = this.getRegisteredSegments().sort();
-            // Extreme fast => everything is empty
-            if (!names.length && !storedSegmentKeys.length) {
-                isDiff = false;
-            }
-            else {
-                var index = 0;
-                while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-                    index++;
-                // Quick path => no changes
-                if (index === names.length && index === storedSegmentKeys.length) {
-                    isDiff = false;
-                }
-                else {
-                    // Slowest path => add and/or remove segments
-                    for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-                        this.removeSegment(storedSegmentKeys[removeIndex]);
-                    }
-                    for (var addIndex = index; addIndex < names.length; addIndex++) {
-                        this.addSegment(names[addIndex]);
-                    }
-                    isDiff = true;
-                }
-            }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
-        this.setChangeNumber(segmentsData.cn);
-        return isDiff;
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+        }
+        return true;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -12,10 +12,9 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
     }
     AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;

package/cjs/storages/dataLoader.js

@@ -1,50 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
-// This value might be eventually set via a config parameter
-var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
+exports.getCache = exports.setCache = void 0;
+var sets_1 = require("../utils/lang/sets");
+var key_1 = require("../utils/key");
 /**
- * Factory of client-side storage loader
- *
- * @param preloadedData - validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
+ * Sets the given synchronous storage with the provided preloaded data snapshot.
+ * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
+ * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
-function dataLoaderFactory(preloadedData) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage - object containing `splits` and `segments` cache (client-side variant)
-     * @param userId - user key string of the provided MySegmentsCache
-     */
-    // @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-    // @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
-        var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        // Do not load data if current localStorage data is more recent,
-        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-        if (storedSince > since || lastUpdated < expirationTimestamp)
-            return;
-        // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
-        storage.splits.clear();
-        // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.update(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }), [], since);
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-        if (!mySegmentsData) {
-            // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-            mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
-            });
+function setCache(log, preloadedData, storage, matchingKey) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0)
+        return;
+    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    log.debug("set cache" + (matchingKey ? " for key " + matchingKey : ''));
+    if (splits) {
+        splits.clear();
+        splits.update(preloadedData.flags || [], [], preloadedData.since || -1);
+    }
+    if (rbSegments) {
+        rbSegments.clear();
+        rbSegments.update(preloadedData.rbSegments || [], [], preloadedData.rbSince || -1);
+    }
+    var segmentsData = preloadedData.segments || {};
+    if (matchingKey) { // add memberships data (client-side)
+        var memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
+        if (!memberships && segmentsData) {
+            memberships = {
+                ms: {
+                    k: Object.keys(segmentsData).filter(function (segmentName) {
+                        var segmentKeys = segmentsData[segmentName];
+                        return segmentKeys.indexOf(matchingKey) > -1;
+                    }).map(function (segmentName) { return ({ n: segmentName }); })
+                }
+            };
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        if (memberships) {
+            if (memberships.ms)
+                segments.resetSegments(memberships.ms);
+            if (memberships.ls && largeSegments)
+                largeSegments.resetSegments(memberships.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).forEach(function (segmentName) {
+            var segmentKeys = segmentsData[segmentName];
+            segments.update(segmentName, segmentKeys, [], -1);
+        });
+    }
+}
+exports.setCache = setCache;
+/**
+ * Gets the preloaded data snapshot from the given synchronous storage.
+ * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
+ * Otherwise, the segments data is returned.
+ */
+function getCache(log, storage, keys) {
+    log.debug("get cache" + (keys ? " for keys " + keys : ''));
+    return {
+        since: storage.splits.getChangeNumber(),
+        flags: storage.splits.getAll(),
+        rbSince: storage.rbSegments.getChangeNumber(),
+        rbSegments: storage.rbSegments.getAll(),
+        segments: keys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        memberships: keys ?
+            keys.reduce(function (prev, key) {
+                if (storage.shared) {
+                    // Client-side segments
+                    // @ts-ignore accessing private prop
+                    var sharedStorage = storage.shared(key);
+                    prev[(0, key_1.getMatching)(key)] = {
+                        ms: {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        } : undefined
+                    };
+                }
+                else {
+                    prev[(0, key_1.getMatching)(key)] = {
+                        ms: {
+                            // Server-side segments
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(key) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
     };
 }
-exports.dataLoaderFactory = dataLoaderFactory;
+exports.getCache = getCache;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -7,20 +7,19 @@ var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
 var constants_1 = require("./constants");
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(log, keys, storage) {
+    function MySegmentsCacheInLocal(log, keys) {
         var _this = _super.call(this) || this;
         _this.log = log;
         _this.keys = keys;
-        _this.storage = storage;
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
     MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (this.storage.getItem(segmentKey) === constants_1.DEFINED)
+            if (localStorage.getItem(segmentKey) === constants_1.DEFINED)
                 return false;
-            this.storage.setItem(segmentKey, constants_1.DEFINED);
+            localStorage.setItem(segmentKey, constants_1.DEFINED);
             return true;
         }
         catch (e) {
@@ -31,9 +30,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (this.storage.getItem(segmentKey) !== constants_1.DEFINED)
+            if (localStorage.getItem(segmentKey) !== constants_1.DEFINED)
                 return false;
-            this.storage.removeItem(segmentKey);
+            localStorage.removeItem(segmentKey);
             return true;
         }
         catch (e) {
@@ -42,16 +41,17 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
-        return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
+        return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
     };
     MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var registeredSegments = [];
-        for (var i = 0; i < this.storage.length; i++) {
-            var segmentName = this.keys.extractSegmentName(this.storage.key(i));
+        var _this = this;
+        // Scan current values from localStorage
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName)
-                registeredSegments.push(segmentName);
-        }
-        return registeredSegments;
+                accum.push(segmentName);
+            return accum;
+        }, []);
     };
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
@@ -59,9 +59,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
             if (changeNumber)
-                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
             else
-                this.storage.removeItem(this.keys.buildTillKey());
+                localStorage.removeItem(this.keys.buildTillKey());
         }
         catch (e) {
             this.log.error(e);
@@ -69,7 +69,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = this.storage.getItem(this.keys.buildTillKey());
+        var value = localStorage.getItem(this.keys.buildTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return (0, lang_1.isNaNNumber)(value) ? n : value;

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -6,27 +6,25 @@ var sets_1 = require("../../utils/lang/sets");
 var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var constants_1 = require("./constants");
 var RBSegmentsCacheInLocal = /** @class */ (function () {
-    function RBSegmentsCacheInLocal(settings, keys, storage) {
+    function RBSegmentsCacheInLocal(settings, keys) {
         this.keys = keys;
         this.log = settings.log;
-        this.storage = storage;
     }
     RBSegmentsCacheInLocal.prototype.clear = function () {
         var _this = this;
         this.getNames().forEach(function (name) { return _this.remove(name); });
-        this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
+        localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
         }
         catch (e) {
             this.log.error(constants_1.LOG_PREFIX + e);
@@ -34,19 +32,20 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
         var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        var count = (0, lang_1.toNumber)(this.storage.getItem(segmentsCountKey)) + diff;
+        var count = (0, lang_1.toNumber)(localStorage.getItem(segmentsCountKey)) + diff;
+        // @ts-expect-error
         if (count > 0)
-            this.storage.setItem(segmentsCountKey, count + '');
+            localStorage.setItem(segmentsCountKey, count);
         else
-            this.storage.removeItem(segmentsCountKey);
+            localStorage.removeItem(segmentsCountKey);
     };
     RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
         try {
             var name_1 = rbSegment.name;
             var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
-            var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-            var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
-            this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+            var rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+            var previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+            localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
             var usesSegmentsDiff = 0;
             if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
                 usesSegmentsDiff--;
@@ -66,7 +65,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
             var rbSegment = this.get(name);
             if (!rbSegment)
                 return false;
-            this.storage.removeItem(this.keys.buildRBSegmentKey(name));
+            localStorage.removeItem(this.keys.buildRBSegmentKey(name));
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
                 this.updateSegmentCount(-1);
             return true;
@@ -77,11 +76,11 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         }
     };
     RBSegmentsCacheInLocal.prototype.getNames = function () {
-        var len = this.storage.length;
+        var len = localStorage.length;
         var accum = [];
         var cur = 0;
         while (cur < len) {
-            var key = this.storage.key(cur);
+            var key = localStorage.key(cur);
             if (key != null && this.keys.isRBSegmentKey(key))
                 accum.push(this.keys.extractKey(key));
             cur++;
@@ -89,9 +88,13 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return accum;
     };
     RBSegmentsCacheInLocal.prototype.get = function (name) {
-        var item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
+        var item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
         return item && JSON.parse(item);
     };
+    RBSegmentsCacheInLocal.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
     RBSegmentsCacheInLocal.prototype.contains = function (names) {
         var namesArray = (0, sets_1.setToArray)(names);
         var namesInStorage = this.getNames();
@@ -99,7 +102,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
+        var value = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return (0, lang_1.isNaNNumber)(value) ? n : value;
@@ -107,7 +110,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return n;
     };
     RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : (0, lang_1.toNumber)(storedCount);
         return (0, lang_1.isFiniteNumber)(splitsWithSegmentsCount) ?
             splitsWithSegmentsCount > 0 :