@splitsoftware/splitio-commons 2.5.0-rc.0 → 2.5.0

package/esm/storages/setRolloutPlan.js

@@ -0,0 +1,61 @@
+import { isObject } from '../utils/lang';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+/**
+ * Validates if the given rollout plan is valid.
+ */
+export function validateRolloutPlan(log, settings) {
+    var mode = settings.mode, initialRolloutPlan = settings.initialRolloutPlan;
+    if (isConsumerMode(mode)) {
+        log.warn('storage: initial rollout plan is ignored in consumer mode');
+        return;
+    }
+    if (isObject(initialRolloutPlan) && isObject(initialRolloutPlan.splitChanges))
+        return initialRolloutPlan;
+    log.error('storage: invalid rollout plan provided');
+    return;
+}
+/**
+ * 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 setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
+    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
+    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
+    if (splits && ff) {
+        splits.clear();
+        splits.update(ff.d, [], ff.t);
+    }
+    if (rbSegments && rbs) {
+        rbSegments.clear();
+        rbSegments.update(rbs.d, [], rbs.t);
+    }
+    var segmentChanges = rolloutPlan.segmentChanges;
+    if (matchingKey) { // add memberships data (client-side)
+        var memberships = rolloutPlan.memberships && rolloutPlan.memberships[matchingKey];
+        if (!memberships && segmentChanges) {
+            memberships = {
+                ms: {
+                    k: segmentChanges.filter(function (segment) {
+                        return segment.added.indexOf(matchingKey) > -1;
+                    }).map(function (segment) { return ({ n: segment.name }); })
+                }
+            };
+        }
+        if (memberships) {
+            if (memberships.ms)
+                segments.resetSegments(memberships.ms);
+            if (memberships.ls && largeSegments)
+                largeSegments.resetSegments(memberships.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        if (segmentChanges) {
+            segments.clear();
+            segmentChanges.forEach(function (segment) {
+                segments.update(segment.name, segment.added, segment.removed, segment.till);
+            });
+        }
+    }
+}

package/esm/utils/inputValidation/index.js

@@ -10,5 +10,4 @@ export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
-export { validatePreloadedData } from './preloadedData';
 export { validateEvaluationOptions } from './eventProperties';

package/esm/utils/settingsValidation/index.js

@@ -5,6 +5,7 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION }
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
+import { validateRolloutPlan } from '../../storages/setRolloutPlan';
 // Exported for telemetry
 export var base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -128,6 +129,9 @@ export function settingsValidation(config, validationParams) {
     // @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)
     var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.5.0-rc.0",
+  "version": "2.5.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/convertions/index.ts

@@ -1,3 +1,5 @@
+import { IBetweenMatcherData } from '../../dtos/types';
+
 export function zeroSinceHH(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
 }
@@ -5,3 +7,11 @@ export function zeroSinceHH(millisSinceEpoch: number): number {
 export function zeroSinceSS(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
 }
+
+export function betweenDateTimeTransform(betweenMatcherData: IBetweenMatcherData): IBetweenMatcherData {
+  return {
+    dataType: betweenMatcherData.dataType,
+    start: zeroSinceSS(betweenMatcherData.start),
+    end: zeroSinceSS(betweenMatcherData.end)
+  };
+}

package/src/evaluator/matchersTransform/index.ts

@@ -3,7 +3,7 @@ import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/
 import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
 import { numericTransform } from './unaryNumeric';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
+import { zeroSinceHH, zeroSinceSS, betweenDateTimeTransform } from '../convertions';
 import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
@@ -32,7 +32,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let type = matcherTypesMapper(matcherType);
     // As default input data type we use string (even for ALL_KEYS)
     let dataType = matcherDataTypes.STRING;
-    let value = undefined;
+    let value;
 
     if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
@@ -60,8 +60,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
-        value.start = zeroSinceSS(value.start);
-        value.end = zeroSinceSS(value.end);
+        value = betweenDateTimeTransform(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN_SEMVER) {

package/src/sdkClient/sdkClientMethodCS.ts

@@ -9,13 +9,15 @@ 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 { setRolloutPlan } from '../storages/setRolloutPlan';
+import { ISegmentsCacheSync } from '../storages/types';
 
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * 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 } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log, initialRolloutPlan } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -56,6 +58,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
       });
 
+      if (sharedStorage && initialRolloutPlan) {
+        setRolloutPlan(log, initialRolloutPlan, { segments: sharedStorage.segments as ISegmentsCacheSync, largeSegments: sharedStorage.largeSegments as ISegmentsCacheSync }, matchingKey);
+      }
+
       // 3 possibilities:
       // - Standalone mode: both syncManager and sharedSyncManager are defined
       // - Consumer mode: both syncManager and sharedSyncManager are undefined

package/src/sdkFactory/index.ts

@@ -14,6 +14,9 @@ import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
 import { DEBUG, OPTIMIZED } from '../utils/constants';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
+import { IStorageSync } from '../storages/types';
+import { getMatching } from '../utils/key';
 
 /**
  * Modular SDK factory
@@ -24,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 } } = 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.
@@ -57,7 +60,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+  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);
+  }
+
   const clients: Record<string, SplitIO.IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });

package/src/storages/getRolloutPlan.ts

@@ -0,0 +1,72 @@
+import SplitIO from '../../types/splitio';
+import { IStorageSync } from './types';
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
+import { ILogger } from '../logger/types';
+import { RolloutPlan } from './types';
+import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
+
+/**
+ * Gets the rollout plan snapshot from the given synchronous storage.
+ */
+export function getRolloutPlan(log: ILogger, storage: IStorageSync, options: SplitIO.RolloutPlanOptions = {}): RolloutPlan {
+
+  const { keys, exposeSegments } = options;
+  const { splits, segments, rbSegments } = storage;
+
+  log.debug(`storage: get feature flags${keys ? `, and memberships for keys: ${keys}` : ''}${exposeSegments ? ', and segments' : ''}`);
+
+  return {
+    splitChanges: {
+      ff: {
+        t: splits.getChangeNumber(),
+        s: -1,
+        d: splits.getAll(),
+      },
+      rbs: {
+        t: rbSegments.getChangeNumber(),
+        s: -1,
+        d: rbSegments.getAll(),
+      }
+    },
+    segmentChanges: exposeSegments ? // @ts-ignore accessing private prop
+      Object.keys(segments.segmentCache).map(segmentName => ({
+        name: segmentName, // @ts-ignore
+        added: setToArray(segments.segmentCache[segmentName] as Set<string>),
+        removed: [],
+        since: -1,
+        till: segments.getChangeNumber(segmentName)!
+      })) :
+      undefined,
+    memberships: keys ?
+      keys.reduce<Record<string, IMembershipsResponse>>((prev, key) => {
+        const matchingKey = getMatching(key);
+        if (storage.shared) { // Client-side segments
+          const sharedStorage = storage.shared(matchingKey);
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
+              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
+            },
+            ls: sharedStorage.largeSegments ? { // @ts-ignore
+              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
+            } : undefined
+          };
+        } else { // Server-side segments
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
+              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore
+                return storage.segments.segmentCache[segmentName].has(matchingKey) ?
+                  prev!.concat({ n: segmentName }) :
+                  prev;
+              }, [])
+            },
+            ls: {
+              k: []
+            }
+          };
+        }
+        return prev;
+      }, {}) :
+      undefined
+  };
+}

