refactor: mode rollout plan validation

Author: EmilianoSanchez

src/sdkClient/sdkClientMethodCS.ts

@@ -9,7 +9,6 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, L
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { buildInstanceId } from './identity';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { setRolloutPlan } from '../storages/dataLoader';
 import { ISegmentsCacheSync } from '../storages/types';
 
@@ -18,7 +17,7 @@ import { ISegmentsCacheSync } from '../storages/types';
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.IBrowserClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log, initialRolloutPlan, mode } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log, initialRolloutPlan } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -59,7 +58,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
       });
 
-      if (sharedStorage && initialRolloutPlan && !isConsumerMode(mode)) {
+      if (sharedStorage && initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, { segments: sharedStorage.segments as ISegmentsCacheSync, largeSegments: sharedStorage.largeSegments as ISegmentsCacheSync }, matchingKey);
       }
 

src/sdkFactory/index.ts

@@ -15,7 +15,6 @@ import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
 import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/dataLoader';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { IStorageSync } from '../storages/types';
 import { getMatching } from '../utils/key';
 
@@ -28,7 +27,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
     filterAdapterFactory, lazyInit } = params;
-  const { log, sync: { impressionsMode }, initialRolloutPlan, mode, core: { key } } = settings;
+  const { log, sync: { impressionsMode }, initialRolloutPlan, core: { key } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -61,7 +60,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  if (initialRolloutPlan && !isConsumerMode(mode)) {
+  if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
     if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
   }

src/storages/__tests__/dataLoader.spec.ts

@@ -4,34 +4,54 @@ import { fullSettings } from '../../utils/settingsValidation/__tests__/settings.
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { IRBSegment, ISplit } from '../../dtos/types';
 
-import { setRolloutPlan, getRolloutPlan } from '../dataLoader';
+import { validateRolloutPlan, setRolloutPlan, getRolloutPlan } from '../dataLoader';
+
+const otherKey = 'otherKey';
+const expectedRolloutPlan = {
+  splitChanges: {
+    ff: { d: [{ name: 'split1' }], t: 123, s: -1 },
+    rbs: { d: [{ name: 'rbs1' }], t: 321, s: -1 }
+  },
+  memberships: {
+    [fullSettings.core.key as string]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } },
+    [otherKey]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } }
+  },
+  segmentChanges: [{
+    name: 'segment1',
+    added: [fullSettings.core.key as string, otherKey],
+    removed: [],
+    till: 123
+  }]
+};
+
+describe('validateRolloutPlan', () => {
+  afterEach(() => {
+    loggerMock.mockClear();
+  });
 
-describe('getRolloutPlan & setRolloutPlan (client-side)', () => {
-  const otherKey = 'otherKey';
+  test('valid rollout plan and mode', () => {
+    expect(validateRolloutPlan(loggerMock, { mode: 'standalone', initialRolloutPlan: expectedRolloutPlan } as any)).toEqual(expectedRolloutPlan);
+    expect(loggerMock.error).not.toHaveBeenCalled();
+  });
+
+  test('invalid rollout plan', () => {
+    expect(validateRolloutPlan(loggerMock, { mode: 'standalone', initialRolloutPlan: {} } as any)).toBeUndefined();
+    expect(loggerMock.error).toHaveBeenCalledWith('storage: invalid rollout plan provided');
+  });
 
+  test('invalid mode', () => {
+    expect(validateRolloutPlan(loggerMock, { mode: 'consumer', initialRolloutPlan: expectedRolloutPlan } as any)).toBeUndefined();
+    expect(loggerMock.warn).toHaveBeenCalledWith('storage: initial rollout plan is ignored in consumer mode');
+  });
+});
+
+describe('getRolloutPlan & setRolloutPlan (client-side)', () => {
   // @ts-expect-error Load server-side storage
   const serverStorage = InMemoryStorageFactory({ settings: fullSettings });
   serverStorage.splits.update([{ name: 'split1' } as ISplit], [], 123);
   serverStorage.rbSegments.update([{ name: 'rbs1' } as IRBSegment], [], 321);
   serverStorage.segments.update('segment1', [fullSettings.core.key as string, otherKey], [], 123);
 
-  const expectedRolloutPlan = {
-    splitChanges: {
-      ff: { d: [{ name: 'split1' }], t: 123, s: -1 },
-      rbs: { d: [{ name: 'rbs1' }], t: 321, s: -1 }
-    },
-    memberships: {
-      [fullSettings.core.key as string]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } },
-      [otherKey]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } }
-    },
-    segmentChanges: [{
-      name: 'segment1',
-      added: [fullSettings.core.key as string, otherKey],
-      removed: [],
-      till: 123
-    }]
-  };
-
   afterEach(() => {
     jest.clearAllMocks();
   });

