@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/esm/storages/pluggable/DefinitionsCachePluggable.js

@@ -0,0 +1,209 @@
+import { __extends, __spreadArray } from "tslib";
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { LOG_PREFIX } from './constants';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
+import { returnDifference } from '../../utils/lang/sets';
+/**
+ * IDefinitionsCacheAsync implementation for pluggable storages.
+ */
+var DefinitionsCachePluggable = /** @class */ (function (_super) {
+    __extends(DefinitionsCachePluggable, _super);
+    /**
+     * Create a DefinitionsCache that uses a storage wrapper.
+     * @param log -  Logger instance.
+     * @param keys -  Key builder.
+     * @param wrapper -  Adapted wrapper storage.
+     */
+    function DefinitionsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.log = log;
+        _this.keys = keys;
+        _this.wrapper = wrapper;
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    DefinitionsCachePluggable.prototype._decrementCounts = function (definition) {
+        var _this = this;
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.wrapper.del(ttKey);
+        });
+    };
+    DefinitionsCachePluggable.prototype._incrementCounts = function (definition) {
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.incr(ttKey);
+    };
+    DefinitionsCachePluggable.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
+        var _this = this;
+        var removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+        var addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+        if (this.setsFilter.length > 0) {
+            addToSets = addToSets.filter(function (set) {
+                return _this.setsFilter.some(function (filterSet) { return filterSet === set; });
+            });
+        }
+        var items = [definitionName];
+        return Promise.all(__spreadArray(__spreadArray([], removeFromSets.map(function (setName) { return _this.wrapper.removeItems(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.wrapper.addItems(_this.keys.buildSetKey(setName), items); }), true));
+    };
+    /**
+     * Add a given definition.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., wrapper operation fails)
+     */
+    DefinitionsCachePluggable.prototype.add = function (definition) {
+        var _this = this;
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        return this.wrapper.get(definitionKey).then(function (definitionFromStorage) {
+            // handling parsing error
+            var parsedPreviousDefinition, stringifiedNewDefinition;
+            try {
+                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                stringifiedNewDefinition = JSON.stringify(definition);
+            }
+            catch (e) {
+                throw new Error('Error parsing feature flag definition: ' + e);
+            }
+            return _this.wrapper.set(definitionKey, stringifiedNewDefinition).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(definition).then(function () {
+                    if (parsedPreviousDefinition)
+                        return _this._decrementCounts(parsedPreviousDefinition);
+                });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
+        }).then(function () { return true; });
+    };
+    /**
+     * Remove a given definition.
+     * The returned promise is resolved when the operation success, with a boolean indicating if the definition existed or not.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.remove = function (name) {
+        var _this = this;
+        return this.get(name).then(function (definition) {
+            if (definition) {
+                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
+            }
+        }).then(function () {
+            return _this.wrapper.del(_this.keys.buildDefinitionKey(name));
+        });
+    };
+    /**
+     * Get definition.
+     * The returned promise is resolved with the definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.get = function (name) {
+        return this.wrapper.get(this.keys.buildDefinitionKey(name))
+            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
+    };
+    /**
+     * Get list of definitions.
+     * The returned promise is resolved with a map of names to their definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getMany = function (names) {
+        var _this = this;
+        var keys = names.map(function (name) { return _this.keys.buildDefinitionKey(name); });
+        return this.wrapper.getMany(keys).then(function (stringifiedDefinitions) {
+            var definitions = {};
+            names.forEach(function (name, idx) {
+                var definition = stringifiedDefinitions[idx];
+                definitions[name] = definition && JSON.parse(definition);
+            });
+            return Promise.resolve(definitions);
+        });
+    };
+    /**
+     * Get list of all definitions.
+     * The returned promise is resolved with the list of definitions,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getAll = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (definitions) { return definitions.map(function (definition) {
+            return JSON.parse(definition);
+        }); });
+    };
+    /**
+     * Get list of definition names.
+     * The returned promise is resolved with the list of names,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getNames = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+    };
+    /**
+     * Get list of definition names related to a given list of set names.
+     * The returned promise is resolved with the list of names per set.
+     * It never rejects (If there is a wrapper error for some set, an empty set is returned for it).
+     */
+    DefinitionsCachePluggable.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return Promise.all(sets.map(function (set) {
+            var setKey = _this.keys.buildSetKey(set);
+            return _this.wrapper.getItems(setKey).catch(function () { return []; });
+        })).then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
+    };
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    DefinitionsCachePluggable.prototype.trafficTypeExists = function (trafficType) {
+        var _this = this;
+        // If there is a number there should be > 0, otherwise the TT is considered as not existent.
+        return this.wrapper.get(this.keys.buildTrafficTypeKey(trafficType))
+            .then(function (ttCount) {
+            if (ttCount === null)
+                return false; // if entry doesn't exist, means that TT doesn't exist
+            ttCount = parseInt(ttCount, 10);
+            if (!isFiniteNumber(ttCount) || ttCount < 0) {
+                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
+                return false;
+            }
+            return ttCount > 0;
+        }).catch(function (e) {
+            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
+            // If there is an error, bypass the validation so the event can get tracked.
+            return true;
+        });
+    };
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
+        return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+    };
+    /**
+     * Get till number or -1 if it's not defined.
+     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
+     * The promise will never be rejected.
+     */
+    DefinitionsCachePluggable.prototype.getChangeNumber = function () {
+        var _this = this;
+        return this.wrapper.get(this.keys.buildDefinitionsTillKey()).then(function (value) {
+            var i = parseInt(value, 10);
+            return isNaNNumber(i) ? -1 : i;
+        }).catch(function (e) {
+            _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+            return -1;
+        });
+    };
+    // @TODO implement if required by DataLoader or producer mode
+    DefinitionsCachePluggable.prototype.clear = function () {
+        return Promise.resolve(true);
+    };
+    return DefinitionsCachePluggable;
+}(AbstractDefinitionsCacheAsync));
+export { DefinitionsCachePluggable };

