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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.0",
+  "version": "3.1.1-rc.10",
   "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/Engine.ts

@@ -7,12 +7,12 @@ import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import SplitIO from '../../types/splitio';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, IDefinitionEvaluator } from './types';
+import { IEvaluation, IDefinitionEvaluator } from './types';
 import { ILogger } from '../logger/types';
 import { ENGINE_DEFAULT } from '../logger/constants';
 import { prerequisitesMatcherContext } from './matchers/prerequisites';
 
-function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
+function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluation {
   return {
     treatment: get(result, 'treatment', defaultTreatment),
     label: get(result, 'label', NO_CONDITION_MATCH)
@@ -29,7 +29,7 @@ export function engineParser(log: ILogger, split: IDefinition, storage: IStorage
 
   return {
 
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluationResult> {
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluation> {
 
       const parsedKey = keyParser(key);
 

package/src/evaluator/condition/index.ts

@@ -29,9 +29,9 @@ export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.S
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
     if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!)) {
       return {
-        treatment: undefined, // treatment value is assigned later
+        // treatment value is assigned later, at Engine's evaluationResult
         label: NOT_IN_SPLIT
-      };
+      } as IEvaluation;
     }
 
     // matcherEvaluator could be Async, this relays on matchers return value, so we need

package/src/evaluator/index.ts

@@ -4,11 +4,12 @@ import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/la
 import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluationResult } from './types';
+import { IEvaluation } from './types';
 import SplitIO from '../../types/splitio';
 import { ILogger } from '../logger/types';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 const EVALUATION_EXCEPTION = {
   treatment: CONTROL,
@@ -23,21 +24,27 @@ const EVALUATION_DEFINITION_NOT_FOUND = {
 };
 
 function treatmentsException(definitionNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   definitionNames.forEach(definitionName => {
     evaluations[definitionName] = EVALUATION_EXCEPTION;
   });
   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,
   definitionName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -48,13 +55,13 @@ export function evaluateFeature(
   }
 
   return thenable(definition) ?
-    definition.then((definition) => getEvaluation(log, key, definition, attributes, storage, options))
+    definition.then((definition) => getEvaluation(log, key, definition, attributes, storage))
       .catch(
         // Exception on async storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         () => EVALUATION_EXCEPTION
       ) :
-    getEvaluation(log, key, definition, attributes, storage, options);
+    getEvaluation(log, key, definition, attributes, storage);
 }
 
 export function evaluateFeatures(
@@ -63,8 +70,7 @@ export function evaluateFeatures(
   definitionNames: string[],
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let definitions;
 
   try {
@@ -75,13 +81,13 @@ export function evaluateFeatures(
   }
 
   return thenable(definitions) ?
-    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage, options))
+    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage))
       .catch(
         // Exception on async storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         () => treatmentsException(definitionNames)
       ) :
-    getEvaluations(log, key, definitionNames, definitions, attributes, storage, options);
+    getEvaluations(log, key, definitionNames, definitions, attributes, storage);
 }
 
 export function evaluateFeaturesByFlagSets(
@@ -91,8 +97,7 @@ export function evaluateFeaturesByFlagSets(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   method: string,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let storedFlagNames: MaybeThenable<Set<string>[]>;
 
   function evaluate(featureFlagsByFlagSets: Set<string>[]) {
@@ -107,7 +112,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
       {};
   }
 
@@ -126,33 +131,21 @@ export function evaluateFeaturesByFlagSets(
     evaluate(storedFlagNames);
 }
 
-function setEvaluationDataFromDefinition(evaluation: IEvaluationResult, definition: IDefinition, options?: SplitIO.EvaluationOptions): IEvaluationResult {
-  evaluation.changeNumber = definition.changeNumber;
-  evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
-  evaluation.type = definition.type;
-  evaluation.subtype = definition.subtype;
-  // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-  evaluation.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
-
-  return evaluation;
-}
-
 function getEvaluation(
   log: ILogger,
   key: SplitIO.SplitKey,
   definition: IDefinition | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
 
   if (definition) {
     const split = engineParser(log, definition, storage);
     const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
     return thenable(evaluation) ?
-      evaluation.then(result => setEvaluationDataFromDefinition(result, definition, options)) :
-      setEvaluationDataFromDefinition(evaluation, definition, options);
+      evaluation.then(result => setEvaluationDataFromDefinition(result, definition)) :
+      setEvaluationDataFromDefinition(evaluation, definition);
   }
 
   return EVALUATION_DEFINITION_NOT_FOUND;
@@ -165,12 +158,11 @@ function getEvaluations(
   definitions: Record<string, IDefinition | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  const result: Record<string, IEvaluationResult> = {};
+): MaybeThenable<Record<string, IEvaluation>> {
+  const result: Record<string, IEvaluation> = {};
   const thenables: Promise<void>[] = [];
   definitionNames.forEach(definitionName => {
-    const evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage, options);
+    const evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
     thenable(evaluation) ?
       thenables.push(evaluation.then(res => {
         result[definitionName] = res;
@@ -184,7 +176,7 @@ function getEvaluations(
 export function evaluateDefaultTreatment(
   definitionName: string,
   storage: IStorageSync | IStorageAsync,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -200,11 +192,11 @@ export function evaluateDefaultTreatment(
 
 function getDefaultTreatment(
   definition: IDefinition | null,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   if (definition) {
     return setEvaluationDataFromDefinition({
       treatment: definition.defaultTreatment,
-      label: NO_CONDITION_MATCH // "default rule"
+      label: NO_CONDITION_MATCH, // "default rule"
     }, definition);
   }
 

package/src/evaluator/types.ts

@@ -19,16 +19,12 @@ export interface IMatcherDto {
 }
 
 export interface IEvaluation {
-  treatment?: string,
+  treatment: string,
   label: string,
-  changeNumber?: number,
+  definition?: IDefinition
   config?: string | null | SplitIO.JsonObject
-  type?: IDefinition['type']
-  subtype?: IDefinition['subtype']
 }
 
-export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
-
 export type IDefinitionEvaluator = (log: ILogger, key: SplitIO.SplitKey, definitionName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
 export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>

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

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
-import { IEvaluationResult } from '../evaluator/types';
+import { IEvaluation } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
 import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
@@ -16,17 +16,17 @@ import { trackMethodFactory } from './trackMethod';
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
 function treatmentsNotReady(featureFlagNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   featureFlagNames.forEach(featureFlagName => {
     evaluations[featureFlagName] = treatmentNotReady;
   });
   return evaluations;
 }
 
-export function stringify(options?: SplitIO.EvaluationOptions) {
-  if (options && options.properties) {
+export function stringify(properties?: SplitIO.Properties) {
+  if (properties) {
     try {
-      return JSON.stringify(options.properties);
+      return JSON.stringify(properties);
     } catch { /* JSON.stringify should never throw with validated options, but handling just in case */ }
   }
 }
@@ -42,9 +42,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
-    const wrapUp = (evaluationResult: IEvaluationResult) => {
+    const wrapUp = (evaluationResult: IEvaluation) => {
       const queue: ImpressionDecorated[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -52,7 +52,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluation = readinessManager.isReadyFromCache() ?
-      evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
+      evaluateFeature(log, key, featureFlagName, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentNotReady) :
         treatmentNotReady;
@@ -67,12 +67,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENTS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -81,7 +80,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
+      evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentsNotReady(featureFlagNames)) :
         treatmentsNotReady(featureFlagNames);
@@ -96,12 +95,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -110,7 +108,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isAsync ?
         Promise.resolve({}) :
         {};
@@ -132,18 +130,18 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
   // Internal function
   function processEvaluation(
-    evaluation: IEvaluationResult,
+    evaluation: IEvaluation,
     featureFlagName: string,
     key: SplitIO.SplitKey,
-    properties: string | undefined,
     withConfig: boolean,
     invokingMethodName: string,
-    queue: ImpressionDecorated[]
+    queue: ImpressionDecorated[],
+    options: SplitIO.EvaluationOptions = {}
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    const { changeNumber, impressionsDisabled } = evaluation;
+    const { definition } = evaluation;
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
@@ -163,10 +161,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
           time: Date.now(),
           bucketingKey,
           label,
-          changeNumber: changeNumber as number,
-          properties
-        },
-        disabled: impressionsDisabled
+          changeNumber: definition?.changeNumber,
+          properties: stringify(options.properties)
+        }, // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
+        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;