@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.10

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitsCachePluggable = void 0;
+var tslib_1 = require("tslib");
+var lang_1 = require("../../utils/lang");
+var constants_1 = require("./constants");
+var AbstractSplitsCacheAsync_1 = require("../AbstractSplitsCacheAsync");
+var sets_1 = require("../../utils/lang/sets");
+/**
+ * ISplitsCacheAsync implementation for pluggable storages.
+ */
+var SplitsCachePluggable = /** @class */ (function (_super) {
+    tslib_1.__extends(SplitsCachePluggable, _super);
+    /**
+     * Create a SplitsCache that uses a storage wrapper.
+     * @param log -  Logger instance.
+     * @param keys -  Key builder.
+     * @param wrapper -  Adapted wrapper storage.
+     */
+    function SplitsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.log = log;
+        _this.keys = keys;
+        _this.wrapper = wrapper;
+        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    SplitsCachePluggable.prototype._decrementCounts = function (split) {
+        var _this = this;
+        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) {
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        return this.wrapper.incr(ttKey);
+    };
+    SplitsCachePluggable.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
+        var _this = this;
+        var removeFromFlagSets = (0, sets_1.returnDifference)(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+        var addToFlagSets = (0, sets_1.returnDifference)(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        if (this.flagSetsFilter.length > 0) {
+            addToFlagSets = addToFlagSets.filter(function (flagSet) {
+                return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });
+            });
+        }
+        var items = [featureFlagName];
+        return Promise.all(tslib_1.__spreadArray(tslib_1.__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.wrapper.removeItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.wrapper.addItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
+    };
+    /**
+     * Add a given split.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., wrapper operation fails)
+     */
+    SplitsCachePluggable.prototype.addSplit = function (split) {
+        var _this = this;
+        var name = split.name;
+        var splitKey = this.keys.buildSplitKey(name);
+        return this.wrapper.get(splitKey).then(function (splitFromStorage) {
+            // handling parsing error
+            var parsedPreviousSplit, stringifiedNewSplit;
+            try {
+                parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
+                stringifiedNewSplit = JSON.stringify(split);
+            }
+            catch (e) {
+                throw new Error('Error parsing feature flag definition: ' + e);
+            }
+            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 _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
+        }).then(function () { return true; });
+    };
+    /**
+     * Remove a given split.
+     * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    SplitsCachePluggable.prototype.removeSplit = function (name) {
+        var _this = this;
+        return this.getSplit(name).then(function (split) {
+            if (split) {
+                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
+            }
+        }).then(function () {
+            return _this.wrapper.del(_this.keys.buildSplitKey(name));
+        });
+    };
+    /**
+     * Get split.
+     * The returned promise is resolved with the split definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    SplitsCachePluggable.prototype.getSplit = function (name) {
+        return this.wrapper.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
+    };
+    /**
+     * Get list of splits.
+     * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    SplitsCachePluggable.prototype.getSplits = function (names) {
+        var _this = this;
+        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
+        return this.wrapper.getMany(keys).then(function (splitDefinitions) {
+            var splits = {};
+            names.forEach(function (name, idx) {
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
+            });
+            return Promise.resolve(splits);
+        });
+    };
+    /**
+     * Get list of all split definitions.
+     * The returned promise is resolved with the list of split definitions,
+     * or rejected if wrapper operation fails.
+     */
+    SplitsCachePluggable.prototype.getAll = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
+    };
+    /**
+     * Get list of split names.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     */
+    SplitsCachePluggable.prototype.getSplitNames = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+    };
+    /**
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set.
+     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
+     */
+    SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return Promise.all(flagSets.map(function (flagSet) {
+            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
+            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
+        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
+    };
+    /**
+     * 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.
+     */
+    SplitsCachePluggable.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 (!(0, lang_1.isFiniteNumber)(ttCount) || ttCount < 0) {
+                _this.log.info(constants_1.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(constants_1.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).
+     */
+    SplitsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
+        return this.wrapper.set(this.keys.buildSplitsTillKey(), 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.
+     */
+    SplitsCachePluggable.prototype.getChangeNumber = function () {
+        var _this = this;
+        return this.wrapper.get(this.keys.buildSplitsTillKey()).then(function (value) {
+            var i = parseInt(value, 10);
+            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+        }).catch(function (e) {
+            _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+            return -1;
+        });
+    };
+    // @TODO implement if required by DataLoader or producer mode
+    SplitsCachePluggable.prototype.clear = function () {
+        return Promise.resolve(true);
+    };
+    return SplitsCachePluggable;
+}(AbstractSplitsCacheAsync_1.AbstractSplitsCacheAsync));
+exports.SplitsCachePluggable = SplitsCachePluggable;

package/cjs/storages/pluggable/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluggableStorage = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilderSS_1 = require("../KeyBuilderSS");
-var DefinitionsCachePluggable_1 = require("./DefinitionsCachePluggable");
+var SplitsCachePluggable_1 = require("./SplitsCachePluggable");
 var SegmentsCachePluggable_1 = require("./SegmentsCachePluggable");
 var ImpressionsCachePluggable_1 = require("./ImpressionsCachePluggable");
 var EventsCachePluggable_1 = require("./EventsCachePluggable");
@@ -106,7 +106,7 @@ function PluggableStorage(options) {
             return e; // Propagate error for shared clients
         });
         return {
-            definitions: new DefinitionsCachePluggable_1.DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+            splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCachePluggable_1.RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/cjs/storages/setRolloutPlan.js

@@ -24,12 +24,12 @@ exports.validateRolloutPlan = validateRolloutPlan;
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
-    var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var splits = storage.splits, 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".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
-    if (definitions && ff) {
-        definitions.clear();
-        definitions.update(ff.d || [], [], ff.t);
+    if (splits && ff) {
+        splits.clear();
+        splits.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();

package/cjs/storages/utils.js

@@ -28,7 +28,6 @@ function impressionsToJSON(impressions, metadata) {
                 m: impression.time,
                 pt: impression.pt,
                 properties: impression.properties
-                // @TODO set entityType
             }
         };
         return JSON.stringify(impressionWithMetadata);

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

@@ -10,7 +10,7 @@ var constants_3 = require("../../../logger/constants");
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log, definitions = storage.definitions;
+    var log = settings.log, splitsCache = storage.splits;
     var startingUp = true;
     return function objectUpdater() {
         var splits = [];
@@ -39,16 +39,16 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 });
             });
             return Promise.all([
-                definitions.clear(),
-                definitions.update(splits, [], Date.now())
+                splitsCache.clear(),
+                splitsCache.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.definitions.emit(constants_2.SDK_DEFINITIONS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [] });
+                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: constants_2.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.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
                         }
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: constants_2.SEGMENTS_UPDATE, names: [] });

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