package/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;
     }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,8 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 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 { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 
 /**
@@ -17,9 +15,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 storages: Record<string, IStorageSync> = {};
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
@@ -40,31 +36,20 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     destroy() { },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared(matchingKey: string) {
-      if (!storages[matchingKey]) {
-        const segments = new MySegmentsCacheInMemory();
-        const largeSegments = new MySegmentsCacheInMemory();
-
-        if (preloadedData) {
-          setCache(log, preloadedData, { segments, largeSegments }, matchingKey);
-        }
-
-        storages[matchingKey] = {
-          splits: this.splits,
-          rbSegments: this.rbSegments,
-          segments,
-          largeSegments,
-          impressions: this.impressions,
-          impressionCounts: this.impressionCounts,
-          events: this.events,
-          telemetry: this.telemetry,
-          uniqueKeys: this.uniqueKeys,
-
-          destroy() { }
-        };
-      }
+    shared() {
+      return {
+        splits: this.splits,
+        rbSegments: this.rbSegments,
+        segments: new MySegmentsCacheInMemory(),
+        largeSegments: new MySegmentsCacheInMemory(),
+        impressions: this.impressions,
+        impressionCounts: this.impressionCounts,
+        events: this.events,
+        telemetry: this.telemetry,
+        uniqueKeys: this.uniqueKeys,
 
-      return storages[matchingKey];
+        destroy() { }
+      };
     },
   };
 
@@ -78,14 +63,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     storage.uniqueKeys.track = noopTrack;
   }
 
-  const matchingKey = getMatching(params.settings.core.key);
-  storages[matchingKey] = storage;
-
-  if (preloadedData) {
-    setCache(log, preloadedData, storage, matchingKey);
-    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
-  }
-
   return storage;
 }
 

package/src/storages/setRolloutPlan.ts

@@ -0,0 +1,71 @@
+import SplitIO from '../../types/splitio';
+import { IRBSegmentsCacheSync, ISegmentsCacheSync, ISplitsCacheSync } from './types';
+import { ILogger } from '../logger/types';
+import { isObject } from '../utils/lang';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+import { RolloutPlan } from './types';
+
+/**
+ * Validates if the given rollout plan is valid.
+ */
+export function validateRolloutPlan(log: ILogger, settings: SplitIO.ISettings): RolloutPlan | undefined {
+  const { mode, initialRolloutPlan } = settings;
+
+  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;
+}
+
+/**
+ * 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 setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  const { splits, rbSegments, segments, largeSegments } = storage;
+  const { splitChanges: { ff, rbs } } = rolloutPlan;
+
+  log.debug(`storage: set feature flags and segments${matchingKey ? ` for key ${matchingKey}` : ''}`);
+
+  if (splits && ff) {
+    splits.clear();
+    splits.update(ff.d, [], ff.t);
+  }
+
+  if (rbSegments && rbs) {
+    rbSegments.clear();
+    rbSegments.update(rbs.d, [], rbs.t);
+  }
+
+  const segmentChanges = rolloutPlan.segmentChanges;
+  if (matchingKey) { // add memberships data (client-side)
+    let memberships = rolloutPlan.memberships && rolloutPlan.memberships[matchingKey];
+    if (!memberships && segmentChanges) {
+      memberships = {
+        ms: {
+          k: segmentChanges.filter(segment => {
+            return segment.added.indexOf(matchingKey) > -1;
+          }).map(segment => ({ n: segment.name }))
+        }
+      };
+    }
+
+    if (memberships) {
+      if (memberships.ms) segments.resetSegments(memberships.ms!);
+      if (memberships.ls && largeSegments) largeSegments.resetSegments(memberships.ls!);
+    }
+  } else { // add segments data (server-side)
+    if (segmentChanges) {
+      segments.clear();
+      segmentChanges.forEach(segment => {
+        segments.update(segment.name, segment.added, segment.removed, segment.till);
+      });
+    }
+  }
+}

package/src/storages/types.ts

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse } from '../dtos/types';
+import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse, IMembershipsResponse, ISegmentChangesResponse, ISplitChangesResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { ISettings } from '../types';
@@ -505,7 +505,7 @@ export interface IStorageFactoryParams {
    */
   onReadyCb: (error?: any) => void,
   /**
-   * For emitting SDK_READY_FROM_CACHE event in consumer mode with Redis and standalone mode with preloaded data
+   * For emitting SDK_READY_FROM_CACHE event in consumer mode with Redis to allow immediate evaluations
    */
   onReadyFromCacheCb: () => void,
 }
