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

package/esm/services/serviceApi.js

@@ -1,26 +1,37 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { authProviderFactory } from './authProvider';
+import { secureSplitHttpClientFactory } from './secureSplitHttpClient';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
-function userKeyToQueryParam(userKey) {
-    return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
 /**
  * Factory of ServiceApi objects, which group the collection of HTTP endpoints used by the SDKs
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
  * @param telemetryTracker - telemetry tracker
- * @param secureSplitHttpClientFactory - factory of SecureSplitHttpClient objects
  */
-export function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
+export function serviceApiFactory(settings, platform, telemetryTracker) {
     var urls = settings.urls;
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform);
-    var secureSplitHttpClient = secureSplitHttpClientFactory(settings, platform, telemetryTracker);
+    // Shared authProvider so that the SSE authentication (via `fetchAuth`,
+    // used by `pushManager`) and every authenticated HTTP request to the Configs
+    // API reuse the same cached credential instead of each fetching their own.
+    var authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+    var secureSplitHttpClient = secureSplitHttpClientFactory(splitHttpClient, authProvider);
+    var initialAuth = true;
     return {
+        fetchAuth: function () {
+            // Guard condition to avoid invalidating the cached credential on the first pushManager authentication
+            if (initialAuth)
+                initialAuth = false;
+            else
+                authProvider.invalidate();
+            return authProvider.credential();
+        },
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/api/version");
@@ -30,15 +41,6 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
             var url = "".concat(urls.events, "/api/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
-        fetchAuth: function (userMatchingKeys) {
-            var url = "".concat(urls.auth, "/api/v2/auth?s=").concat(settings.sync.flagSpecVersion);
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-        },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
             var url = "".concat(urls.sdk, "/api/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
@@ -79,7 +81,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
          */
         postEventsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/events/bulk");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS), false, false, false);
         },
         /**
          * Post impressions.
@@ -89,12 +91,12 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
          */
         postTestImpressionsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/bulk");
-            return splitHttpClient(url, {
+            return secureSplitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
                 body: body,
                 headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(IMPRESSIONS));
+            }, telemetryTracker.trackHttp(IMPRESSIONS), false, false, false);
         },
         /**
          * Post impressions counts.
@@ -104,7 +106,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
          */
         postTestImpressionsCount: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/count");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT), false, false, false);
         },
         /**
          * Post unique keys for client side.
@@ -114,7 +116,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
          */
         postUniqueKeysBulkCs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/cs");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
         },
         /**
          * Post unique keys for server side.
@@ -124,7 +126,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker, secureSp
          */
         postUniqueKeysBulkSs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/ss");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
         },
         postMetricsConfig: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/metrics/config");

package/esm/services/splitApi.js