src/storages/dataLoader.ts

@@ -5,6 +5,7 @@ import { getMatching } from '../utils/key';
 import { IMembershipsResponse, IMySegmentsResponse, ISegmentChangesResponse, ISplitChangesResponse } from '../dtos/types';
 import { ILogger } from '../logger/types';
 import { isObject } from '../utils/lang';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 
 export type RolloutPlan = {
   /**
@@ -27,10 +28,18 @@ export type RolloutPlan = {
 /**
  * Validates if the given rollout plan is valid.
  */
-function validateRolloutPlan(rolloutPlan: unknown): rolloutPlan is RolloutPlan {
-  if (isObject(rolloutPlan) && isObject((rolloutPlan as any).splitChanges)) return true;
+export function validateRolloutPlan(log: ILogger, settings: SplitIO.ISettings): RolloutPlan | undefined {
+  const { mode, initialRolloutPlan } = settings;
 
-  return false;
+  if (isConsumerMode(mode)) {
+    log.warn('storage: initial rollout plan is ignored in consumer mode');
+    return;
+  }
+
+  if (isObject(initialRolloutPlan) && isObject((initialRolloutPlan as any).splitChanges)) return initialRolloutPlan as RolloutPlan;
+
+  log.error('storage: invalid rollout plan provided');
+  return;
 }
 
 /**
@@ -39,12 +48,6 @@ function validateRolloutPlan(rolloutPlan: unknown): rolloutPlan is RolloutPlan {
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 export function setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current rollout plan is empty
-  if (!validateRolloutPlan(rolloutPlan)) {
-    log.error('storage: invalid rollout plan provided');
-    return;
-  }
-
   const { splits, rbSegments, segments, largeSegments } = storage;
   const { splitChanges: { ff, rbs } } = rolloutPlan;
 
@@ -79,6 +82,7 @@ export function setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage:
     }
   } else { // add segments data (server-side)
     if (segmentChanges) {
+      segments.clear();
       segmentChanges.forEach(segment => {
         segments.update(segment.name, segment.added, segment.removed, segment.till);
       });

src/storages/inLocalStorage/validateCache.ts

@@ -17,7 +17,7 @@ const MILLIS_IN_A_DAY = 86400000;
  * @returns `true` if cache should be cleared, `false` otherwise
  */
 function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
-  const { log } = settings;
+  const { log, initialRolloutPlan } = settings;
 
   // Check expiration
   const lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()) as string, 10);
@@ -41,7 +41,7 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: IS
     } catch (e) {
       log.error(LOG_PREFIX + e);
     }
-    if (isThereCache) {
+    if (isThereCache && !initialRolloutPlan) {
       log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
       return true;
     }

src/utils/settingsValidation/index.ts

@@ -7,6 +7,7 @@ import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
+import { validateRolloutPlan } from '../../storages/dataLoader';
 
 // Exported for telemetry
 export const base = {
@@ -152,6 +153,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (storage) withDefaults.storage = storage(withDefaults);
 
+  // @ts-ignore, modify readonly prop
+  if (withDefaults.initialRolloutPlan) withDefaults.initialRolloutPlan = validateRolloutPlan(log, withDefaults);
+
   // Validate key and TT (for client-side)
   const maybeKey = withDefaults.core.key;
   if (validationParams.acceptKey) {