@@ -520,3 +520,21 @@ export type IStorageAsyncFactory = SplitIO.StorageAsyncFactory & {
   readonly type: SplitIO.StorageType,
   (params: IStorageFactoryParams): IStorageAsync
 }
+
+export type RolloutPlan = {
+  /**
+   * Feature flags and rule-based segments.
+   */
+  splitChanges: ISplitChangesResponse;
+  /**
+   * Optional map of matching keys to their memberships.
+   */
+  memberships?: {
+    [matchingKey: string]: IMembershipsResponse;
+  };
+  /**
+   * Optional list of standard segments.
+   * This property is ignored if `memberships` is provided.
+   */
+  segmentChanges?: ISegmentChangesResponse[];
+};

package/src/types.ts

@@ -1,6 +1,7 @@
 import SplitIO from '../types/splitio';
 import { ISplitFiltersValidation } from './dtos/types';
 import { ILogger } from './logger/types';
+import { RolloutPlan } from './storages/types';
 
 /**
  * SplitIO.ISettings interface extended with private properties for internal use
@@ -10,6 +11,7 @@ export interface ISettings extends SplitIO.ISettings {
     __splitFiltersValidation: ISplitFiltersValidation;
   };
   readonly log: ILogger;
+  readonly initialRolloutPlan?: RolloutPlan;
 }
 
 /**

package/src/utils/inputValidation/index.ts

@@ -10,5 +10,4 @@ export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
-export { validatePreloadedData } from './preloadedData';
 export { validateEvaluationOptions } from './eventProperties';

package/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/setRolloutPlan';
 
 // 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) {

package/types/splitio.d.ts

@@ -351,9 +351,10 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
    */
   features?: SplitIO.MockedFeaturesMap;
   /**
-   * Data to initialize the SDK storage with. If provided and valid, the SDK will be ready from cache immediately.
+   * Rollout plan object (i.e., feature flags and segment definitions) to initialize the SDK storage with. If provided and valid, the SDK will be ready from cache immediately.
+   * This object is derived from calling the Node.js SDK’s `getRolloutPlan` method.
    */
