[WIP] Fallback treatment

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

@@ -0,0 +1,66 @@
+import { FallbackTreatmentsCalculator } from '../';
+import type { FallbackTreatmentConfiguration } from '../../../../types/splitio'; // adjust path if needed
+
+describe('FallbackTreatmentsCalculator', () => {
+
+  test('returns specific fallback if flag exists', () => {
+    const config: FallbackTreatmentConfiguration = {
+      byFlag: {
+        'featureA': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    const calculator = new FallbackTreatmentsCalculator(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(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(config);
+    const result = calculator.resolve('missingFlag', 'label by noFallback');
+
+    expect(result).toEqual({
+      treatment: 'CONTROL',
+      config: null,
+      label: 'fallback - label by noFallback',
+    });
+  });
+
+  test('returns undefined label if no label provided', () => {
+    const config: FallbackTreatmentConfiguration = {
+      byFlag: {
+        'featureB': { treatment: 'TREATMENT_B' },
+      },
+    };
+    const calculator = new FallbackTreatmentsCalculator(config);
+    const result = calculator.resolve('featureB');
+
+    expect(result).toEqual({
+      treatment: 'TREATMENT_B',
+      config: undefined,
+      label: undefined,
+    });
+  });
+});

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

@@ -0,0 +1,103 @@
+import { FallbacksSanitizer } from '../fallbackSanitizer';
+import { TreatmentWithConfig } from '../../../../types/splitio';
+
+describe('FallbacksSanitizer', () => {
+  const validTreatment: TreatmentWithConfig = { treatment: 'on', config: '{"color":"blue"}' };
+  const invalidTreatment: TreatmentWithConfig = { treatment: ' ', config: null };
+
+  beforeEach(() => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    (console.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(validTreatment)).toEqual(validTreatment);
+      expect(console.error).not.toHaveBeenCalled();
+    });
+
+    test('returns undefined and logs error if invalid', () => {
+      const result = FallbacksSanitizer.sanitizeGlobal(invalidTreatment);
+      expect(result).toBeUndefined();
+      expect(console.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(input);
+
+      expect(result).toEqual({ valid_flag: validTreatment });
+      expect(console.error).toHaveBeenCalledTimes(2); // invalid flag + bad_treatment
+    });
+
+    test('returns empty object if all invalid', () => {
+      const input = {
+        'invalid flag': invalidTreatment,
+      };
+
+      const result = FallbacksSanitizer.sanitizeByFlag(input);
+      expect(result).toEqual({});
+      expect(console.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(input);
+      expect(result).toEqual(input);
+      expect(console.error).not.toHaveBeenCalled();
+    });
+  });
+});

src/evaluator/fallbackTreatmentsCalculator/constants.ts

@@ -0,0 +1,4 @@
+export enum FallbackDiscardReason {
+  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
+  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
+}

src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -0,0 +1,68 @@
+import { FallbackTreatment } from '../../../../types/splitio';
+import { FallbackDiscardReason } from '../constants';
+
+
+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?: FallbackTreatment): boolean {
+    if (!t) {
+      return false;
+    }
+
+    if (typeof t === 'string') {
+      if (t.length > 100) {
+        return false;
+      }
+      return FallbacksSanitizer.pattern.test(t);
+    }
+
+    const { treatment } = t;
+    if (!treatment || treatment.length > 100) {
+      return false;
+    }
+    return FallbacksSanitizer.pattern.test(treatment);
+  }
+
+  static sanitizeGlobal(treatment?: FallbackTreatment): FallbackTreatment | undefined {
+    if (!this.isValidTreatment(treatment)) {
+      console.error(
+        `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
+      );
+      return undefined;
+    }
+    return treatment!;
+  }
+
+  static sanitizeByFlag(
+    byFlagFallbacks: Record<string, FallbackTreatment>
+  ): Record<string, FallbackTreatment> {
+    const sanitizedByFlag: Record<string, FallbackTreatment> = {};
+
+    const entries = Object.entries(byFlagFallbacks);
+    entries.forEach(([flag, t]) => {
+      if (!this.isValidFlagName(flag)) {
+        console.error(
+          `Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`
+        );
+        return;
+      }
+
+      if (!this.isValidTreatment(t)) {
+        console.error(
+          `Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`
+        );
+        return;
+      }
+
+      sanitizedByFlag[flag] = t;
+    });
+
+    return sanitizedByFlag;
+  }
+}

src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -0,0 +1,49 @@
+import { FallbackTreatmentConfiguration, FallbackTreatment, IFallbackTreatmentsCalculator} from '../../../types/splitio';
+
+export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
+  private readonly labelPrefix = 'fallback - ';
+  private readonly control = 'CONTROL';
+  private readonly fallbacks: FallbackTreatmentConfiguration;
+
+  constructor(fallbacks: FallbackTreatmentConfiguration) {
+    this.fallbacks = fallbacks;
+  }
+
+  resolve(flagName: string, label?: string | undefined): FallbackTreatment {
+    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: this.control,
+      config: null,
+      label: this.resolveLabel(label),
+    };
+  }
+
+  private copyWithLabel(fallback: FallbackTreatment, label: string | undefined): FallbackTreatment {
+    if (typeof fallback === 'string') {
+      return {
+        treatment: fallback,
+        config: null,
+        label: this.resolveLabel(label),
+      };
+    }
+
+    return {
+      treatment: fallback.treatment,
+      config: fallback.config,
+      label: this.resolveLabel(label),
+    };
+  }
+
+  private resolveLabel(label?: string | undefined): string | undefined {
+    return label ? `${this.labelPrefix}${label}` : undefined;
+  }
+
+}

types/splitio.d.ts

@@ -621,6 +621,10 @@ declare namespace SplitIO {
      * User consent status if using in client-side. Undefined if using in server-side (Node.js).
      */
     readonly userConsent?: ConsentStatus;
+    /**
+     * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+     */
+    readonly fallbackTreatments?: FallbackTreatmentConfiguration;
   }
   /**
    * Log levels.
@@ -1228,6 +1232,26 @@ declare namespace SplitIO {
    * User consent status.
    */
   type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
+  /**
+   * Fallback treatment can be either a string (treatment) or an object with treatment, config and label.
+   */
+  type FallbackTreatment = string | {
+    treatment: string;
+    config?: string | null;
+    label?: string | null;
+  };
+  /**
+   * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+   */
+  type FallbackTreatmentConfiguration = {
+    global?: FallbackTreatment,
+    byFlag: {
+      [key: string]: FallbackTreatment
+    }
+  }
+  type IFallbackTreatmentsCalculator = {
+    resolve(flagName: string, label?: string | undefined): FallbackTreatment;
+  }
   /**
    * Logger. Its interface details are not part of the public API. It shouldn't be used directly.
    */