@splitsoftware/splitio-commons 2.7.9-rc.3 → 2.8.1-rc.0

package/CHANGES.txt

@@ -1,4 +1,8 @@
-2.8.0 (October 28, 2025)
+2.9.0 (November 26, 2025)
+ - Updated the SDK’s initial synchronization in Node.js (server-side) to use the `startup.requestTimeoutBeforeReady` and `startup.retriesOnFailureBeforeReady` options to control the timeout and retry behavior of segment requests.
+ - Updated the order of storage operations to prevent inconsistent states when using the `LOCALSTORAGE` storage type and the browser’s `localStorage` fails due to quota limits.
+
+2.8.0 (October 30, 2025)
  - Added new configuration for Fallback Treatments, which allows setting a treatment value and optional config to be returned in place of "control", either globally or by flag. Read more in our docs.
  - Added `client.getStatus()` method to retrieve the client readiness status properties (`isReady`, `isReadyFromCache`, etc).
  - Added `client.whenReady()` and `client.whenReadyFromCache()` methods to replace the deprecated `client.ready()` method, which has an issue causing the returned promise to hang when using async/await syntax if it was rejected.

package/cjs/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.js

@@ -1,51 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbacksSanitizer = void 0;
+exports.sanitizeFallbacks = exports.isValidTreatment = exports.isValidFlagName = void 0;
 var lang_1 = require("../../../utils/lang");
 var FallbackDiscardReason;
 (function (FallbackDiscardReason) {
     FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
     FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
 })(FallbackDiscardReason || (FallbackDiscardReason = {}));
-var FallbacksSanitizer = /** @class */ (function () {
-    function FallbacksSanitizer() {
+var TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+function isValidFlagName(name) {
+    return name.length <= 100 && !name.includes(' ');
+}
+exports.isValidFlagName = isValidFlagName;
+function isValidTreatment(t) {
+    var treatment = (0, lang_1.isObject)(t) ? t.treatment : t;
+    if (!(0, lang_1.isString)(treatment) || treatment.length > 100) {
+        return false;
     }
-    FallbacksSanitizer.isValidFlagName = function (name) {
-        return name.length <= 100 && !name.includes(' ');
-    };
-    FallbacksSanitizer.isValidTreatment = function (t) {
-        var treatment = (0, lang_1.isObject)(t) ? t.treatment : t;
-        if (!(0, lang_1.isString)(treatment) || treatment.length > 100) {
-            return false;
+    return TREATMENT_PATTERN.test(treatment);
+}
+exports.isValidTreatment = isValidTreatment;
+function sanitizeGlobal(logger, treatment) {
+    if (treatment === undefined)
+        return undefined;
+    if (!isValidTreatment(treatment)) {
+        logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
+        return undefined;
+    }
+    return treatment;
+}
+function sanitizeByFlag(logger, byFlagFallbacks) {
+    var sanitizedByFlag = {};
+    if (!(0, lang_1.isObject)(byFlagFallbacks))
+        return sanitizedByFlag;
+    Object.keys(byFlagFallbacks).forEach(function (flag) {
+        var t = byFlagFallbacks[flag];
+        if (!isValidFlagName(flag)) {
+            logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
+            return;
         }
-        return FallbacksSanitizer.pattern.test(treatment);
-    };
-    FallbacksSanitizer.sanitizeGlobal = function (logger, treatment) {
-        if (!this.isValidTreatment(treatment)) {
-            logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
-            return undefined;
+        if (!isValidTreatment(t)) {
+            logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
+            return;
         }
-        return treatment;
-    };
-    FallbacksSanitizer.sanitizeByFlag = function (logger, byFlagFallbacks) {
-        var _this = this;
-        var sanitizedByFlag = {};
-        var entries = Object.keys(byFlagFallbacks);
-        entries.forEach(function (flag) {
-            var t = byFlagFallbacks[flag];
-            if (!_this.isValidFlagName(flag)) {
-                logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
-                return;
-            }
-            if (!_this.isValidTreatment(t)) {
-                logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
-                return;
-            }
-            sanitizedByFlag[flag] = t;
-        });
-        return sanitizedByFlag;
+        sanitizedByFlag[flag] = t;
+    });
+    return sanitizedByFlag;
+}
+function sanitizeFallbacks(logger, fallbacks) {
+    if (!(0, lang_1.isObject)(fallbacks)) {
+        logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
+        return;
+    }
+    return {
+        global: sanitizeGlobal(logger, fallbacks.global),
+        byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
     };
-    FallbacksSanitizer.pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
-    return FallbacksSanitizer;
-}());
-exports.FallbacksSanitizer = FallbacksSanitizer;
+}
+exports.sanitizeFallbacks = sanitizeFallbacks;

package/cjs/evaluator/fallbackTreatmentsCalculator/index.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FallbackTreatmentsCalculator = exports.FALLBACK_PREFIX = void 0;
-var fallbackSanitizer_1 = require("./fallbackSanitizer");
 var constants_1 = require("../../utils/constants");
 var lang_1 = require("../../utils/lang");
 exports.FALLBACK_PREFIX = 'fallback - ';
 var FallbackTreatmentsCalculator = /** @class */ (function () {
-    function FallbackTreatmentsCalculator(logger, fallbacks) {
-        var sanitizedGlobal = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.global) ? fallbackSanitizer_1.FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
-        var sanitizedByFlag = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.byFlag) ? fallbackSanitizer_1.FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
-        this.fallbacks = {
-            global: sanitizedGlobal,
-            byFlag: sanitizedByFlag
-        };
+    function FallbackTreatmentsCalculator(fallbacks) {
+        if (fallbacks === void 0) { fallbacks = {}; }
+        this.fallbacks = fallbacks;
     }
     FallbackTreatmentsCalculator.prototype.resolve = function (flagName, label) {
         var _a;

package/cjs/sdkFactory/index.js

@@ -52,7 +52,7 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+    var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
         if (storage.splits.getChangeNumber() > -1)

package/cjs/storages/AbstractMySegmentsCacheSync.js

@@ -23,37 +23,45 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
-        this.setChangeNumber(segmentsData.cn);
+        var isDiff = false;
         var _a = segmentsData, added = _a.added, removed = _a.removed;
         if (added && removed) {
-            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff_1 = _this.addSegment(segment) || isDiff_1;
+                isDiff = _this.addSegment(segment) || isDiff;
             });
             removed.forEach(function (segment) {
-                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
+                isDiff = _this.removeSegment(segment) || isDiff;
             });
-            return isDiff_1;
-        }
-        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]);
         }
-        for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
+        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;
+                }
+            }
         }