@@ -2,6 +2,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
@@ -20,6 +21,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform);
     return {
+        fetchAuth: fetchAuthFactory(function (userMatchingKeys) {
+            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
+            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
+                if (queryParams)
+                    url += '&' + queryParams;
+            }
+            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+        }),
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/version");
@@ -29,15 +39,6 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = "".concat(urls.events, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
-        fetchAuth: function (userMatchingKeys) {
-            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-        },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
             var url = "".concat(urls.sdk, "/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))

package/esm/storages/inRedis/RedisAdapter.js

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
 // Dynamically require ioredis to prevent strict TypeScript binding
-// and handle module export differences between v4 and v5.
+// and handle module export differences between v4 and later major versions.
 var RedisConstructor;
 try {
     var ioredisLib = require('ioredis');
@@ -8,7 +8,7 @@ try {
 }
 catch (e) {
     // If we reach here, the peer dependency is missing
-    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+    throw new Error('ioredis is missing. Please install ioredis v4, v5 or v6.');
 }
 import { merge, isString } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
@@ -28,13 +28,16 @@ var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
     lazyConnect: false,
-    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
-    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    // CRITICAL: v5 and v6 default this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 and v6 work like v4.
     slotsRefreshInterval: 5000,
+    // v6 defaults to RESP3 (`protocol: 3`). The SDK doesn't use any RESP3 feature,
+    // so we stick to RESP2 to keep the v4 and v5 behavior. Ignored by v4 and v5.
+    protocol: 2,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- * Refactored to use Composition instead of Inheritance to support both v4 and v5.
+ * Refactored to use Composition instead of Inheritance to support v4, v5 and v6.
  */
 var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {

package/esm/sync/polling/pollingManagerCS.js

@@ -5,92 +5,97 @@ import { getMatching } from '../../utils/key';
 import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export function pollingManagerCSFactory(params, definitionChangesFetcher) {
-    var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
-    // Map of matching keys to their corresponding MySegmentsSyncTask.
-    var mySegmentsSyncTasks = {};
-    var matchingKey = getMatching(settings.core.key);
-    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
-    function startMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            mySegmentsSyncTask.start();
-        });
-    }
-    function stopMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            if (mySegmentsSyncTask.isRunning())
-                mySegmentsSyncTask.stop();
-        });
-    }
-    // smart pausing
-    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
-        if (!definitionsSyncTask.isRunning())
-            return; // noop if not doing polling
-        var usingSegments = usesSegmentsSync(storage);
-        if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-            if (usingSegments) {
-                startMySegmentsSyncTasks();
-            }
-            else {
-                stopMySegmentsSyncTasks();
-            }
-        }
-    });
-    function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
-        // smart ready
-        function smartReady(metadata) {
-            if (!readiness.isReady() && !usesSegmentsSync(storage))
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+export function pollingManagerCSFactory(definitionFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
+    return function (params) {
+        var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
+        // Map of matching keys to their corresponding MySegmentsSyncTask.
+        var mySegmentsSyncTasks = {};
+        var matchingKey = getMatching(settings.core.key);
+        var mySegmentsSyncTask = add(matchingKey, readiness, storage);
+        function startMySegmentsSyncTasks() {
+            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                mySegmentsSyncTask.start();
+            });
         }
-        if (!usesSegmentsSync(storage))
-            setTimeout(smartReady, 0);
-        else
-            readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
-        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-        return mySegmentsSyncTask;
-    }
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: mySegmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(POLLING_START);
-            definitionsSyncTask.start();
-            if (usesSegmentsSync(storage))
-                startMySegmentsSyncTasks();
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            stopMySegmentsSyncTasks();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        // fetch definitions and segments
-        syncAll: function () {
-            var promises = [definitionsSyncTask.execute()];
+        function stopMySegmentsSyncTasks() {
             forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-                promises.push(mySegmentsSyncTask.execute());
+                if (mySegmentsSyncTask.isRunning())
+                    mySegmentsSyncTask.stop();
             });
-            return Promise.all(promises);
-        },
-        // Support for handling mySegments sync of multiple clients
-        add: add,
-        remove: function (matchingKey) {
-            delete mySegmentsSyncTasks[matchingKey];
-        },
-        get: function (matchingKey) {
-            return mySegmentsSyncTasks[matchingKey];
         }
+        // smart pausing
+        readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
+            if (!definitionsSyncTask.isRunning())
+                return; // noop if not doing polling
+            var usingSegments = usesSegmentsSync(storage);
+            if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+                log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+                if (usingSegments) {
+                    startMySegmentsSyncTasks();
+                }
+                else {
+                    stopMySegmentsSyncTasks();
+                }
+            }
+        });
+        function add(matchingKey, readiness, storage) {
+            var mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+            // smart ready
+            function smartReady(metadata) {
+                if (!readiness.isReady() && !usesSegmentsSync(storage))
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+            }
+            if (!usesSegmentsSync(storage))
+                setTimeout(smartReady, 0);
+            else
+                readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
+            mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+            return mySegmentsSyncTask;
+        }
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: mySegmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(POLLING_START);
+                definitionsSyncTask.start();
+                if (usesSegmentsSync(storage))
+                    startMySegmentsSyncTasks();
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                stopMySegmentsSyncTasks();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            // fetch definitions and segments
+            syncAll: function () {
+                var promises = [definitionsSyncTask.execute()];
+                forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                    promises.push(mySegmentsSyncTask.execute());
+                });
+                return Promise.all(promises);
+            },
+            // Support for handling mySegments sync of multiple clients
+            add: add,
+            remove: function (matchingKey) {
+                delete mySegmentsSyncTasks[matchingKey];
+            },
+            get: function (matchingKey) {
+                return mySegmentsSyncTasks[matchingKey];
+            }
+        };
     };
 }

package/esm/sync/polling/pollingManagerSS.js

@@ -1,45 +1,53 @@
 import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
