@splitsoftware/splitio-commons 3.1.1-rc.4 → 3.1.1-rc.6

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/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];
         }
     });

package/esm/sync/submitters/submitterManager.js

@@ -3,40 +3,63 @@ import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
-export function submitterManagerFactory(params) {
-    var submitters = [
-        impressionsSubmitterFactory(params),
-        eventsSubmitterFactory(params),
-        impressionCountsSubmitterFactory(params),
-        uniqueKeysSubmitterFactory(params)
-    ];
-    var telemetrySubmitter = telemetrySubmitterFactory(params);
-    return {
-        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
-        start: function (onlyTelemetry) {
+import { SDK_READY } from '../../readiness/constants';
+/**
+ * Creates a submitter manager.
+ *
+ * @param startWhenReady - If true, the submitters will only start and execute the underlying submitters when the SDK is ready.
+ * `true` for Configs SDK, `false` for Flags SDKs.
+ */
+export function submitterManagerFactory(startWhenReady) {
+    return function (params) {
+        var readiness = params.readiness;
+        var submitters = [
+            impressionsSubmitterFactory(params),
+            eventsSubmitterFactory(params),
+            impressionCountsSubmitterFactory(params),
+            uniqueKeysSubmitterFactory(params)
+        ];
+        var telemetrySubmitter = telemetrySubmitterFactory(params);
+        var isRunning = false;
+        function startSubmitters(onlyTelemetry) {
+            if (!isRunning)
+                return;
             if (!onlyTelemetry)
                 submitters.forEach(function (submitter) { return submitter.start(); });
             if (telemetrySubmitter)
                 telemetrySubmitter.start();
-        },
-        // `allExceptTelemetry` true if userConsent is changed to DECLINED
-        stop: function (allExceptTelemetry) {
-            submitters.forEach(function (submitter) { return submitter.stop(); });
-            if (!allExceptTelemetry && telemetrySubmitter)
-                telemetrySubmitter.stop();
-        },
-        isRunning: function () {
-            return submitters.some(function (submitter) { return submitter.isRunning(); });
-        },
-        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
-        execute: function (onlyTelemetry) {
-            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
-            if (telemetrySubmitter)
-                promises.push(telemetrySubmitter.execute());
-            return Promise.all(promises).then(function () { });
-        },
-        isExecuting: function () {
-            return submitters.some(function (submitter) { return submitter.isExecuting(); });
         }
+        return {
+            // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+            start: function (onlyTelemetry) {
+                isRunning = true;
+                if (!startWhenReady || readiness.isReady())
+                    startSubmitters(onlyTelemetry);
+                else
+                    readiness.gate.once(SDK_READY, function () { return startSubmitters(onlyTelemetry); });
+            },
+            // `allExceptTelemetry` true if userConsent is changed to DECLINED
+            stop: function (allExceptTelemetry) {
+                isRunning = false;
+                submitters.forEach(function (submitter) { return submitter.stop(); });
+                if (!allExceptTelemetry && telemetrySubmitter)
+                    telemetrySubmitter.stop();
+            },
+            isRunning: function () {
+                return isRunning;
+            },
+            // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+            execute: function (onlyTelemetry) {
+                if (startWhenReady && !readiness.isReady())
+                    return Promise.resolve();
+                var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
+                if (telemetrySubmitter)
+                    promises.push(telemetrySubmitter.execute());
+                return Promise.all(promises).then(function () { });
+            },
+            isExecuting: function () {
+                return submitters.some(function (submitter) { return submitter.isExecuting(); });
+            }
+        };
     };
 }

package/esm/sync/syncManagerOnline.js

@@ -12,8 +12,10 @@ import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
  * @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 submitterManagerFactory - specify the submitter manager factory to use
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, _submitterManagerFactory) {
+    if (_submitterManagerFactory === void 0) { _submitterManagerFactory = submitterManagerFactory(); }
     /**
      * SyncManager factory for modular SDK
      */
@@ -27,7 +29,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             undefined;
         /** Submitter Manager */
         // It is not injected as push and polling managers, because at the moment it is required
-        var submitterManager = submitterManagerFactory(params);
+        var submitterManager = _submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.4",
+  "version": "3.1.1-rc.6",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/presets/serverSide.ts

@@ -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';
@@ -11,7 +11,7 @@ const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFact
 
 export const serverSideModules = {
   storageFactory: InMemoryStorageFactory,
-  serviceApiFactory,
+  serviceApiFactory: splitApiFactory,
   syncManagerFactory: syncManagerOnlineSSFactory,
   sdkManagerFactory,
   sdkClientMethodFactory,

package/src/services/authProvider.ts

@@ -1,6 +1,6 @@
 import { ISplitHttpClient, NetworkError } from './types';
-import { IJwtCredentialV3 } from '../sync/streaming/AuthClient/types';
-import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { IJwtCredential } from '../sync/streaming/AuthClient/types';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { ISettings } from '../types';
@@ -9,12 +9,20 @@ import { ITelemetryTracker } from '../trackers/types';
 
 const SKEW_SECONDS = 30;
 
-function isExpired(credential: IJwtCredentialV3): boolean {
+function isExpired(credential: IJwtCredential): boolean {
   return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
 }
 
 export interface IAuthProvider {
-  credential(): Promise<IJwtCredentialV3>;
+  /**
+   * Returns the cached credential, or fetches a new one if there isn't one cached or it's expired,
+   * retrying with backoff on recoverable errors. Used by `secureSplitHttpClient` and `serviceApi.fetchAuth`.
+   */
+  credential(): Promise<IJwtCredential>;
+  /**
+   * Invalidates/clears the cached credential. Used by `secureSplitHttpClient` in the special case of 401 error,
+   * and by `serviceApi.fetchAuth` to force a credential/token refresh.
+   */
   invalidate(): void;
   stop(): void;
 }
@@ -27,20 +35,18 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
 
   const { urls, log } = settings;
 
-  function fetchAuth() {
+  const fetchAuth = fetchAuthFactory(() => {
     let url = `${urls.auth}/api/v3/auth?capabilities=config,aiconfig`;
     return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
-  }
-
-  const authenticate = authenticateFactory(fetchAuth);
+  });
   const backoff = new Backoff(fetchCredential);
 
-  let cachedCredential: IJwtCredentialV3 | undefined;
-  let inFlightPromise: Promise<IJwtCredentialV3> | undefined;
+  let cachedCredential: IJwtCredential | undefined;
+  let inFlightPromise: Promise<IJwtCredential> | undefined;
   let stopped = false;
 
-  function fetchCredential(): Promise<IJwtCredentialV3> {
-    return authenticate().then((credential: IJwtCredentialV3) => {
+  function fetchCredential(): Promise<IJwtCredential> {
+    return fetchAuth().then((credential: IJwtCredential) => {
       log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
       cachedCredential = credential;
       inFlightPromise = undefined;
@@ -62,7 +68,7 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
   }
 
   return {
-    credential(): Promise<IJwtCredentialV3> {
+    credential(): Promise<IJwtCredential> {
       if (cachedCredential && !isExpired(cachedCredential)) {
         return Promise.resolve(cachedCredential);
       }

package/src/services/secureSplitHttpClient.ts

@@ -1,22 +1,14 @@
-import { IRequestOptions, IResponse, ISecureSplitHttpClient, NetworkError } from './types';
-import { ISettings } from '../types';
-import { IPlatform } from '../sdkFactory/types';
-import { splitHttpClientFactory } from './splitHttpClient';
-import { authProviderFactory } from './authProvider';
-import { ITelemetryTracker } from '../trackers/types';
+import { IRequestOptions, IResponse, ISecureSplitHttpClient, ISplitHttpClient, NetworkError } from './types';
+import { IAuthProvider } 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: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISecureSplitHttpClient {
-
-  const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+export function secureSplitHttpClientFactory(splitHttpClient: ISplitHttpClient, authProvider: IAuthProvider): ISecureSplitHttpClient {
 
   function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker: ((error?: NetworkError) => void) | undefined, logErrorsAsInfo: boolean | undefined, token: string): Promise<IResponse> {
     return splitHttpClient(url, { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } }, latencyTracker, logErrorsAsInfo, true);

package/src/services/serviceApi.ts

@@ -1,40 +1,52 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
-import { ISecureSplitHttpClient, IServiceApi } from './types';
+import { IServiceApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-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';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
-function userKeyToQueryParam(userKey: string) {
-  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: ISettings,
   platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
   telemetryTracker: ITelemetryTracker,
-  secureSplitHttpClientFactory?: (settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker) => ISecureSplitHttpClient,
 ): IServiceApi {
 
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
+
   const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const 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.
+  const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+  const secureSplitHttpClient = secureSplitHttpClientFactory(splitHttpClient, authProvider);
+
+  let initialAuth = true;
 
   return {
+    fetchAuth() {
+      // 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() {
       const url = `${urls.sdk}/api/version`;
@@ -46,15 +58,6 @@ export function serviceApiFactory(
       return splitHttpClient(url).then(() => true).catch(() => false);
     },
 
-    fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/api/v2/auth?s=${settings.sync.flagSpecVersion}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
-      }
-      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-    },
-
     fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
       const url = `${urls.sdk}/api/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))

package/src/services/splitApi.ts

@@ -6,6 +6,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 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';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -33,6 +34,15 @@ export function splitApiFactory(
   const splitHttpClient = splitHttpClientFactory(settings, platform);
 
   return {
+    fetchAuth: fetchAuthFactory((userMatchingKeys?: string[]) => {
+      let url = `${urls.auth}/v2/auth?s=${settings.sync.flagSpecVersion}`;
+      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+        const 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() {
       const url = `${urls.sdk}/version`;
@@ -44,15 +54,6 @@ export function splitApiFactory(
       return splitHttpClient(url).then(() => true).catch(() => false);
     },
 
-    fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/v2/auth?s=${settings.sync.flagSpecVersion}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
-      }
-      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-    },
-
     fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
       const url = `${urls.sdk}/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))

package/src/services/types.ts

@@ -1,3 +1,5 @@
+import { IFetchAuth } from '../sync/streaming/AuthClient/types';
+
 export type IRequestOptions = {
 	method?: string,
 	headers?: Record<string, string>,
@@ -35,8 +37,6 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
 
-export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
-
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>

package/src/sync/polling/updaters/definitionChangesUpdater.ts

@@ -9,7 +9,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';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
 import { ISplit } from '../fetchers/splitChangesFetcher';
 import { ISegmentsSyncTask } from '../types';
@@ -154,14 +154,14 @@ export function definitionChangesUpdaterFactory(
 
       return Promise.resolve(
         instantUpdate ?
-          instantUpdate.type === SPLIT_UPDATE ?
+          instantUpdate.type === RB_SEGMENT_UPDATE ?
+            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
             // 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((contains) => {
               return contains ?
                 { d: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['d'] } :
                 definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
             }) :
-            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
           definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
         .then((definitionChanges: IDefinitionChangesResponse) => {

package/src/sync/streaming/AuthClient/index.ts

@@ -1,22 +1,20 @@
-import { IFetchAuth } from '../../../services/types';
-import { IAuthenticate, IJwtCredentialV2 } from './types';
+import { IJwtCredential, IFetchAuth } from './types';
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { encodeToBase64 } from '../../../utils/base64';
 import { decodeJWTtoken } from '../../../utils/jwt';
-import { hash } from '../../../utils/murmur3/murmur3';
+import { IResponse } from '../../../services/types';
 
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth - `ServiceApi.fetchAuth` endpoint
+ * @param fetchAuth - /auth endpoint
  */
-export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
+export function fetchAuthFactory(fetchAuth: (userKeys?: string[]) => Promise<IResponse>): IFetchAuth {
 
   /**
    * 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.
    */
-  return function authenticate(userKeys?: string[]): Promise<IJwtCredentialV2> {
+  return function authenticate(userKeys?: string[]): Promise<IJwtCredential> {
     return fetchAuth(userKeys)
       .then(resp => resp.json())
       .then(json => {
@@ -24,19 +22,20 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
           const decodedToken = decodeJWTtoken(json.token);
           if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
           const channels = JSON.parse(decodedToken['x-ably-capability']);
-          return objectAssign({
+          const credential = objectAssign({
             decodedToken,
             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.
+          const 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: string): string {
-  return encodeToBase64(hash(userKey, 0).toString());
-}