-        return true;
+        this.setChangeNumber(segmentsData.cn);
+        return isDiff;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/cjs/storages/AbstractSplitsCacheSync.js

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

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -13,33 +13,20 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         _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)
-                return false;
-            this.storage.setItem(segmentKey, constants_1.DEFINED);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
+        if (this.storage.getItem(segmentKey) === constants_1.DEFINED)
             return false;
-        }
+        this.storage.setItem(segmentKey, constants_1.DEFINED);
+        return true;
     };
     MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        try {
-            if (this.storage.getItem(segmentKey) !== constants_1.DEFINED)
-                return false;
-            this.storage.removeItem(segmentKey);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
+        if (this.storage.getItem(segmentKey) !== constants_1.DEFINED)
             return false;
-        }
+        this.storage.removeItem(segmentKey);
+        return true;
     };
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
@@ -57,15 +44,10 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return 1;
     };
     MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            if (changeNumber)
-                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            else
-                this.storage.removeItem(this.keys.buildTillKey());
-        }
-        catch (e) {
-            this.log.error(e);
-        }
+        if (changeNumber)
+            this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+        else
+            this.storage.removeItem(this.keys.buildTillKey());
     };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -18,9 +18,10 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        this.setChangeNumber(changeNumber);
         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;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
@@ -40,40 +41,28 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
             this.storage.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 usesSegmentsDiff = 0;
-            if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
-                usesSegmentsDiff--;
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-                usesSegmentsDiff++;
-            if (usesSegmentsDiff !== 0)
-                this.updateSegmentCount(usesSegmentsDiff);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
-        }
+        var name = rbSegment.name;
+        var rbSegmentKey = this.keys.buildRBSegmentKey(name);
+        var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+        var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
+        this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+        var usesSegmentsDiff = 0;
+        if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
+            usesSegmentsDiff--;
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
+            usesSegmentsDiff++;
+        if (usesSegmentsDiff !== 0)
+            this.updateSegmentCount(usesSegmentsDiff);
+        return true;
     };
     RBSegmentsCacheInLocal.prototype.remove = function (name) {
-        try {
-            var rbSegment = this.get(name);
-            if (!rbSegment)
-                return false;
-            this.storage.removeItem(this.keys.buildRBSegmentKey(name));
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-                this.updateSegmentCount(-1);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
+        var rbSegment = this.get(name);
+        if (!rbSegment)
             return false;
-        }
+        this.storage.removeItem(this.keys.buildRBSegmentKey(name));
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
+            this.updateSegmentCount(-1);
+        return true;
     };
     RBSegmentsCacheInLocal.prototype.getNames = function () {
         var len = this.storage.length;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -70,39 +70,27 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         this.hasSync = false;
     };
     SplitsCacheInLocal.prototype.addSplit = function (split) {
-        try {
-            var name_1 = split.name;
-            var splitKey = this.keys.buildSplitKey(name_1);
-            var splitFromStorage = this.storage.getItem(splitKey);
-            var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-            if (previousSplit) {
-                this._decrementCounts(previousSplit);
-                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            }
-            this.storage.setItem(splitKey, JSON.stringify(split));
-            this._incrementCounts(split);
-            this.addToFlagSets(split);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
+        var name = split.name;
+        var splitKey = this.keys.buildSplitKey(name);
+        var splitFromStorage = this.storage.getItem(splitKey);
+        var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
+        if (previousSplit) {
+            this._decrementCounts(previousSplit);
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
         }
+        this.storage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this.addToFlagSets(split);
+        return true;
     };
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        try {
-            var split = this.getSplit(name);
-            if (!split)
-                return false;
-            this.storage.removeItem(this.keys.buildSplitKey(name));
-            this._decrementCounts(split);
-            this.removeFromFlagSets(split.name, split.sets);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
+        var split = this.getSplit(name);
+        if (!split)
             return false;
-        }
+        this.storage.removeItem(this.keys.buildSplitKey(name));
+        this._decrementCounts(split);
+        this.removeFromFlagSets(split.name, split.sets);
+        return true;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
         var item = this.storage.getItem(this.keys.buildSplitKey(name));
@@ -174,6 +162,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromStorage = _this.storage.getItem(flagSetKey);
             var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            if (flagSetCache.has(featureFlag.name))
+                return;
             flagSetCache.add(featureFlag.name);
             _this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
         });

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -16,9 +16,10 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     };
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        this.changeNumber = changeNumber;
         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;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+        this.changeNumber = changeNumber;
