Rename new methods

Author: EmilianoSanchez

CHANGES.txt

@@ -1,6 +1,6 @@
 2.5.0 (August XX, 2025)
- - Added `factory.getCache()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
- - Added `preloadedData` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
+ - Added `factory.getRolloutPlan()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
+ - Added `initialRolloutPlan` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
 
 2.4.1 (June 3, 2025)
  - Bugfix - Improved the Proxy fallback to flag spec version 1.2 to handle cases where the Proxy does not return an end-of-stream marker in 400 status code responses.

src/storages/__tests__/dataLoader.spec.ts

@@ -6,8 +6,8 @@ import { IRBSegment, ISplit } from '../../dtos/types';
 
 import * as dataLoader from '../dataLoader';
 
-describe('setCache & getCache', () => {
-  jest.spyOn(dataLoader, 'setCache');
+describe('setRolloutPlan & getRolloutPlan', () => {
+  jest.spyOn(dataLoader, 'setRolloutPlan');
   const onReadyFromCacheCb = jest.fn();
   const onReadyCb = jest.fn();
 
@@ -24,23 +24,23 @@ describe('setCache & getCache', () => {
   });
 
   test('using preloaded data with memberships', () => {
-    const preloadedData = dataLoader.getCache(loggerMock, serverStorage, [fullSettings.core.key as string, otherKey]);
+    const rolloutPlanData = dataLoader.getRolloutPlan(loggerMock, serverStorage, [fullSettings.core.key as string, otherKey]);
 
     // Load client-side storage with preloaded data
-    const clientStorage = InMemoryStorageCSFactory({ settings: { ...fullSettings, preloadedData }, onReadyFromCacheCb, onReadyCb });
-    expect(dataLoader.setCache).toBeCalledTimes(1);
+    const clientStorage = InMemoryStorageCSFactory({ settings: { ...fullSettings, initialRolloutPlan: rolloutPlanData }, onReadyFromCacheCb, onReadyCb });
+    expect(dataLoader.setRolloutPlan).toBeCalledTimes(1);
     expect(onReadyFromCacheCb).toBeCalledTimes(1);
 
     // Shared client storage
     const sharedClientStorage = clientStorage.shared!(otherKey);
-    expect(dataLoader.setCache).toBeCalledTimes(2);
+    expect(dataLoader.setRolloutPlan).toBeCalledTimes(2);
 
     expect(clientStorage.segments.getRegisteredSegments()).toEqual(['segment1']);
     expect(sharedClientStorage.segments.getRegisteredSegments()).toEqual(['segment1']);
 
     // Get preloaded data from client-side storage
-    expect(dataLoader.getCache(loggerMock, clientStorage, [fullSettings.core.key as string, otherKey])).toEqual(preloadedData);
-    expect(preloadedData).toEqual({
+    expect(dataLoader.getRolloutPlan(loggerMock, clientStorage, [fullSettings.core.key as string, otherKey])).toEqual(rolloutPlanData);
+    expect(rolloutPlanData).toEqual({
       since: 123,
       flags: [{ name: 'split1' }],
       rbSince: 321,
@@ -54,20 +54,20 @@ describe('setCache & getCache', () => {
   });
 
   test('using preloaded data with segments', () => {
-    const preloadedData = dataLoader.getCache(loggerMock, serverStorage);
+    const rolloutPlanData = dataLoader.getRolloutPlan(loggerMock, serverStorage);
 
     // Load client-side storage with preloaded data
-    const clientStorage = InMemoryStorageCSFactory({ settings: { ...fullSettings, preloadedData }, onReadyFromCacheCb, onReadyCb });
-    expect(dataLoader.setCache).toBeCalledTimes(1);
+    const clientStorage = InMemoryStorageCSFactory({ settings: { ...fullSettings, initialRolloutPlan: rolloutPlanData }, onReadyFromCacheCb, onReadyCb });
+    expect(dataLoader.setRolloutPlan).toBeCalledTimes(1);
     expect(onReadyFromCacheCb).toBeCalledTimes(1);
 
     // Shared client storage
     const sharedClientStorage = clientStorage.shared!(otherKey);
-    expect(dataLoader.setCache).toBeCalledTimes(2);
+    expect(dataLoader.setRolloutPlan).toBeCalledTimes(2);
     expect(clientStorage.segments.getRegisteredSegments()).toEqual(['segment1']);
     expect(sharedClientStorage.segments.getRegisteredSegments()).toEqual(['segment1']);
 
-    expect(preloadedData).toEqual({
+    expect(rolloutPlanData).toEqual({
       since: 123,
       flags: [{ name: 'split1' }],
       rbSince: 321,

src/storages/dataLoader.ts

@@ -6,31 +6,31 @@ import { IMembershipsResponse, IMySegmentsResponse, IRBSegment, ISplit } from '.
 import { ILogger } from '../logger/types';
 
 /**
- * Sets the given synchronous storage with the provided preloaded data snapshot.
+ * Sets the given synchronous storage with the provided rollout plan snapshot.
  * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
-export function setCache(log: ILogger, preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current preloadedData is empty
-  if (Object.keys(preloadedData).length === 0) return;
+export function setRolloutPlan(log: ILogger, rolloutPlan: SplitIO.RolloutPlan, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  // Do not load data if current rollout plan is empty
+  if (Object.keys(rolloutPlan).length === 0) return;
 
   const { splits, rbSegments, segments, largeSegments } = storage;
 
-  log.debug(`set cache${matchingKey ? ` for key ${matchingKey}` : ''}`);
+  log.debug(`storage: set feature flags and segments${matchingKey ? ` for key ${matchingKey}` : ''}`);
 
   if (splits) {
     splits.clear();
-    splits.update(preloadedData.flags as ISplit[] || [], [], preloadedData.since || -1);
+    splits.update(rolloutPlan.flags as ISplit[] || [], [], rolloutPlan.since || -1);
   }
 
   if (rbSegments) {
     rbSegments.clear();
-    rbSegments.update(preloadedData.rbSegments as IRBSegment[] || [], [], preloadedData.rbSince || -1);
+    rbSegments.update(rolloutPlan.rbSegments as IRBSegment[] || [], [], rolloutPlan.rbSince || -1);
   }
 
-  const segmentsData = preloadedData.segments || {};
+  const segmentsData = rolloutPlan.segments || {};
   if (matchingKey) { // add memberships data (client-side)
-    let memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
+    let memberships = rolloutPlan.memberships && rolloutPlan.memberships[matchingKey];
     if (!memberships && segmentsData) {
       memberships = {
         ms: {
@@ -55,13 +55,13 @@ export function setCache(log: ILogger, preloadedData: SplitIO.PreloadedData, sto
 }
 
 /**
- * Gets the preloaded data snapshot from the given synchronous storage.
+ * Gets the rollout plan snapshot from the given synchronous storage.
  * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
  * Otherwise, the segments data is returned.
  */
-export function getCache(log: ILogger, storage: IStorageSync, keys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
+export function getRolloutPlan(log: ILogger, storage: IStorageSync, keys?: SplitIO.SplitKey[]): SplitIO.RolloutPlan {
 
-  log.debug(`get cache${keys ? ` for keys ${keys}` : ''}`);
+  log.debug(`storage: get feature flags and segments${keys ? ` for keys ${keys}` : ''}`);
 
   return {
     since: storage.splits.getChangeNumber(),

src/storages/inLocalStorage/index.ts

@@ -26,9 +26,9 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
 
   function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
 
-    // Fallback to InMemoryStorage if LocalStorage API is not available
-    if (!isLocalStorageAvailable()) {
-      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+    // Fallback to InMemoryStorage if LocalStorage API is not available or preloaded data is provided
+    if (!isLocalStorageAvailable() || params.settings.initialRolloutPlan) {
+      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable or `initialRolloutPlan` is provided. Falling back to default MEMORY storage');
       return InMemoryStorageCSFactory(params);
     }
 

src/storages/inMemory/InMemoryStorageCS.ts

@@ -8,7 +8,7 @@ import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-import { setCache } from '../dataLoader';
+import { setRolloutPlan } from '../dataLoader';
 import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 
 /**
@@ -17,7 +17,7 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
+  const { settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation }, initialRolloutPlan }, onReadyFromCacheCb } = params;
 
   const storages: Record<string, IStorageSync> = {};
 
@@ -45,8 +45,8 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         const segments = new MySegmentsCacheInMemory();
         const largeSegments = new MySegmentsCacheInMemory();
 
-        if (preloadedData) {
-          setCache(log, preloadedData, { segments, largeSegments }, matchingKey);
+        if (initialRolloutPlan) {
+          setRolloutPlan(log, initialRolloutPlan, { segments, largeSegments }, matchingKey);
         }
 
         storages[matchingKey] = {
@@ -81,8 +81,8 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
   const matchingKey = getMatching(params.settings.core.key);
   storages[matchingKey] = storage;
 
-  if (preloadedData) {
-    setCache(log, preloadedData, storage, matchingKey);
+  if (initialRolloutPlan) {
+    setRolloutPlan(log, initialRolloutPlan, storage, matchingKey);
     if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
   }
 

types/splitio.d.ts

@@ -353,7 +353,7 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
   /**
    * Data to initialize the SDK storage with. If provided and valid, the SDK will be ready from cache immediately.
    */
-  preloadedData?: SplitIO.PreloadedData;
+  initialRolloutPlan?: SplitIO.RolloutPlan;
   /**
    * SDK Startup settings.
    */
@@ -559,7 +559,7 @@ declare namespace SplitIO {
       eventsFirstPushWindow: number;
     };
     readonly storage: StorageSyncFactory | StorageAsyncFactory | StorageOptions;
-    readonly preloadedData?: SplitIO.PreloadedData;
+    readonly initialRolloutPlan?: SplitIO.RolloutPlan;
     readonly urls: {
       events: string;
       sdk: string;
@@ -1025,41 +1025,41 @@ declare namespace SplitIO {
     type: NodeSyncStorage | NodeAsyncStorage | BrowserStorage;
     prefix?: string;
     options?: Object;
-  }
+  };
   /**
-   * Defines the format of rollout plan data to preload the factory storage (cache).
+   * Defines the format of rollout plan data to preload the SDK cache.
    */
-  type PreloadedData = {
+  type RolloutPlan = {
     /**
      * Change number of feature flags.
      */
     since: number;
     /**
      * List of feature flags.
      */
-    flags: Object[],
+    flags: Object[];
     /**
      * Change number of rule-based segments.
      */
-    rbSince?: number,
+    rbSince?: number;
     /**
      * List of rule-based segments.
      */
-    rbSegments?: Object[],
+    rbSegments?: Object[];
     /**
      * Optional map of user keys to their memberships.
      */
     memberships?: {
-      [key: string]: Object
-    },
+      [key: string]: Object;
+    };
     /**
      * Optional map of segments to their list of keys.
      * This property is ignored if `memberships` is provided.
      */
     segments?: {
-      [segmentName: string]: string[]
-    },
-  }
+      [segmentName: string]: string[];
+    };
+  };
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -1082,7 +1082,7 @@ declare namespace SplitIO {
   type IntegrationFactory = {
     readonly type: string;
     (params: any): (Integration | void);
-  }
+  };
   /**
    * A pair of user key and it's trafficType, required for tracking valid Split events.
    */
@@ -1609,7 +1609,7 @@ declare namespace SplitIO {
      * @param keys - Optional list of keys to generate the rollout plan snapshot with the memberships of the given keys, rather than the complete segments data.
      * @returns The current snapshot of the SDK rollout plan.
      */
-    getCache(keys?: SplitKey[]): PreloadedData,
+    getRolloutPlan(keys?: SplitKey[]): RolloutPlan;
   }
   /**
    * This represents the interface for the SDK instance for server-side with asynchronous storage.