General polishing: fix mocks, simplify fallback calculator, remove redundant logs, etc

CHANGES.txt

@@ -1,5 +1,5 @@
 2.12.0 (February 24, 2026)
- - Added support for ioredis v5.
+ - Added support for ioredis v5 (Related to issue https://github.com/splitio/javascript-commons/issues/471).
 
 2.11.0 (January 28, 2026)
  - Added functionality to provide metadata alongside SDK update and READY events. Read more in our docs.

src/dtos/types.ts

@@ -23,7 +23,7 @@ export interface IBetweenStringMatcherData {
 }
 
 export interface IWhitelistMatcherData {
-  whitelist: string[]
+  whitelist?: string[] | null
 }
 
 export interface IInSegmentMatcherData {

src/evaluator/condition/engineUtils.ts

@@ -18,10 +18,10 @@ export function getTreatment(log: ILogger, key: string, seed: number | undefined
 /**
  * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
  */
-export function shouldApplyRollout(trafficAllocation: number, key: string, trafficAllocationSeed: number) {
+export function shouldApplyRollout(trafficAllocation: number, bucketingKey: string, trafficAllocationSeed: number) {
   // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
   if (trafficAllocation < 100) {
-    const _bucket = bucket(key, trafficAllocationSeed);
+    const _bucket = bucket(bucketingKey, trafficAllocationSeed);
 
     if (_bucket > trafficAllocation) {
       return false;

src/evaluator/fallbackTreatmentsCalculator/__tests__/fallback-calculator.spec.ts

@@ -9,8 +9,8 @@ describe('FallbackTreatmentsCalculator' , () => {
         'featureA': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
       },
     };
-    const calculator = new FallbackTreatmentsCalculator(config);
-    const result = calculator.resolve('featureA', 'label by flag');
+    const calculator = FallbackTreatmentsCalculator(config);
+    const result = calculator('featureA', 'label by flag');
 
     expect(result).toEqual({
       treatment: 'TREATMENT_A',
@@ -24,8 +24,8 @@ describe('FallbackTreatmentsCalculator' , () => {
       byFlag: {},
       global: { treatment: 'GLOBAL_TREATMENT', config: '{ global: true }' },
     };
-    const calculator = new FallbackTreatmentsCalculator(config);
-    const result = calculator.resolve('missingFlag', 'label by global');
+    const calculator = FallbackTreatmentsCalculator(config);
+    const result = calculator('missingFlag', 'label by global');
 
     expect(result).toEqual({
       treatment: 'GLOBAL_TREATMENT',
@@ -38,8 +38,8 @@ describe('FallbackTreatmentsCalculator' , () => {
     const config: FallbackTreatmentConfiguration = {
       byFlag: {},
     };
-    const calculator = new FallbackTreatmentsCalculator(config);
-    const result = calculator.resolve('missingFlag', 'label by noFallback');
+    const calculator = FallbackTreatmentsCalculator(config);
+    const result = calculator('missingFlag', 'label by noFallback');
 
     expect(result).toEqual({
       treatment: CONTROL,

src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,50 +1,32 @@
-import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
+import { FallbackTreatmentConfiguration, TreatmentWithConfig } from '../../../types/splitio';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
 
-export type IFallbackTreatmentsCalculator = {
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
-}
+export type IFallbackTreatmentsCalculator = (flagName: string, label?: string) => TreatmentWithConfig & { label: string };
 
 export const FALLBACK_PREFIX = 'fallback - ';
 
-export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
-  private readonly fallbacks: FallbackTreatmentConfiguration;
-
-  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
-    this.fallbacks = fallbacks;
-  }
-
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {
-    const treatment = this.fallbacks.byFlag?.[flagName];
-    if (treatment) {
-      return this.copyWithLabel(treatment, label);
-    }
-
-    if (this.fallbacks.global) {
-      return this.copyWithLabel(this.fallbacks.global, label);
-    }
-
-    return {
-      treatment: CONTROL,
-      config: null,
-      label,
-    };
-  }
-
-  private copyWithLabel(fallback: Treatment | TreatmentWithConfig, label: string): TreatmentWithConfig & { label: string } {
-    if (isString(fallback)) {
-      return {
-        treatment: fallback,
+export function FallbackTreatmentsCalculator(fallbacks: FallbackTreatmentConfiguration = {}): IFallbackTreatmentsCalculator {
+
+  return (flagName: string, label = '') => {
+    const fallback = fallbacks.byFlag?.[flagName] || fallbacks.global;
+
+    return fallback ?
+      isString(fallback) ?
+        {
+          treatment: fallback,
+          config: null,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+        {
+          treatment: fallback.treatment,
+          config: fallback.config,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+      {
+        treatment: CONTROL,
         config: null,
-        label: `${FALLBACK_PREFIX}${label}`,
+        label,
       };
-    }
-
-    return {
-      treatment: fallback.treatment,
-      config: fallback.config,
-      label: `${FALLBACK_PREFIX}${label}`,
-    };
-  }
+  };
 }

src/evaluator/matchers/whitelist.ts

@@ -1,5 +1,5 @@
-export function whitelistMatcherContext(ruleAttr: string[]) {
-  const whitelistSet = new Set(ruleAttr);
+export function whitelistMatcherContext(ruleAttr?: string[] | null) {
+  const whitelistSet = new Set(ruleAttr || []);
 
   return function whitelistMatcher(runtimeAttr: string): boolean {
     const isInWhitelist = whitelistSet.has(runtimeAttr);

src/logger/constants.ts

@@ -32,7 +32,6 @@ export const ENGINE_DEFAULT = 41;
 
 export const CLIENT_READY_FROM_CACHE = 100;
 export const CLIENT_READY = 101;
-export const IMPRESSION = 102;
 export const IMPRESSION_QUEUEING = 103;
 export const NEW_SHARED_CLIENT = 104;
 export const NEW_FACTORY = 105;

src/logger/messages/info.ts

@@ -8,8 +8,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'],
   [c.CLIENT_READY, READY_MSG],
   // SDK
-  [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
-  [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing corresponding impression.'],
+  [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing impression. Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
   [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
   [c.NEW_FACTORY, 'New Split SDK instance created. %s'],
   [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],

src/sdkClient/__tests__/clientInputValidation.spec.ts

@@ -14,7 +14,7 @@ const settings: any = {
 const EVALUATION_RESULT = 'on';
 const client: any = createClientMock(EVALUATION_RESULT);
 
-const fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings);
+const fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator = FallbackTreatmentsCalculator();
 
 const readinessManager: any = {
   isReadyFromCache: () => true,

src/sdkClient/__tests__/sdkClientMethod.spec.ts

@@ -19,7 +19,7 @@ const paramMocks = [
     telemetryTracker: telemetryTrackerFactory(),
     clients: {},
     impressionsTracker: { start: jest.fn(), stop: jest.fn(), track: jest.fn() },
-    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator({})
+    fallbackTreatmentsCalculator: FallbackTreatmentsCalculator({})
   },
   // SyncManager (i.e., Sync SDK) and Signal listener
   {
@@ -31,7 +31,7 @@ const paramMocks = [
     telemetryTracker: telemetryTrackerFactory(),
     clients: {},
     impressionsTracker: { start: jest.fn(), stop: jest.fn(), track: jest.fn() },
-    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator({})
+    fallbackTreatmentsCalculator: FallbackTreatmentsCalculator({})
   }
 ];
 

src/sdkClient/client.ts

@@ -7,7 +7,7 @@ import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, 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, TRACK_FN_LABEL } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
+import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
@@ -147,16 +147,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
-      const fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+      const fallbackTreatment = fallbackTreatmentsCalculator(featureFlagName, label);
       treatment = fallbackTreatment.treatment;
       label = fallbackTreatment.label;
       config = fallbackTreatment.config;
     }
 
-    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-
     if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      log.info(IMPRESSION_QUEUEING);
+      log.info(IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
       queue.push({
         imp: {
           feature: featureFlagName,

src/sdkClient/clientInputValidation.ts

@@ -59,17 +59,20 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     };
   }
 
-  function evaluateFallBackTreatment(featureFlagName: string, withConfig: boolean): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const { treatment, config } = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
+  function evaluateFallBackTreatment(featureFlagName: string | false | string[], withConfig: boolean) {
+    if (Array.isArray(featureFlagName)) {
+      const res: SplitIO.Treatments = {};
+      featureFlagName.forEach((split: string) => res[split] = evaluateFallBackTreatment(split, withConfig) as SplitIO.Treatment);
+      return res;
+    }
+
+    const { treatment, config } = fallbackTreatmentsCalculator(featureFlagName as string);
 
-    if (withConfig) {
-      return {
+    return withConfig ?
+      {
         treatment,
         config
-      };
-    }
-
-    return treatment;
+      } : treatment;
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
@@ -79,89 +82,65 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, false);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, false));
   }
 
   function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, true);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, true));
   }
 
   function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.Treatments = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach((split: string) => res[split] = evaluateFallBackTreatment(split, false) as SplitIO.Treatment);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], false));
   }
 
   function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.TreatmentsWithConfig = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach(split => res[split] = evaluateFallBackTreatment(split, true) as SplitIO.TreatmentWithConfig);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], true));
   }
 
   function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
@@ -172,11 +151,9 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
 
-    if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-      return client.track(key, tt, event, eventValue, properties, size);
-    } else {
-      return isAsync ? Promise.resolve(false) : false;
-    }
+    return isNotDestroyed && key && tt && event && eventValue !== false && properties !== false ? // @ts-expect-error
+      client.track(key, tt, event, eventValue, properties, size) :
+      wrapResult(false);
   }
 
   return {

src/sdkFactory/__tests__/index.spec.ts

@@ -37,7 +37,7 @@ const paramsForAsyncSDK = {
   platform: {
     EventEmitter
   },
-  fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator()
+  fallbackTreatmentsCalculator: FallbackTreatmentsCalculator()
 };
 
 // IBrowserSDK, full params

src/sdkFactory/index.ts

@@ -45,7 +45,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+  const fallbackTreatmentsCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));