+        return updated;
     };
     RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
         var name = rbSegment.name;

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentsCacheInRedis = void 0;
 var lang_1 = require("../../utils/lang");
-var constants_1 = require("../inLocalStorage/constants");
+var constants_1 = require("./constants");
 var SegmentsCacheInRedis = /** @class */ (function () {
     function SegmentsCacheInRedis(log, keys, redis) {
         this.log = log;

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

@@ -8,6 +8,6 @@ var segmentChangesUpdater_1 = require("../updaters/segmentChangesUpdater");
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
 function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }
 exports.segmentsSyncTaskFactory = segmentsSyncTaskFactory;

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -48,9 +48,9 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
             mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(function (segments) {
-                // Only when we have downloaded segments completely, we should not keep retrying anymore
-                startingUp = false;
                 updateSegments(segments);
+                // Only when we have downloaded and stored segments completely, we should not keep retrying anymore
+                startingUp = false;
                 return true;
             });
         return updaterPromise.catch(function (error) {

package/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesUpdaterFactory = void 0;
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
+var timeout_1 = require("../../../utils/promise/timeout");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -14,22 +15,33 @@ var constants_2 = require("../../../logger/constants");
  * @param segments - segments storage, with sync or async methods
  * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
  */
-function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
+function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
     var readyOnAlreadyExistentState = true;
-    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
+    function _promiseDecorator(promise) {
+        if (readyOnAlreadyExistentState && requestTimeoutBeforeReady)
+            promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
+        return promise;
+    }
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
         log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
             return fetchOnlyNew && since !== undefined ?
                 false :
-                segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
+                segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
                         log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });
+                }).catch(function (error) {
+                    if (retries) {
+                        log.warn(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Retrying fetch of segment " + segmentName + " (attempt #" + retries + "). Reason: " + error);
+                        return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
+                    }
+                    throw error;
                 });
         });
     }
@@ -49,8 +61,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers
-            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -135,7 +135,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                     { rbs: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
                 splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (splitChanges) {
-                startingUp = false;
                 var usedSegments = new Set();
                 var ffUpdate = false;
                 if (splitChanges.ff) {
@@ -156,6 +155,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                     var ffChanged = _a[0], rbsChanged = _a[1];
                     if (storage.save)
                         storage.save();
+                    startingUp = false;
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
@@ -171,14 +171,14 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                 });
             })
                 .catch(function (error) {
-                log.warn(constants_2.SYNC_SPLITS_FETCH_FAILS, [error]);
                 if (startingUp && retriesOnFailureBeforeReady > retry) {
                     retry += 1;
-                    log.info(constants_2.SYNC_SPLITS_FETCH_RETRY, [retry, error]);
+                    log.warn(constants_2.SYNC_SPLITS_FETCH_RETRY, [retry, error]);
                     return _splitChangesUpdater(sinces, retry);
                 }
                 else {
                     startingUp = false;
+                    log.warn(constants_2.SYNC_SPLITS_FETCH_FAILS, [error]);
                 }
                 return false;
             });

package/cjs/utils/settingsValidation/index.js

@@ -9,6 +9,7 @@ var impressionsMode_1 = require("./impressionsMode");
 var key_1 = require("../inputValidation/key");
 var constants_2 = require("../../logger/constants");
 var setRolloutPlan_1 = require("../../storages/setRolloutPlan");
+var fallbackSanitizer_1 = require("../../evaluator/fallbackTreatmentsCalculator/fallbackSanitizer");
 // Exported for telemetry
 exports.base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -183,6 +184,8 @@ function settingsValidation(config, validationParams) {
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
+    // @ts-ignore, modify readonly prop
+    withDefaults.fallbackTreatments = withDefaults.fallbackTreatments ? (0, fallbackSanitizer_1.sanitizeFallbacks)(log, withDefaults.fallbackTreatments) : undefined;
     return withDefaults;
 }
 exports.settingsValidation = settingsValidation;