+import { segmentChangesFetcherFactory } from './fetchers/segmentChangesFetcher';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
-    var storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
-    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: segmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(POLLING_START);
-            log.debug(LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
-            log.debug(LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
-            var startingUp = definitionsSyncTask.start();
-            if (startingUp) {
-                startingUp.then(function () {
-                    if (definitionsSyncTask.isRunning())
-                        segmentsSyncTask.start();
+export function pollingManagerSSFactory(definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
+    return function (params) {
+        var storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var segmentChangesFetcher = segmentFetcherFactory(params);
+        var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+        var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: segmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(POLLING_START);
+                log.debug(LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
+                log.debug(LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
+                var startingUp = definitionsSyncTask.start();
+                if (startingUp) {
+                    startingUp.then(function () {
+                        if (definitionsSyncTask.isRunning())
+                            segmentsSyncTask.start();
+                    });
+                }
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                if (segmentsSyncTask.isRunning())
+                    segmentsSyncTask.stop();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.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 () {
+                    return segmentsSyncTask.execute();
                 });
             }
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            if (segmentsSyncTask.isRunning())
-                segmentsSyncTask.stop();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.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 () {
-                return segmentsSyncTask.execute();
-            });
-        }
+        };
     };
 }

package/esm/sync/polling/updaters/definitionChangesUpdater.js

@@ -4,7 +4,7 @@ import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_FETCH_RETRY } from '../
 import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
+import { RB_SEGMENT_UPDATE } from '../../streaming/constants';
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -120,14 +120,14 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
             var since = sinces[0], rbSince = sinces[1];
             log.debug(SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
             return Promise.resolve(instantUpdate ?
-                instantUpdate.type === SPLIT_UPDATE ?
+                instantUpdate.type === RB_SEGMENT_UPDATE ?
+                    { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                     // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
                     Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then(function (contains) {
                         return contains ?
                             { d: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                             definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
                     }) :
-                    { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                 definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (definitionChanges) {
                 var usedSegments = new Set();

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

@@ -28,7 +28,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with since = ").concat(x.since, " and 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; });

package/esm/sync/streaming/AuthClient/index.js

@@ -1,13 +1,11 @@
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { encodeToBase64 } from '../../../utils/base64';
 import { decodeJWTtoken } from '../../../utils/jwt';
-import { hash } from '../../../utils/murmur3/murmur3';
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth - `ServiceApi.fetchAuth` endpoint
+ * @param fetchAuth - /auth endpoint
  */
-export function authenticateFactory(fetchAuth) {
+export function fetchAuthFactory(fetchAuth) {
     /**
      * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
      * @param userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
@@ -21,18 +19,20 @@ export function authenticateFactory(fetchAuth) {
                 if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number')
                     throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
                 var channels = JSON.parse(decodedToken['x-ably-capability']);
-                return objectAssign({
+                var credential = objectAssign({
                     decodedToken: decodedToken,
                     channels: channels
                 }, json);
+                // The `/api/v3/auth` endpoint nests the streaming settings under `config.streaming`. Normalize
+                // them into the flat `pushEnabled`/`connDelay` properties used by the PushManager.
+                var streaming = credential.config && credential.config.streaming;
+                if (streaming) {
+                    credential.pushEnabled = streaming.enabled;
+                    credential.connDelay = streaming.delay;
+                }
+                return credential;
             }
             return json;
         });
     };
 }
-/**
- * Returns the hash of a given user key
- */
-export function hashUserKey(userKey) {
-    return encodeToBase64(hash(userKey, 0).toString());
-}

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -71,6 +71,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
+                case CONFIG_UPDATE:
                 case SEGMENT_UPDATE:
                 case MEMBERSHIPS_MS_UPDATE:
                 case MEMBERSHIPS_LS_UPDATE:

package/esm/sync/streaming/constants.js

@@ -27,6 +27,7 @@ export var MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';
+export var CONFIG_UPDATE = 'CONFIG_UPDATE';
 export var RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 export var CONTROL = 'CONTROL';

package/esm/sync/streaming/pushManager.js

@@ -4,11 +4,10 @@ import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
 import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
-import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
@@ -34,7 +33,6 @@ export function pushManagerFactory(params, pollingManager) {
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(serviceApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
@@ -44,8 +42,6 @@ export function pushManagerFactory(params, pollingManager) {
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
     var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
-    // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
-    var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
@@ -90,7 +86,7 @@ export function pushManagerFactory(params, pollingManager) {
         log.info(STREAMING_CONNECTING);
         disconnected = false;
         var userKeys = userKey ? Object.keys(clients) : undefined;
-        authenticate(userKeys).then(function (authData) {
+        serviceApi.fetchAuth(userKeys).then(function (authData) {
             if (disconnected)
                 return;
             // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
@@ -178,8 +174,11 @@ export function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
+    // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+    // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
     pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
     pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(CONFIG_UPDATE, definitionsUpdateWorker.put);
     pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
@@ -282,9 +281,7 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var hash = hashUserKey(userKey);
-            if (!userKeyHashes[hash]) {
-                userKeyHashes[hash] = userKey;
+            if (!clients[userKey]) {
                 clients[userKey] = {
                     hash64: hash64(userKey),
                     worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -305,8 +302,6 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = hashUserKey(userKey);
-            delete userKeyHashes[hash];
             delete clients[userKey];
         }
     });