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

package/esm/sync/submitters/impressionsSubmitter.js

@@ -20,7 +20,7 @@ export function fromImpressionsCollector(sendLabels, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
                     et: entry.entityType, // Definition type
                 };
             })

package/esm/sync/syncManagerOnline.js

@@ -5,8 +5,6 @@ import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
-import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -14,18 +12,15 @@ import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesF
  * @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
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
+export 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/utils/Backoff.js

@@ -1,6 +1,7 @@
 var Backoff = /** @class */ (function () {
     /**
-     * Schedule function calls with exponential backoff
+     * Schedule function calls with exponential backoff.
+     * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
      */
     function Backoff(cb, baseMillis, maxMillis) {
         this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -17,11 +18,11 @@ var Backoff = /** @class */ (function () {
         var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
+        this.attempts++;
         this.timeoutID = setTimeout(function () {
             _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
-        this.attempts++;
         return delayInMillis;
     };
     /**
@@ -35,21 +36,32 @@ var Backoff = /** @class */ (function () {
             clearTimeout(this.timeoutID);
         this.attempts++;
         return new Promise(function (resolve, reject) {
+            _this.pending = { resolve: resolve, reject: reject };
             _this.timeoutID = setTimeout(function () {
                 _this.timeoutID = undefined;
+                _this.pending = undefined;
                 _this.cb().then(resolve, reject);
             }, delayInMillis);
         });
     };
     /**
-     * Reset the backoff attempts
+     * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending
+     * and the caller wants to settle it immediately instead of waiting for `cb` to be invoked, pass `settle`:
+     * `{ value }` to resolve, or `{ error }` to reject.
      */
-    Backoff.prototype.reset = function () {
+    Backoff.prototype.reset = function (settle) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (settle && this.pending) {
+            if ('value' in settle)
+                this.pending.resolve(settle.value);
+            else
+                this.pending.reject(settle.error);
+            this.pending = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.1",
+  "version": "3.1.1-rc.11",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -20,8 +20,8 @@
     "check:lint": "eslint src types --ext .js,.ts",
     "check:types": "tsc --noEmit",
     "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm",
-    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
+    "build:esm": "rimraf esm && tsc -p tsconfig.build.json -m es2015 --outDir esm",
+    "build:cjs": "rimraf cjs && tsc -p tsconfig.build.json -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",
@@ -45,12 +45,12 @@
   "bugs": "https://github.com/splitio/javascript-commons/issues",
   "homepage": "https://github.com/splitio/javascript-commons#readme",
   "dependencies": {
-    "@types/ioredis": "^4.28.0",
+    "@types/node": ">=14.0.0",
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
     "bloom-filters": "^3.0.0",
-    "ioredis": "^4.28.0 || ^5.0.0",
+    "ioredis": "^4.28.0 || ^5.0.0 || ^6.0.0",
     "node-fetch": "^2.7.0"
   },
   "peerDependenciesMeta": {
@@ -65,7 +65,6 @@
     }
   },
   "devDependencies": {
-    "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
@@ -77,7 +76,7 @@
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-tsdoc": "^0.3.0",
     "fetch-mock": "^9.11.0",
-    "ioredis": "^5.0.0",
+    "ioredis": "^6.0.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "lodash": "^4.17.21",

package/src/dtos/types.ts

@@ -236,7 +236,7 @@ export interface IDefinition extends TargetingEntity {
   } | null;
   /** Definition classification. Absent means a feature flag. */
   type?: ConfigType;
-  /** Only meaningful when `type === 'AI'`. */
+  /** Only meaningful when `type === 'ai'`. */
   subtype?: ConfigSubtype;
 }
 

package/src/evaluator/index.ts

@@ -31,6 +31,13 @@ function treatmentsException(definitionNames: string[]) {
   return evaluations;
 }
 
+function setEvaluationDataFromDefinition(evaluation: IEvaluation, definition: IDefinition): IEvaluation {
+  return objectAssign(evaluation, {
+    definition,
+    config: definition.configurations && definition.configurations[evaluation.treatment] || null
+  });
+}
+
 export function evaluateFeature(
   log: ILogger,
   key: SplitIO.SplitKey,
@@ -137,8 +144,8 @@ function getEvaluation(
     const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
     return thenable(evaluation) ?
-      evaluation.then(result => objectAssign(result, { definition })) :
-      objectAssign(evaluation, { definition });
+      evaluation.then(result => setEvaluationDataFromDefinition(result, definition)) :
+      setEvaluationDataFromDefinition(evaluation, definition);
   }
 
   return EVALUATION_DEFINITION_NOT_FOUND;
@@ -187,11 +194,10 @@ function getDefaultTreatment(
   definition: IDefinition | null,
 ): MaybeThenable<IEvaluation> {
   if (definition) {
-    return {
+    return setEvaluationDataFromDefinition({
       treatment: definition.defaultTreatment,
       label: NO_CONDITION_MATCH, // "default rule"
-      definition,
-    };
+    }, definition);
   }
 
   return EVALUATION_DEFINITION_NOT_FOUND;

package/src/evaluator/types.ts

@@ -22,6 +22,7 @@ export interface IEvaluation {
   treatment: string,
   label: string,
   definition?: IDefinition
+  config?: string | null | SplitIO.JsonObject
 }
 
 export type IDefinitionEvaluator = (log: ILogger, key: SplitIO.SplitKey, definitionName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>

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';
@@ -7,11 +7,11 @@ import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
 
-const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 
 export const serverSideModules = {
   storageFactory: InMemoryStorageFactory,
-  serviceApiFactory,
+  serviceApiFactory: splitApiFactory,
   syncManagerFactory: syncManagerOnlineSSFactory,
   sdkManagerFactory,
   sdkClientMethodFactory,

package/src/sdkClient/client.ts

@@ -142,8 +142,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const bucketingKey = getBucketing(key);
 
     const { definition } = evaluation;
-    let { treatment, label } = evaluation;
-    let config = definition?.configurations?.[treatment] || null;
+    let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
       const fallbackTreatment = fallbackCalculator(featureFlagName, label);
@@ -162,10 +161,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
           time: Date.now(),
           bucketingKey,
           label,
-          changeNumber: definition!.changeNumber,
+          changeNumber: definition?.changeNumber,
           properties: stringify(options.properties)
         }, // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        disabled: options.impressionsDisabled || definition!.impressionsDisabled
+        disabled: options.impressionsDisabled || definition?.impressionsDisabled
       });
     }
 

package/src/sdkClient/sdkLifecycle.ts

@@ -69,6 +69,9 @@ export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?:
 
       // Stop background jobs
       syncManager && syncManager.stop();
+
+      // Stop the service API (the auth provider backoff retries specifically) before flushing,
+      // so that a pending/never-resolved auth retry doesn't block the flush forever
       serviceApi && serviceApi.stop();
 
       return __flush().then(() => {

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,24 @@ 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;
 }
 
+function noCachedCredentialError() {
+  return new Error(LOG_PREFIX_SYNC_AUTH + 'stopped without a cached credential');
+}
+
 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,28 +39,27 @@ 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;
       backoff.reset();
       return credential;
     }).catch((error: NetworkError) => {
-      // Avoid rejected promises and unnecessary retries after stop()
-      if (stopped) return cachedCredential!;
+      // Avoid unnecessary retries after stop(): fall back to any cached credential, or reject
+      // (never resolve with `undefined`, which callers would otherwise send as an unauthenticated request).
+      if (stopped) return cachedCredential || Promise.reject(noCachedCredentialError());
 
       if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
         log.error(LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
@@ -62,14 +73,24 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
   }
 
   return {
-    credential(): Promise<IJwtCredentialV3> {
+    credential(): Promise<IJwtCredential> {
       if (cachedCredential && !isExpired(cachedCredential)) {
         return Promise.resolve(cachedCredential);
       }
 
+      // Reuse any fetch already in flight (e.g. one started just before stop()), instead of firing a redundant one.
+      if (inFlightPromise) return inFlightPromise;
+
+      // No cached credential to fall back to and stopped: reject so callers don't send an unauthenticated request.
+      if (stopped && !cachedCredential) {
+        return Promise.reject(noCachedCredentialError());
+      }
+
       if (cachedCredential) log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
 
-      return inFlightPromise || (inFlightPromise = fetchCredential());
+      // If stopped, this is a last, bounded refetch: fetchCredential()'s catch short-circuits (no backoff retry)
+      // once stopped, so it's a single attempt that falls back to the stale cached credential on failure.
+      return inFlightPromise = fetchCredential();
     },
 
     invalidate() {
@@ -78,9 +99,10 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
 
     stop() {
       stopped = true;
-      cachedCredential = undefined;
-      inFlightPromise = undefined;
-      backoff.reset();
+      // Keep any in-flight fetch and already-cached credential usable (e.g. by a final flush on destroy).
+      // If a retry is only pending (not actively in flight), settle it immediately instead of waiting out the
+      // backoff delay: with the cached credential if there is one, or rejected otherwise.
+      backoff.reset(cachedCredential ? { value: cachedCredential } : { error: noCachedCredentialError() });
     }
   };
 }

package/src/services/secureSplitHttpClient.ts

@@ -1,36 +1,28 @@
-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 {
+export function secureSplitHttpClientFactory(splitHttpClient: ISplitHttpClient, authProvider: IAuthProvider): ISecureSplitHttpClient {
 
-  const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
-
-  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);
+  function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean, token?: string): Promise<IResponse> {
+    return splitHttpClient(url, token ? { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } } : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
   }
 
-  const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean): Promise<IResponse> {
+  const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader = true, useJwt = true): Promise<IResponse> {
     return authProvider.credential().then(credential => {
-      return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+      return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
         .catch((error: NetworkError) => {
           if (error.statusCode === 401) {
             // retry once for 401, in case the token has just expired
             authProvider.invalidate();
             return authProvider.credential().then(newCredential => {
-              return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+              return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
             });
           }
           throw error;

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))
@@ -99,7 +102,7 @@ export function serviceApiFactory(
      */
     postEventsBulk(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/api/events/bulk`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS), false, false, false);
     },
 
     /**
@@ -110,10 +113,10 @@ export function serviceApiFactory(
      */
     postTestImpressionsBulk(body: string, headers?: Record<string, string>) {
       const url = `${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, headers: objectAssign({ SplitSDKImpressionsMode }, headers)
-      }, telemetryTracker.trackHttp(IMPRESSIONS));
+      }, telemetryTracker.trackHttp(IMPRESSIONS), false, false, false);
     },
 
     /**
@@ -124,7 +127,7 @@ export function serviceApiFactory(
      */
     postTestImpressionsCount(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/api/testImpressions/count`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT), false, false, false);
     },
 
     /**
@@ -135,7 +138,7 @@ export function serviceApiFactory(
      */
     postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/api/v1/keys/cs`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
     },
 
     /**
@@ -146,7 +149,7 @@ export function serviceApiFactory(
      */
     postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/api/v1/keys/ss`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
     },
 
     postMetricsConfig(body: string, headers?: Record<string, string>) {

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>,
@@ -33,9 +35,8 @@ export type IHealthCheckAPI = () => Promise<boolean>
 
 export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean) => Promise<IResponse>
 
-export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
-
-export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
+// @TODO: remove `newVersionHeader` and `useJwt` arguments when all service endpoints are migrated to the new auth mechanism
+export type ISecureSplitHttpClient = ((url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean, useJwt?: boolean) => Promise<IResponse>) & { stop(): void }
 
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
@@ -73,7 +74,7 @@ export interface IServiceApi {
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig
 	postMetricsUsage: IPostMetricsUsage
-	// lifecycle
+	// lifecycle: stops authProvider backoff retries
 	stop(): void
 }