@splitsoftware/splitio-commons 3.1.1-rc.3 → 3.1.1-rc.5

package/cjs/sync/syncManagerOnline.js

@@ -8,8 +8,6 @@ var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
 var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCacheSync");
-var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
-var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -17,18 +15,15 @@ var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher"
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
     return function (params) {
         var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :

package/esm/presets/serverSide.js

@@ -1,4 +1,4 @@
-import { serviceApiFactory } from '../services/serviceApi';
+import { splitApiFactory } from '../services/splitApi';
 import { syncManagerOnlineFactory } from '../sync/syncManagerOnline';
 import { pushManagerFactory } from '../sync/streaming/pushManager';
 import { pollingManagerSSFactory } from '../sync/polling/pollingManagerSS';
@@ -6,10 +6,10 @@ import { InMemoryStorageFactory } from '../storages/inMemory/InMemoryStorage';
 import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
-var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 export var serverSideModules = {
     storageFactory: InMemoryStorageFactory,
-    serviceApiFactory: serviceApiFactory,
+    serviceApiFactory: splitApiFactory,
     syncManagerFactory: syncManagerOnlineSSFactory,
     sdkManagerFactory: sdkManagerFactory,
     sdkClientMethodFactory: sdkClientMethodFactory,

package/esm/services/authProvider.js

@@ -1,4 +1,4 @@
-import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { TOKEN } from '../utils/constants';
@@ -12,17 +12,16 @@ function isExpired(credential) {
  */
 export function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
     var urls = settings.urls, log = settings.log;
-    function fetchAuth() {
+    var fetchAuth = fetchAuthFactory(function () {
         var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
         return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
-    }
-    var authenticate = authenticateFactory(fetchAuth);
+    });
     var backoff = new Backoff(fetchCredential);
     var cachedCredential;
     var inFlightPromise;
     var stopped = false;
     function fetchCredential() {
-        return authenticate().then(function (credential) {
+        return fetchAuth().then(function (credential) {
             log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
             cachedCredential = credential;
             inFlightPromise = undefined;

package/esm/services/secureSplitHttpClient.js

@@ -1,17 +1,12 @@
 import { __assign } from "tslib";
-import { splitHttpClientFactory } from './splitHttpClient';
-import { authProviderFactory } from './authProvider';
 /**
  * Factory of Secure HTTP client, which authenticates requests using a JWT token.
  * On 401 responses, invalidates the cached credential and retries once with a fresh token.
  *
- * @param settings - SDK settings
- * @param platform - object containing environment-specific dependencies
- * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
+ * @param splitHttpClient - `splitHttpClientFactory` to use for making requests
+ * @param authProvider - `authProviderFactory` to use for authentication
  */
-export function secureSplitHttpClientFactory(settings, platform, telemetryTracker) {
-    var splitHttpClient = splitHttpClientFactory(settings, platform);
-    var authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+export function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
     function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
         return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
     }

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))

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/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';