Separate getRolloutPlan and setRolloutPlan for bundle size reduction

Author: EmilianoSanchez

src/sdkClient/sdkClientMethodCS.ts

@@ -9,7 +9,7 @@ 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/dataLoader';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { ISegmentsCacheSync } from '../storages/types';
 
 /**

src/sdkFactory/index.ts

@@ -14,7 +14,7 @@ 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/dataLoader';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { IStorageSync } from '../storages/types';
 import { getMatching } from '../utils/key';
 

src/storages/__tests__/dataLoader.spec.ts

@@ -4,7 +4,8 @@ import { fullSettings } from '../../utils/settingsValidation/__tests__/settings.
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { IRBSegment, ISplit } from '../../dtos/types';
 
-import { validateRolloutPlan, setRolloutPlan, getRolloutPlan } from '../dataLoader';
+import { validateRolloutPlan, setRolloutPlan } from '../setRolloutPlan';
+import { getRolloutPlan } from '../getRolloutPlan';
 
 const otherKey = 'otherKey';
 const expectedRolloutPlan = {

src/storages/dataLoader.ts

@@ -0,0 +1,73 @@
+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.
+ * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
+ * Otherwise, the segments data is returned.
+ */
+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: [],
+        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
+  };
+}

src/storages/getRolloutPlan.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);
+      });
+    }
+  }
+}

src/storages/setRolloutPlan.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';
@@ -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[];
+};

src/storages/types.ts

@@ -1,7 +1,7 @@
 import SplitIO from '../types/splitio';
 import { ISplitFiltersValidation } from './dtos/types';
 import { ILogger } from './logger/types';
-import { RolloutPlan } from './storages/dataLoader';
+import { RolloutPlan } from './storages/types';
 
 /**
  * SplitIO.ISettings interface extended with private properties for internal use

src/types.ts

@@ -7,7 +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';
+import { validateRolloutPlan } from '../../storages/setRolloutPlan';
 
 // Exported for telemetry
 export const base = {