@splitsoftware/splitio-commons 1.16.1-rc.10 → 1.16.1-rc.12

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -16,22 +16,11 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
-  /**
-   * Removes list of segments from localStorage
-   * @NOTE this method is not being used at the moment.
-   */
-  clear() {
-    this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
-
-    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-    // We could optimize next sentence, since it implies iterating over all localStorage items
-    this.resetSegments([]);
-  }
-
   addToSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) === DEFINED) return false;
       localStorage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
@@ -44,6 +33,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
       localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
@@ -56,41 +46,22 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   *
-   * @param {string[]} names list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(names: string[], changeNumber?: number): boolean {
-    try {
-      if (changeNumber) {
-        localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      } else {
-        localStorage.removeItem(this.keys.buildTillKey());
-      }
-    } catch (e) {
-      this.log.error(e);
-    }
-
-    let isDiff = false;
-    let index;
-
+  getRegisteredSegments(): string[] {
     // Scan current values from localStorage
-    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
+    return Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
       if (segmentName) {
         accum.push(segmentName);
       } else {
-        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
         segmentName = this.keys.extractOldSegmentKey(key);
 
         if (segmentName) { // this was an old segment key, let's clean up.
           const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
           try {
             // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+            if (!localStorage.getItem(newSegmentKey)) {
               localStorage.setItem(newSegmentKey, DEFINED);
               // we are migrating a segment, let's track it.
               accum.push(segmentName);
@@ -104,46 +75,21 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
       return accum;
     }, [] as string[]);
-
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentNames.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentNames.length !== names.length) {
-      isDiff = true;
-
-      storedSegmentNames.forEach(name => this.removeFromSegment(name));
-      names.forEach(name => this.addToSegment(name));
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        storedSegmentNames.forEach(name => this.removeFromSegment(name));
-        names.forEach(name => this.addToSegment(name));
-      }
-    }
-
-    return isDiff;
-  }
-
-  getRegisteredSegments(): string[] {
-    return Object.keys(localStorage).reduce<string[]>((accum, key) => {
-      const segmentName = this.keys.extractSegmentName(key);
-      if (segmentName) accum.push(segmentName);
-      return accum;
-    }, []);
   }
 
   getKeysCount() {
     return 1;
   }
 
+  setChangeNumber(name?: string, changeNumber?: number) {
+    try {
+      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else localStorage.removeItem(this.keys.buildTillKey());
+    } catch (e) {
+      this.log.error(e);
+    }
+  }
+
   getChangeNumber() {
     const n = -1;
     let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -9,17 +9,17 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
   private segmentCache: Record<string, boolean> = {};
   private cn?: number;
 
-  clear() {
-    this.segmentCache = {};
-  }
-
   addToSegment(name: string): boolean {
+    if (this.segmentCache[name]) return false;
+
     this.segmentCache[name] = true;
 
     return true;
   }
 
   removeFromSegment(name: string): boolean {
+    if (!this.segmentCache[name]) return false;
+
     delete this.segmentCache[name];
 
     return true;
@@ -29,49 +29,9 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return this.segmentCache[name] === true;
   }
 
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   * @NOTE based on the way we use segments in the browser, this way is the best option
-   *
-   * @param {string[]} names list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(names: string[], changeNumber?: number): boolean {
-    this.cn = changeNumber;
-    let isDiff = false;
-    let index;
-
-    const storedSegmentKeys = Object.keys(this.segmentCache);
 
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentKeys.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentKeys.length !== names.length) {
-      isDiff = true;
-
-      this.segmentCache = {};
-      names.forEach(s => {
-        this.addToSegment(s);
-      });
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        this.segmentCache = {};
-        names.forEach(s => {
-          this.addToSegment(s);
-        });
-      }
-    }
-
-    return isDiff;
+  setChangeNumber(name?: string, changeNumber?: number) {
+    this.cn = changeNumber;
   }
 
   getChangeNumber() {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -51,7 +51,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       spC: this.splits && this.splits.getSplitNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
-      lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+      lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
       lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),

package/src/storages/types.ts

@@ -1,4 +1,5 @@
-import { MaybeThenable, ISplit } from '../dtos/types';
+import { MaybeThenable, ISplit, IMySegmentsResponse } 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 { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { ISet } from '../utils/lang/sets';
@@ -218,7 +219,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   removeSplits(names: string[]): boolean[],
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean,
+  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -268,9 +269,9 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean
-  getChangeNumber(name: string): number
-  resetSegments(names: string[], changeNumber?: number): boolean // only for Sync Client-Side
+  setChangeNumber(name: string, changeNumber: number): boolean | void
+  getChangeNumber(name?: string): number
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -11,11 +11,12 @@ export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): I
   return function mySegmentsFetcher(
     userMatchingKey: string,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ): Promise<IMembershipsResponse> {
 
-    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache);
+    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
     return mySegmentsPromise.then(resp => resp.json());