package/esm/storages/pluggable/EventsCachePluggable.js

@@ -18,7 +18,7 @@ var EventsCachePluggable = /** @class */ (function () {
             // We use boolean values to signal successful queueing
             .then(function () { return true; })
             .catch(function (e) {
-            _this.log.error(LOG_PREFIX + "Error adding event to queue: " + e + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error adding event to queue: ").concat(e, "."));
             return false;
         });
     };

package/esm/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -21,10 +21,10 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
         if (!keys.length)
             return Promise.resolve(false);
         var pipeline = keys.reduce(function (pipeline, key) {
-            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+            return pipeline.then(function () { return _this.wrapper.incr("".concat(_this.key, "::").concat(key), counts[key]); });
         }, Promise.resolve());
         return pipeline.catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in impression counts pipeline: ").concat(err, "."));
             return false;
         });
     };
@@ -49,18 +49,18 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
                     var count = counts[i];
                     var keyFeatureNameAndTime = key.split('::');
                     if (keyFeatureNameAndTime.length !== 3) {
-                        _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                        _this.log.error("".concat(LOG_PREFIX, "Error spliting key ").concat(key));
                         continue;
                     }
                     var timeFrame = parseInt(keyFeatureNameAndTime[2]);
                     if (isNaN(timeFrame)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        _this.log.error("".concat(LOG_PREFIX, "Error parsing time frame ").concat(keyFeatureNameAndTime[2]));
                         continue;
                     }
                     // @ts-ignore
                     var rawCount = parseInt(count);
                     if (isNaN(rawCount)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                        _this.log.error("".concat(LOG_PREFIX, "Error parsing raw count ").concat(count));
                         continue;
                     }
                     pf.push({

package/esm/storages/pluggable/RBSegmentsCachePluggable.js

@@ -31,7 +31,7 @@ var RBSegmentsCachePluggable = /** @class */ (function () {
                 return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
             })),
             Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
+                var key = _this.keys.buildRBSegmentKey(toRemove);
                 return _this.wrapper.del(key);
             }))
         ]).then(function (_a) {

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -42,18 +42,18 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = latencyKeys[i].split('::')[1];
                         var parsedField = parseLatencyField(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(latencies[i]);
                         if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            _this.log.error("Ignoring latency with invalid count: ".concat(latencies[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                         if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                             continue;
                         }
                         var methodLatencies = result.get(metadata) || {};
@@ -81,13 +81,13 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = exceptionKeys[i].split('::')[1];
                         var parsedField = parseExceptionField(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(exceptions[i]);
                         if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1];
@@ -115,7 +115,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = configKeys[i].split('::')[1];
                         var parsedField = parseMetadata(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         var metadata = parsedField[0];
@@ -124,7 +124,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                             result.set(metadata, config);
                         }
                         catch (e) {
-                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                            _this.log.error("Ignoring invalid config: ".concat(configs[i]));
                         }
                     }
                     return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -32,7 +32,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         this.clear();
         return this.wrapper.pushItems(this.key, uniqueKeysArray)
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/pluggable/index.js

@@ -1,6 +1,6 @@
 import { __assign } from "tslib";
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCachePluggable } from './SplitsCachePluggable';
+import { DefinitionsCachePluggable } from './DefinitionsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
 import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
@@ -35,7 +35,7 @@ function validatePluggableStorageOptions(options) {
     var wrapper = options.wrapper;
     var missingMethods = METHODS_TO_PROMISE_WRAP.filter(function (method) { return typeof wrapper[method] !== 'function'; });
     if (missingMethods.length)
-        throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
+        throw new Error("".concat(NO_VALID_WRAPPER_INTERFACE, " The following methods are missing or invalid: ").concat(missingMethods));
 }
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
@@ -79,7 +79,7 @@ export function PluggableStorage(options) {
                     var currentHash = getStorageHash(settings);
                     if (hash !== currentHash) {
                         log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                        return wrapper.getKeysByPrefix("".concat(keys.prefix, ".")).then(function (storageKeys) {
                             return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
                         }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
                     }
@@ -103,7 +103,7 @@ export function PluggableStorage(options) {
             return e; // Propagate error for shared clients
         });
         return {
-            splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/esm/storages/pluggable/wrapperAdapter.js

@@ -31,7 +31,7 @@ export function wrapperAdapter(log, wrapper) {
     METHODS_TO_PROMISE_WRAP.forEach(function (method) {
         // Logs error and wraps it into a rejected promise.
         function handleError(e) {
-            log.error(LOG_PREFIX + " Wrapper '" + method + "' operation threw an error. Message: " + e);
+            log.error("".concat(LOG_PREFIX, " Wrapper '").concat(method, "' operation threw an error. Message: ").concat(e));
             return Promise.reject(e);
         }
         wrapperAdapter[method] = function () {

package/esm/storages/setRolloutPlan.js

@@ -20,16 +20,16 @@ export function validateRolloutPlan(log, settings) {
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 export function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
     var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
-    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
-    if (splits && ff) {
-        splits.clear();
-        splits.update(ff.d, [], ff.t);
+    log.debug("storage: set feature flags and segments".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
+    if (definitions && ff) {
+        definitions.clear();
+        definitions.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();
-        rbSegments.update(rbs.d, [], rbs.t);
+        rbSegments.update(rbs.d || [], [], rbs.t);
     }
     var segmentChanges = rolloutPlan.segmentChanges;
     if (matchingKey) { // add memberships data (client-side)

package/esm/storages/utils.js

@@ -37,30 +37,30 @@ var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key)
 export function parseMetadata(field) {
     var parts = field.split('/');
     if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
+        return "invalid subsection count. Expected 3, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
     return [JSON.stringify({ s: s, n: n, i: i })];
 }
 export function parseExceptionField(field) {
     var parts = field.split('/');
     if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
+        return "invalid subsection count. Expected 4, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     return [JSON.stringify({ s: s, n: n, i: i }), method];
 }
 export function parseLatencyField(field) {
     var parts = field.split('/');
     if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
+        return "invalid subsection count. Expected 5, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     var bucket = parseInt(b);
     if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+        return "invalid bucket. Expected a number between 0 and ".concat(MAX_LATENCY_BUCKET_COUNT - 1, ", got: ").concat(b);
     return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
 }

package/esm/sync/offline/splitsParser/parseCondition.js

@@ -23,7 +23,7 @@ export function parseCondition(data) {
                     size: 100
                 }
             ],
-            label: "whitelisted " + treatment
+            label: "whitelisted ".concat(treatment)
         };
     }
     else {

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

@@ -1,13 +1,13 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 export function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log, splitsCache = storage.splits;
+    var log = settings.log, definitions = storage.definitions;
     var startingUp = true;
     return function objectUpdater() {
         var splits = [];
@@ -36,16 +36,16 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 });
             });
             return Promise.all([
-                splitsCache.clear(),
-                splitsCache.update(splits, [], Date.now())
+                definitions.clear(),
+                definitions.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
+                readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
                     Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                         // Emits SDK_READY
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });

package/esm/sync/polling/fetchers/splitChangesFetcher.js

@@ -1,22 +1,31 @@
 import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
-import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+import { LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { checkIfServerSide } from '../../../utils/key';
 var PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
 var PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
 function sdkEndpointOverridden(settings) {
     return settings.urls.sdk !== base.urls.sdk;
 }
+function isSplitChangesLegacyResponse(data) {
+    return data.splits != null;
+}
+function partitionByStatus(items, till, since) {
+    var updated = [], removed = [];
+    items.forEach(function (item) { return item.status === 'ARCHIVED' ? removed.push(item.name) : updated.push(item); });
+    return { updated: updated, removed: removed, till: till, since: since };
+}
 /**
  * Factory of SplitChanges fetcher.
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
-export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage) {
+export function splitChangesFetcherFactory(params) {
+    var fetchSplitChanges = params.splitApi.fetchSplitChanges, settings = params.settings, storage = params.storage;
     var log = settings.log;
     var PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
     var lastProxyCheckTimestamp;
-    return function splitChangesFetcher(since, noCache, till, rbSince, 
+    function splitChangesFetcher(since, noCache, till, rbSince, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
         // Recheck proxy
@@ -27,7 +36,7 @@ export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage)
             .catch(function (err) {
             // Handle proxy error with spec 1.3
             if ((!err.statusCode || err.statusCode === 400) && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === FLAG_SPEC_VERSION) {
-                log.error(LOG_PREFIX_SYNC_SPLITS + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
+                log.error(LOG_PREFIX_SYNC + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
                 lastProxyCheckTimestamp = Date.now();
                 settings.sync.flagSpecVersion = '1.2'; // fallback to 1.2 spec
                 return fetchSplitChanges(since, noCache, till); // retry request without rbSince
@@ -40,26 +49,26 @@ export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage)
             .then(function (resp) { return resp.json(); })
             .then(function (data) {
             // Using flag spec version 1.2 or below
-            if (data.splits) {
-                return {
-                    ff: {
-                        d: data.splits,
-                        s: data.since,
-                        t: data.till
-                    }
-                };
+            if (isSplitChangesLegacyResponse(data)) {
+                return { d: partitionByStatus(data.splits || [], data.till, data.since) };
             }
             // Proxy recovery
             if (lastProxyCheckTimestamp) {
-                log.info(LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
+                log.info(LOG_PREFIX_SYNC + 'Proxy error recovered');
                 lastProxyCheckTimestamp = undefined;
                 return splitChangesFetcher(-1, undefined, undefined, -1)
                     .then(function (splitChangesResponse) {
-                    return Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+                    return Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
                         .then(function () { return splitChangesResponse; });
                 });
             }
-            return data;
+            var ff = data.ff, rbs = data.rbs;
+            return {
+                d: (ff === null || ff === void 0 ? void 0 : ff.d) ? partitionByStatus(ff.d, ff.t, ff.s) : undefined,
+                rbs: (rbs === null || rbs === void 0 ? void 0 : rbs.d) ? partitionByStatus(rbs.d, rbs.t, rbs.s) : undefined,
+            };
         });
-    };
+    }
+    splitChangesFetcher.type = 'feature flags';
+    return splitChangesFetcher;
 }