@@ -10,25 +10,16 @@ var PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24
 function sdkEndpointOverridden(settings) {
     return settings.urls.sdk !== settingsValidation_1.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
-function splitChangesFetcherFactory(params) {
-    var fetchSplitChanges = params.serviceApi.fetchSplitChanges, settings = params.settings, storage = params.storage;
+function splitChangesFetcherFactory(fetchSplitChanges, settings, storage) {
     var log = settings.log;
     var PROXY_CHECK_INTERVAL_MILLIS = (0, key_1.checkIfServerSide)(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
     var lastProxyCheckTimestamp;
-    function splitChangesFetcher(since, noCache, till, rbSince, 
+    return function splitChangesFetcher(since, noCache, till, rbSince, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
         // Recheck proxy
@@ -39,7 +30,7 @@ function splitChangesFetcherFactory(params) {
             .catch(function (err) {
             // Handle proxy error with spec 1.3
             if ((!err.statusCode || err.statusCode === 400) && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === constants_1.FLAG_SPEC_VERSION) {
-                log.error(constants_2.LOG_PREFIX_SYNC + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
+                log.error(constants_2.LOG_PREFIX_SYNC_SPLITS + '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
@@ -52,27 +43,27 @@ function splitChangesFetcherFactory(params) {
             .then(function (resp) { return resp.json(); })
             .then(function (data) {
             // Using flag spec version 1.2 or below
-            if (isSplitChangesLegacyResponse(data)) {
-                return { d: partitionByStatus(data.splits || [], data.till, data.since) };
+            if (data.splits) {
+                return {
+                    ff: {
+                        d: data.splits,
+                        s: data.since,
+                        t: data.till
+                    }
+                };
             }
             // Proxy recovery
             if (lastProxyCheckTimestamp) {
-                log.info(constants_2.LOG_PREFIX_SYNC + 'Proxy error recovered');
+                log.info(constants_2.LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
                 lastProxyCheckTimestamp = undefined;
                 return splitChangesFetcher(-1, undefined, undefined, -1)
                     .then(function (splitChangesResponse) {
-                    return Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
+                    return Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
                         .then(function () { return splitChangesResponse; });
                 });
             }
-            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,
-            };
+            return data;
         });
-    }
-    splitChangesFetcher.type = 'feature flags';
-    return splitChangesFetcher;
+    };
 }
 exports.splitChangesFetcherFactory = splitChangesFetcherFactory;

package/cjs/sync/polling/pollingManagerCS.js

@@ -3,19 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pollingManagerCSFactory = void 0;
 var lang_1 = require("../../utils/lang");
 var mySegmentsSyncTask_1 = require("./syncTasks/mySegmentsSyncTask");
-var definitionsSyncTask_1 = require("./syncTasks/definitionsSyncTask");
+var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
-var AbstractDefinitionsCacheSync_1 = require("../../storages/AbstractDefinitionsCacheSync");
+var AbstractSplitsCacheSync_1 = require("../../storages/AbstractSplitsCacheSync");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-function pollingManagerCSFactory(params, definitionChangesFetcher) {
-    var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+function pollingManagerCSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings);
+    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings, true);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = (0, key_1.getMatching)(settings.core.key);
@@ -32,10 +32,10 @@ function pollingManagerCSFactory(params, definitionChangesFetcher) {
         });
     }
     // smart pausing
-    readiness.definitions.on(constants_1.SDK_DEFINITIONS_ARRIVED, function () {
-        if (!definitionsSyncTask.isRunning())
+    readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
+        if (!splitsSyncTask.isRunning())
             return; // noop if not doing polling
-        var usingSegments = (0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage);
+        var usingSegments = (0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage);
         if (usingSegments !== mySegmentsSyncTask.isRunning()) {
             log.info(constants_2.POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
             if (usingSegments) {
@@ -47,41 +47,41 @@ function pollingManagerCSFactory(params, definitionChangesFetcher) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady(metadata) {
-            if (!readiness.isReady() && !(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+            if (!readiness.isReady() && !(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                 readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
         }
-        if (!(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+        if (!(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
             setTimeout(smartReady, 0);
         else
-            readiness.definitions.once(constants_1.SDK_DEFINITIONS_ARRIVED, smartReady);
+            readiness.splits.once(constants_1.SDK_SPLITS_ARRIVED, smartReady);
         mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
         return mySegmentsSyncTask;
     }
     return {
-        definitionsSyncTask: definitionsSyncTask,
+        splitsSyncTask: splitsSyncTask,
         segmentsSyncTask: mySegmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(constants_2.POLLING_START);
-            definitionsSyncTask.start();
-            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+            splitsSyncTask.start();
+            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
             log.info(constants_2.POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
+            if (splitsSyncTask.isRunning())
+                splitsSyncTask.stop();
             stopMySegmentsSyncTasks();
         },
         // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        // fetch definitions and segments
+        isRunning: splitsSyncTask.isRunning,
+        // fetch splits and segments
         syncAll: function () {
-            var promises = [definitionsSyncTask.execute()];
+            var promises = [splitsSyncTask.execute()];
             (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
                 promises.push(mySegmentsSyncTask.execute());
             });

package/cjs/sync/polling/pollingManagerSS.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pollingManagerSSFactory = void 0;
-var definitionsSyncTask_1 = require("./syncTasks/definitionsSyncTask");
+var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var segmentsSyncTask_1 = require("./syncTasks/segmentsSyncTask");
 var constants_1 = require("../../logger/constants");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
-    var storage = params.storage, readiness = params.readiness, settings = params.settings;
+function pollingManagerSSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(splitApi.fetchSegmentChanges, storage, readiness, settings);
     return {
-        definitionsSyncTask: definitionsSyncTask,
+        splitsSyncTask: splitsSyncTask,
         segmentsSyncTask: segmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(constants_1.POLLING_START);
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
-            var startingUp = definitionsSyncTask.start();
+            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "Splits will be refreshed each ".concat(settings.scheduler.featuresRefreshRate, " millis"));
+            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "Segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
+            var startingUp = splitsSyncTask.start();
             if (startingUp) {
                 startingUp.then(function () {
-                    if (definitionsSyncTask.isRunning())
+                    if (splitsSyncTask.isRunning())
                         segmentsSyncTask.start();
                 });
             }
@@ -31,16 +31,16 @@ function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChange
         // Stop periodic fetching (polling)
         stop: function () {
             log.info(constants_1.POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
+            if (splitsSyncTask.isRunning())
+                splitsSyncTask.stop();
             if (segmentsSyncTask.isRunning())
                 segmentsSyncTask.stop();
         },
         // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
+        isRunning: splitsSyncTask.isRunning,
         syncAll: function () {
-            // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-            return definitionsSyncTask.execute().then(function () {
+            // fetch splits and segments. There is no need to catch this promise (`SplitChangesUpdater` is always resolved with a boolean value)
+            return splitsSyncTask.execute().then(function () {
                 return segmentsSyncTask.execute();
             });
         }

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

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentsSyncTaskFactory = void 0;
 var syncTask_1 = require("../../syncTask");
+var segmentChangesFetcher_1 = require("../fetchers/segmentChangesFetcher");
 var segmentChangesUpdater_1 = require("../updaters/segmentChangesUpdater");
 /**
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
-function segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, segmentChangesFetcher, storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+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.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }
 exports.segmentsSyncTaskFactory = segmentsSyncTaskFactory;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitsSyncTaskFactory = void 0;
+var syncTask_1 = require("../../syncTask");
+var splitChangesFetcher_1 = require("../fetchers/splitChangesFetcher");
+var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
+/**
+ * Creates a sync task that periodically executes a `splitChangesUpdater` task
+ */
+function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges, settings, storage), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+}
+exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

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

@@ -5,7 +5,7 @@ var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var constants_3 = require("../../streaming/constants");
-var AbstractDefinitionsCacheSync_1 = require("../../../storages/AbstractDefinitionsCacheSync");
+var AbstractSplitsCacheSync_1 = require("../../../storages/AbstractSplitsCacheSync");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -37,7 +37,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
         if (storage.save)
             storage.save();
         // Notify update if required
-        if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: constants_1.SEGMENTS_UPDATE, names: [] });
         }
@@ -56,7 +56,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
         return updaterPromise.catch(function (error) {
             if (startingUp && retriesOnFailureBeforeReady > retry) {
                 retry += 1;
-                log.warn(constants_2.SYNC_FETCH_RETRY, ['memberships', retry, error]);
+                log.warn(constants_2.SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
                 return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
             }
             else {

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

@@ -23,7 +23,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         return promise;
     }
     function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
-        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing segment ").concat(segmentName));
+        log.debug("".concat(constants_2.LOG_PREFIX_SYNC_SEGMENTS, "Processing segment ").concat(segmentName));
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
@@ -31,14 +31,14 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC_SEGMENTS, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(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("".concat(constants_2.LOG_PREFIX_SYNC, "Retrying fetch of segment ").concat(segmentName, " (attempt #").concat(retries, "). Reason: ").concat(error));
+                        log.warn("".concat(constants_2.LOG_PREFIX_SYNC_SEGMENTS, "Retrying fetch of segment ").concat(segmentName, " (attempt #").concat(retries, "). Reason: ").concat(error));
                         return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
                     }
                     throw error;
@@ -57,7 +57,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
      * @param till - till target for the provided segmentName, for CDN bypass.
      */
     return function segmentChangesUpdater(fetchOnlyNew, segmentName, noCache, till) {
-        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Started segments update"));
+        log.debug("".concat(constants_2.LOG_PREFIX_SYNC_SEGMENTS, "Started segments update"));
         // 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) {
@@ -66,7 +66,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    if (readiness && !fetchOnlyNew) {
+                    if (readiness) {
                         var metadata = {
                             type: constants_1.SEGMENTS_UPDATE,
                             names: []
@@ -87,7 +87,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 log.error("".concat(constants_2.LOG_PREFIX_INSTANTIATION, ": you passed a client-side type authorizationKey, please grab an SDK Key from Harness FME UI that is of type server-side."));
             }
             else {
-                log.warn("".concat(constants_2.LOG_PREFIX_SYNC, "Error while doing fetch of segments. ").concat(error));
+                log.warn("".concat(constants_2.LOG_PREFIX_SYNC_SEGMENTS, "Error while doing fetch of segments. ").concat(error));
             }
             return false;
         });