-  preloadedData?: SplitIO.PreloadedData;
+  initialRolloutPlan?: SplitIO.RolloutPlan;
   /**
    * SDK Startup settings.
    */
@@ -559,7 +560,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 +1026,28 @@ declare namespace SplitIO {
     type: NodeSyncStorage | NodeAsyncStorage | BrowserStorage;
     prefix?: string;
     options?: Object;
-  }
+  };
   /**
-   * Defines the format of rollout plan data to preload the factory storage (cache).
+   * A JSON-serializable plain object that defines the format of rollout plan data to preload the SDK cache with feature flags and segments.
    */
-  type PreloadedData = {
-    /**
-     * Change number of feature flags.
-     */
-    since: number;
-    /**
-     * List of feature flags.
-     */
-    flags: Object[],
-    /**
-     * Change number of rule-based segments.
-     */
-    rbSince?: number,
-    /**
-     * List of rule-based segments.
-     */
-    rbSegments?: Object[],
+  type RolloutPlan = Object;
+  /**
+   * Options for the `factory.getRolloutPlan` method.
+   */
+  type RolloutPlanOptions = {
     /**
-     * Optional map of user keys to their memberships.
+     * Optional list of keys to generate the rollout plan snapshot with the memberships of the given keys.
+     *
+     * @defaultValue `undefined`
      */
-    memberships?: {
-      [key: string]: Object
-    },
+    keys?: SplitKey[];
     /**
-     * Optional map of segments to their list of keys.
-     * This property is ignored if `memberships` is provided.
+     * Optional flag to expose segments data in the rollout plan snapshot.
+     *
+     * @defaultValue `false`
      */
-    segments?: {
-      [segmentName: string]: string[]
-    },
-  }
+    exposeSegments?: boolean;
+  };
   /**
    * 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 +1070,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.
    */
@@ -1606,10 +1594,17 @@ declare namespace SplitIO {
     /**
      * Returns the current snapshot of the SDK rollout plan in cache.
      *
-     * @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.
+     * Wait for the SDK client to be ready before calling this method.
+     *
+     * ```js
+     * await factory.client().ready();
+     * const rolloutPlan = factory.getRolloutPlan();
+     * ```
+     *
+     * @param options - An object of type RolloutPlanOptions for advanced options.
      * @returns The current snapshot of the SDK rollout plan.
      */
-    getCache(keys?: SplitKey[]): PreloadedData,
+    getRolloutPlan(options?: RolloutPlanOptions): RolloutPlan;
   }
   /**
    * This represents the interface for the SDK instance for server-side with asynchronous storage.