Merge branch 'refactor_checkIfServerSide_util' into handle-segmentchanges-timeout

Author: EmilianoSanchez

CHANGES.txt

@@ -1,6 +1,12 @@
-2.8.0 (October XX, 2025)
+2.9.0 (October XX, 2025)
  - Updated the SDK’s initial synchronization in Node.js (server-side) to use the `startup.requestTimeoutBeforeReady` and `startup.retriesOnFailureBeforeReady` options to control the timeout and retry behavior of segment requests.
 
+2.8.0 (October 28, 2025)
+ - Added new configuration for Fallback Treatments, which allows setting a treatment value and optional config to be returned in place of "control", either globally or by flag. Read more in our docs.
+ - Added `client.getStatus()` method to retrieve the client readiness status properties (`isReady`, `isReadyFromCache`, etc).
+ - Added `client.whenReady()` and `client.whenReadyFromCache()` methods to replace the deprecated `client.ready()` method, which has an issue causing the returned promise to hang when using async/await syntax if it was rejected.
+ - Updated the SDK_READY_FROM_CACHE event to be emitted alongside the SDK_READY event if it hasn’t already been emitted.
+
 2.7.1 (October 8, 2025)
  - Bugfix - Update `debug` option to support log levels when `logger` option is used.
 

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

@@ -0,0 +1,134 @@
+import { FallbackTreatmentsCalculator } from '../';
+import type { FallbackTreatmentConfiguration } from '../../../../types/splitio';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
+import { CONTROL } from '../../../utils/constants';
+
+describe('FallbackTreatmentsCalculator' , () => {
+  const longName = 'a'.repeat(101);
+
+  test('logs an error if flag name is invalid - by Flag', () => {
+    let config: FallbackTreatmentConfiguration = {
+      byFlag: {
+        'feature A': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[0][0]).toBe(
+      'Fallback treatments - Discarded flag \'feature A\': Invalid flag name (max 100 chars, no spaces)'
+    );
+    config = {
+      byFlag: {
+        [longName]: { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[1][0]).toBe(
+      `Fallback treatments - Discarded flag '${longName}': Invalid flag name (max 100 chars, no spaces)`
+    );
+
+    config = {
+      byFlag: {
+        'featureB': { treatment: longName, config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[2][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureB\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      byFlag: {
+        // @ts-ignore
+        'featureC': { config: '{ global: true }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[3][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      byFlag: {
+        // @ts-ignore
+        'featureC': { treatment: 'invalid treatment!', config: '{ global: true }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[4][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+  });
+
+  test('logs an error if flag name is invalid - global', () => {
+    let config: FallbackTreatmentConfiguration = {
+      global: { treatment: longName, config: '{ value: 1 }' },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[2][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureB\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      // @ts-ignore
+      global: { config: '{ global: true }' },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[3][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      // @ts-ignore
+      global: { treatment: 'invalid treatment!', config: '{ global: true }' },
+    };
+    new FallbackTreatmentsCalculator(loggerMock, config);
+    expect(loggerMock.error.mock.calls[4][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+  });
+
+  test('returns specific fallback if flag exists', () => {
+    const config: FallbackTreatmentConfiguration = {
+      byFlag: {
+        'featureA': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const result = calculator.resolve('featureA', 'label by flag');
+
+    expect(result).toEqual({
+      treatment: 'TREATMENT_A',
+      config: '{ value: 1 }',
+      label: 'fallback - label by flag',
+    });
+  });
+
+  test('returns global fallback if flag is missing and global exists', () => {
+    const config: FallbackTreatmentConfiguration = {
+      byFlag: {},
+      global: { treatment: 'GLOBAL_TREATMENT', config: '{ global: true }' },
+    };
+    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const result = calculator.resolve('missingFlag', 'label by global');
+
+    expect(result).toEqual({
+      treatment: 'GLOBAL_TREATMENT',
+      config: '{ global: true }',
+      label: 'fallback - label by global',
+    });
+  });
+
+  test('returns control fallback if flag and global are missing', () => {
+    const config: FallbackTreatmentConfiguration = {
+      byFlag: {},
+    };
+    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const result = calculator.resolve('missingFlag', 'label by noFallback');
+
+    expect(result).toEqual({
+      treatment: CONTROL,
+      config: null,
+      label: 'label by noFallback',
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import { FallbacksSanitizer } from '../fallbackSanitizer';
+import { TreatmentWithConfig } from '../../../../types/splitio';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
+
+describe('FallbacksSanitizer', () => {
+  const validTreatment: TreatmentWithConfig = { treatment: 'on', config: '{"color":"blue"}' };
+  const invalidTreatment: TreatmentWithConfig = { treatment: ' ', config: null };
+
+  beforeEach(() => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    (loggerMock.error as jest.Mock).mockRestore();
+  });
+
+  describe('isValidFlagName', () => {
+    test('returns true for a valid flag name', () => {
+      // @ts-expect-private-access
+      expect((FallbacksSanitizer as any).isValidFlagName('my_flag')).toBe(true);
+    });
+
+    test('returns false for a name longer than 100 chars', () => {
+      const longName = 'a'.repeat(101);
+      expect((FallbacksSanitizer as any).isValidFlagName(longName)).toBe(false);
+    });
+
+    test('returns false if the name contains spaces', () => {
+      expect((FallbacksSanitizer as any).isValidFlagName('invalid flag')).toBe(false);
+    });
+  });
+
+  describe('isValidTreatment', () => {
+    test('returns true for a valid treatment string', () => {
+      expect((FallbacksSanitizer as any).isValidTreatment(validTreatment)).toBe(true);
+    });
+
+    test('returns false for null or undefined', () => {
+      expect((FallbacksSanitizer as any).isValidTreatment(null)).toBe(false);
+      expect((FallbacksSanitizer as any).isValidTreatment(undefined)).toBe(false);
+    });
+
+    test('returns false for a treatment longer than 100 chars', () => {
+      const long = { treatment: 'a'.repeat(101) };
+      expect((FallbacksSanitizer as any).isValidTreatment(long)).toBe(false);
+    });
+
+    test('returns false if treatment does not match regex pattern', () => {
+      const invalid = { treatment: 'invalid treatment!' };
+      expect((FallbacksSanitizer as any).isValidTreatment(invalid)).toBe(false);
+    });
+  });
+
+  describe('sanitizeGlobal', () => {
+    test('returns the treatment if valid', () => {
+      expect(FallbacksSanitizer.sanitizeGlobal(loggerMock, validTreatment)).toEqual(validTreatment);
+      expect(loggerMock.error).not.toHaveBeenCalled();
+    });
+
+    test('returns undefined and logs error if invalid', () => {
+      const result = FallbacksSanitizer.sanitizeGlobal(loggerMock, invalidTreatment);
+      expect(result).toBeUndefined();
+      expect(loggerMock.error).toHaveBeenCalledWith(
+        expect.stringContaining('Fallback treatments - Discarded fallback')
+      );
+    });
+  });
+
+  describe('sanitizeByFlag', () => {
+    test('returns a sanitized map with valid entries only', () => {
+      const input = {
+        valid_flag: validTreatment,
+        'invalid flag': validTreatment,
+        bad_treatment: invalidTreatment,
+      };
+
+      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
+
+      expect(result).toEqual({ valid_flag: validTreatment });
+      expect(loggerMock.error).toHaveBeenCalledTimes(2); // invalid flag + bad_treatment
+    });
+
+    test('returns empty object if all invalid', () => {
+      const input = {
+        'invalid flag': invalidTreatment,
+      };
+
+      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
+      expect(result).toEqual({});
+      expect(loggerMock.error).toHaveBeenCalled();
+    });
+
+    test('returns same object if all valid', () => {
+      const input = {
+        flag_one: validTreatment,
+        flag_two: { treatment: 'valid_2', config: null },
+      };
+
+      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
+      expect(result).toEqual(input);
+      expect(loggerMock.error).not.toHaveBeenCalled();
+    });
+  });
+});

src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -0,0 +1,65 @@
+import { Treatment, TreatmentWithConfig } from '../../../../types/splitio';
+import { ILogger } from '../../../logger/types';
+import { isObject, isString } from '../../../utils/lang';
+
+enum FallbackDiscardReason {
+  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
+  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
+}
+
+export class FallbacksSanitizer {
+
+  private static readonly pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+
+  private static isValidFlagName(name: string): boolean {
+    return name.length <= 100 && !name.includes(' ');
+  }
+
+  private static isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
+    const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
+
+    if (!isString(treatment) || treatment.length > 100) {
+      return false;
+    }
+    return FallbacksSanitizer.pattern.test(treatment);
+  }
+
+  static sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
+    if (!this.isValidTreatment(treatment)) {
+      logger.error(
+        `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
+      );
+      return undefined;
+    }
+    return treatment;
+  }
+
+  static sanitizeByFlag(
+    logger: ILogger,
+    byFlagFallbacks: Record<string, Treatment | TreatmentWithConfig>
+  ): Record<string, Treatment | TreatmentWithConfig> {
+    const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
+
+    const entries = Object.keys(byFlagFallbacks);
+    entries.forEach((flag) => {
+      const t = byFlagFallbacks[flag];
+      if (!this.isValidFlagName(flag)) {
+        logger.error(
+          `Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`
+        );
+        return;
+      }
+
+      if (!this.isValidTreatment(t)) {
+        logger.error(
+          `Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`
+        );
+        return;
+      }
+
+      sanitizedByFlag[flag] = t;
+    });
+
+    return sanitizedByFlag;
+  }
+}

src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -0,0 +1,57 @@
+import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
+import { FallbacksSanitizer } from './fallbackSanitizer';
+import { CONTROL } from '../../utils/constants';
+import { isString } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export type IFallbackTreatmentsCalculator = {
+  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
+}
+
+export const FALLBACK_PREFIX = 'fallback - ';
+
+export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
+  private readonly fallbacks: FallbackTreatmentConfiguration;
+
+  constructor(logger: ILogger, fallbacks?: FallbackTreatmentConfiguration) {
+    const sanitizedGlobal = fallbacks?.global ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
+    const sanitizedByFlag = fallbacks?.byFlag ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
+    this.fallbacks = {
+      global: sanitizedGlobal,
+      byFlag: sanitizedByFlag
+    };
+  }
+
+  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,
+        config: null,
+        label: `${FALLBACK_PREFIX}${label}`,
+      };
+    }
+
+    return {
+      treatment: fallback.treatment,
+      config: fallback.config,
+      label: `${FALLBACK_PREFIX}${label}`,
+    };
+  }
+}

src/logger/constants.ts

@@ -60,7 +60,7 @@ export const SUBMITTERS_PUSH_PAGE_HIDDEN = 125;
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export const CLIENT_NO_LISTENER = 202;
-export const CLIENT_NOT_READY = 203;
+export const CLIENT_NOT_READY_FROM_CACHE = 203;
 export const SYNC_MYSEGMENTS_FETCH_RETRY = 204;
 export const SYNC_SPLITS_FETCH_FAILS = 205;
 export const STREAMING_PARSING_ERROR_FAILS = 206;

src/logger/messages/warn.ts

@@ -14,8 +14,8 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s.'],
   [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
   // client status
-  [c.CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
-  [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],
+  [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
+  [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
   // input validation
   [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
   [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],