package/src/sync/polling/fetchers/types.ts

@@ -19,5 +19,6 @@ export type ISegmentChangesFetcher = (
 export type IMySegmentsFetcher = (
   userMatchingKey: string,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<IMembershipsResponse>

package/src/sync/polling/types.ts

@@ -1,22 +1,21 @@
-import { IMembershipsResponse, ISplit } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
-export type MySegmentsData = IMembershipsResponse | {
-  /* segment type */
-  isLS?: boolean
-  /* segment name */
-  name: string
-  /* action: `true` for add, and `false` for delete */
-  add: boolean
-}[]
+export type MySegmentsData = {
+  type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE
+  cn: number
+  added: string[]
+  removed: string[]
+}
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -6,8 +6,10 @@ import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
+import { IMembershipsResponse } from '../../../dtos/types';
+import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 
-type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -36,23 +38,16 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: MySegmentsData) {
+  function updateSegments(segmentsData: IMembershipsResponse | MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Add/Delete the segment names
-      segmentsData.forEach(({ isLS, name, add }) => {
-        const cache = isLS ? largeSegments : segments;
-        if (cache!.isInSegment(name) !== add) {
-          shouldNotifyUpdate = true;
-          if (add) cache!.addToSegment(name);
-          else cache!.removeFromSegment(name);
-        }
-      });
+    if ((segmentsData as MySegmentsData).type !== undefined) {
+      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIPS_LS_UPDATE ?
+        largeSegments!.resetSegments(segmentsData as MySegmentsData) :
+        segments.resetSegments(segmentsData as MySegmentsData);
     } else {
-      // Reset the list of segment names
-      shouldNotifyUpdate = segments.resetSegments((segmentsData.ms?.k || []).map((segment) => segment.n), segmentsData.ms?.cn);
-      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData.ls?.k || []).map((segment) => segment.n), segmentsData.ls?.cn) || shouldNotifyUpdate;
+      shouldNotifyUpdate = segments.resetSegments((segmentsData as IMembershipsResponse).ms || {});
+      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
     }
 
     // Notify update if required
@@ -62,12 +57,12 @@ export function mySegmentsUpdaterFactory(
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean): Promise<boolean> {
+  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean, till?: number): Promise<boolean> {
     const updaterPromise: Promise<boolean> = segmentsData ?
       // If segmentsData is provided, there is no need to fetch mySegments
       new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
-      mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 
@@ -97,9 +92,10 @@ export function mySegmentsUpdaterFactory(
    *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
    *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
    * @param {boolean | undefined} noCache true to revalidate data to fetch
+   * @param {boolean | undefined} till query param to bypass CDN requests
    */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
-    return _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
+    return _mySegmentsUpdater(0, segmentsData, noCache, till);
   };
 
 }

package/src/sync/streaming/AuthClient/index.ts

@@ -14,7 +14,7 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
 
   /**
    * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-   * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+   * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
    */
   return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
     return fetchAuth(userKeys)

package/src/sync/streaming/SSEHandler/index.ts

@@ -1,9 +1,9 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE_V3, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { IControlData, INotificationError, INotificationMessage, IOccupancyData } from './types';
+import { INotificationError, INotificationMessage } from './types';
 import { ILogger } from '../../../logger/types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
@@ -75,26 +75,24 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
       // we only handle update events if streaming is up
-      // @ts-expect-error
-      const type = parsedData.type || parsedData.t;
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1) return;
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1) return;
 
-      switch (type) {
+      switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MY_SEGMENTS_UPDATE_V3:
-        case MY_LARGE_SEGMENTS_UPDATE:
+        case MEMBERSHIPS_MS_UPDATE:
+        case MEMBERSHIPS_LS_UPDATE:
         case SPLIT_KILL:
-          pushEmitter.emit(type, parsedData);
+          pushEmitter.emit(parsedData.type, parsedData);
           break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent((parsedData as IOccupancyData).metrics.publishers, channel, timestamp);
+          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
           break;
         case CONTROL:
-          notificationKeeper.handleControlEvent((parsedData as IControlData).controlType, channel, timestamp);
+          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
           break;
 
         default:

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V3 } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -19,8 +19,8 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-interface IMySegmentsUpdateData<T extends string> {
-  t: T,
+interface IMembershipUpdateData<T extends string> {
+  type: T,
   cn: number,
   n?: string[],
   c?: Compression,
@@ -31,9 +31,9 @@ interface IMySegmentsUpdateData<T extends string> {
   s?: number, // seed for hash function
 }
 
-export interface IMySegmentsUpdateV3Data extends IMySegmentsUpdateData<MY_SEGMENTS_UPDATE_V3> { }
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> { }
 
-export interface IMyLargeSegmentsUpdateData extends IMySegmentsUpdateData<MY_LARGE_SEGMENTS_UPDATE> { }
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> { }
 
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
@@ -68,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }