@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

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

@@ -3,7 +3,7 @@ import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
+import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
 
@@ -38,7 +38,7 @@ export function segmentChangesUpdaterFactory(
   }
 
   function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
+    log.debug(`${LOG_PREFIX_SYNC}Processing segment ${segmentName}`);
     const sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
     return sincePromise.then(since => {
@@ -47,14 +47,14 @@ export function segmentChangesUpdaterFactory(
         false :
         segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
           return Promise.all(changes.map(x => {
-            log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);
           });
         }).catch(error => {
           if (retries) {
-            log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Retrying fetch of segment ${segmentName} (attempt #${retries}). Reason: ${error}`);
+            log.warn(`${LOG_PREFIX_SYNC}Retrying fetch of segment ${segmentName} (attempt #${retries}). Reason: ${error}`);
             return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
           }
           throw error;
@@ -73,7 +73,7 @@ export function segmentChangesUpdaterFactory(
    * @param till - till target for the provided segmentName, for CDN bypass.
    */
   return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);
+    log.debug(`${LOG_PREFIX_SYNC}Started segments update`);
 
     // If not a segment name provided, read list of available segments names to be updated.
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
@@ -102,9 +102,9 @@ export function segmentChangesUpdaterFactory(
           // If the operation is forbidden, it may be due to permissions. Destroy the SDK instance.
           // @TODO although factory status is destroyed, synchronization is not stopped
           if (readiness) readiness.setDestroyed();
-          log.error(`${LOG_PREFIX_INSTANTIATION}: you passed a client-side type authorizationKey, please grab an SDK Key from the Split user interface that is of type server-side.`);
+          log.error(`${LOG_PREFIX_INSTANTIATION}: you passed a client-side type authorizationKey, please grab an SDK Key from Harness UI that is of type server-side.`);
         } else {
-          log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Error while doing fetch of segments. ${error}`);
+          log.warn(`${LOG_PREFIX_SYNC}Error while doing fetch of segments. ${error}`);
         }
 
         return false;

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

@@ -1,5 +1,5 @@
 import { IFetchAuth } from '../../../services/types';
-import { IAuthenticate, IAuthToken } from './types';
+import { IAuthenticate, IJwtCredentialV2 } from './types';
 import { objectAssign } from '../../../utils/lang/objectAssign';
 import { encodeToBase64 } from '../../../utils/base64';
 import { decodeJWTtoken } from '../../../utils/jwt';
@@ -16,7 +16,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 userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
    */
-  return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
+  return function authenticate(userKeys?: string[]): Promise<IJwtCredentialV2> {
     return fetchAuth(userKeys)
       .then(resp => resp.json())
       .then(json => {

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

@@ -1,20 +1,23 @@
 import { IDecodedJWTToken } from '../../../utils/jwt/types';
 
-export interface IAuthTokenPushEnabled {
-  pushEnabled: true
-  token: string
+export type IJwtCredentialV2 = {
+  pushEnabled: boolean
+  token: string // empty string ("") when `"pushEnabled": false`
   decodedToken: IDecodedJWTToken
   channels: { [channel: string]: string[] }
   connDelay?: number
 }
 
-export interface IAuthTokenPushDisabled {
-  pushEnabled: false
-  token: ''
+export type IJwtCredentialV3 = {
+  token: string
+  decodedToken: IDecodedJWTToken
+  channels: { [channel: string]: string[] }
+  config?: {
+    streaming?: {
+      delay?: number
+      enabled?: boolean
+    } | null;
+  } | null;
 }
 
-export type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled
-
-export type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>
-
-export type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>
+export type IAuthenticate = (userKeys?: string[]) => Promise<IJwtCredentialV2>

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

@@ -5,7 +5,7 @@ import { ISettings } from '../../../types';
 import { checkIfServerSide } from '../../../utils/key';
 import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { IAuthTokenPushEnabled } from '../AuthClient/types';
+import { IJwtCredentialV2 } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
 const ABLY_API_VERSION = '1.1';
@@ -66,7 +66,7 @@ export class SSEClient implements ISSEClient {
   /**
    * Open the connection with a given authToken
    */
-  open(authToken: IAuthTokenPushEnabled) {
+  open(authToken: IJwtCredentialV2) {
     this.close(); // it closes connection if previously opened
 
     const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {

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

@@ -1,4 +1,4 @@
-import { IAuthTokenPushEnabled } from '../AuthClient/types';
+import { IJwtCredentialV2 } from '../AuthClient/types';
 
 export interface ISseEventHandler {
   handleError: (ev: Event) => any;
@@ -7,7 +7,7 @@ export interface ISseEventHandler {
 }
 
 export interface ISSEClient {
-  open(authToken: IAuthTokenPushEnabled): void,
+  open(authToken: IJwtCredentialV2): void,
   close(): void,
   setEventHandler(handler: ISseEventHandler): void
 }

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

@@ -1,7 +1,7 @@
 import { ITelemetryTracker } from '../../../trackers/types';
 import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
 import { StreamingEventType } from '../../submitters/types';
-import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
+import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
 import { IPushEventEmitter } from '../types';
 
 const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
@@ -84,7 +84,7 @@ export function notificationKeeperFactory(pushEmitter: IPushEventEmitter, teleme
             c.cTime = timestamp;
             if (controlType === ControlType.STREAMING_DISABLED) {
               telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
-              pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+              pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
             } else if (hasPublishers) {
               if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {
                 telemetryTracker.streamingEvent(STREAMING_STATUS, PAUSED);

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -56,7 +56,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       if (isRetryableError(errorWithParsedData)) {
         pushEmitter.emit(PUSH_RETRYABLE_ERROR);
       } else {
-        pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+        pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
       }
     },
 

package/src/sync/streaming/UpdateWorkers/{SplitsUpdateWorker.ts → DefinitionsUpdateWorker.ts}

@@ -1,14 +1,14 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
+import { IRBSegment, IDefinition } from '../../../dtos/types';
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
 import { ILogger } from '../../../logger/types';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
-import { ISplitsEventEmitter } from '../../../readiness/types';
-import { IRBSegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
+import { IDefinitionsEventEmitter } from '../../../readiness/types';
+import { IRBSegmentsCacheSync, IDefinitionsCacheSync, IStorageSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
-import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { InstantUpdate } from '../../polling/updaters/splitChangesUpdater';
+import { ISegmentsSyncTask, IDefinitionsSyncTask } from '../../polling/types';
+import { InstantUpdate } from '../../polling/updaters/definitionChangesUpdater';
 import { RB_SEGMENT_UPDATE } from '../constants';
 import { parseFFUpdatePayload } from '../parseUtils';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
@@ -16,30 +16,30 @@ import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES }
 import { IUpdateWorker } from './types';
 
 /**
- * SplitsUpdateWorker factory
+ * DefinitionsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
+export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, definitionsSyncTask: IDefinitionsSyncTask, definitionsEventEmitter: IDefinitionsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killDefinition(event: ISplitKillData): void } {
 
-  const ff = SplitsUpdateWorker(storage.splits);
-  const rbs = SplitsUpdateWorker(storage.rbSegments);
+  const ff = DefinitionsUpdateWorker(storage.definitions);
+  const rbs = DefinitionsUpdateWorker(storage.rbSegments);
 
-  function SplitsUpdateWorker(cache: ISplitsCacheSync | IRBSegmentsCacheSync) {
+  function DefinitionsUpdateWorker(cache: IDefinitionsCacheSync | IRBSegmentsCacheSync) {
     let maxChangeNumber = -1;
     let handleNewEvent = false;
     let isHandlingEvent: boolean;
     let cdnBypass: boolean;
     let instantUpdate: InstantUpdate | undefined;
-    const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+    const backoff = new Backoff(__handleDefinitionUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-    function __handleSplitUpdateCall() {
+    function __handleDefinitionUpdateCall() {
       isHandlingEvent = true;
       if (maxChangeNumber > cache.getChangeNumber()) {
         handleNewEvent = false;
         // fetch splits revalidating data if cached
-        splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
+        definitionsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
           if (!isHandlingEvent) return; // halt if `stop` has been called
           if (handleNewEvent) {
-            __handleSplitUpdateCall();
+            __handleDefinitionUpdateCall();
           } else {
             if (instantUpdate) telemetryTracker.trackUpdatesFromSSE(SPLITS);
             // fetch new registered segments for server-side API. Not retrying on error
@@ -64,7 +64,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
             } else {
               backoff.reset();
               cdnBypass = true;
-              __handleSplitUpdateCall();
+              __handleDefinitionUpdateCall();
             }
           }
         });
@@ -79,7 +79,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
        *
        * @param changeNumber - change number of the notification
        */
-      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: ISplit | IRBSegment) {
+      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: IDefinition | IRBSegment) {
         const currentChangeNumber = cache.getChangeNumber();
 
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
@@ -93,7 +93,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
           instantUpdate = { payload, changeNumber, type };
         }
 
-        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+        if (backoff.timeoutID || !isHandlingEvent) __handleDefinitionUpdateCall();
         backoff.reset();
       },
       stop() {
@@ -128,10 +128,10 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
      * @param splitName - name of split to kill
      * @param defaultTreatment - default treatment value
      */
-    killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-      if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+    killDefinition({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
+      if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
         // trigger an SDK_UPDATE if Split was killed locally
-        splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
+        definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, true);
       }
       // queues the SplitChanges fetch (only if changeNumber is newer)
       ff.put({ changeNumber } as ISplitUpdateData);

package/src/sync/streaming/constants.ts

@@ -6,7 +6,7 @@ export const SECONDS_BEFORE_EXPIRATION = 600;
  * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
  * triggers `handleNonRetryableError` call
  */
-export const PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+export const PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
 /**
  * emitted on SSE and Authenticate recoverable errors
  * triggers `handleRetryableError` call
@@ -19,7 +19,7 @@ export const PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
 export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 
 /**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NON_RETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
  * triggers `startPolling` and `stopWorkers` calls
  */
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';

package/src/sync/streaming/parseUtils.ts

@@ -1,8 +1,8 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { hash } from '../../utils/murmur3/murmur3';
-import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { IRBSegment, ISplit } from '../../dtos/types';
+import { Compression, IMembershipMSUpdateData } from './SSEHandler/types';
+import { IRBSegment, IDefinition } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -35,20 +35,20 @@ function decompress(data: string, compression: Compression) {
 }
 
 /**
- * Decode, decompress and parse the provided 'data' into a KeyList object
+ * Decode, decompress and parse the provided 'data' into an object of type T
  *
  * @param data - base64 encoded string
  * @param compression - 1 GZIP, 2 ZLIB
  * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns keyList
+ * @returns parsed object
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
-  const binKeyList = decompress(data, compression);
-  let strKeyList = Uint8ArrayToString(binKeyList);
-  // replace numbers to strings, to avoid losing precision
-  if (avoidPrecisionLoss) strKeyList = strKeyList.replace(/\d+/g, '"$&"');
-  return JSON.parse(strKeyList);
+export function parseCompressedData<T>(data: string, compression: Compression, avoidPrecisionLoss = true): T {
+  const binData = decompress(data, compression);
+  let str = Uint8ArrayToString(binData);
+  // replace numbers to strings, to avoid losing precision (e.g., 64-bit IDs in KeyList)
+  if (avoidPrecisionLoss) str = str.replace(/\d+/g, '"$&"');
+  return JSON.parse(str) as T;
 }
 
 /**
@@ -82,9 +82,9 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 /**
  * Parse feature flags notifications for instant feature flag updates
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | IRBSegment | undefined {
+export function parseFFUpdatePayload(compression: Compression, data: string): IDefinition | IRBSegment | undefined {
   return compression > 0 ?
-    parseKeyList(data, compression, false) :
+    parseCompressedData<IDefinition | IRBSegment>(data, compression, false) :
     JSON.parse(decodeFromBase64(data));
 }
 

package/src/sync/streaming/pushManager.ts

@@ -6,17 +6,17 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { IJwtCredentialV2 } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -55,8 +55,8 @@ export function pushManagerFactory(
   // init workers
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
   const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
-  // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+  const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
@@ -67,10 +67,10 @@ export function pushManagerFactory(
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
 
-  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
   // It is used to halt the `connectPush` process if it was in progress.
   let disconnected: boolean | undefined;
-  // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+  // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
   // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
   let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
 
@@ -81,7 +81,7 @@ export function pushManagerFactory(
   let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
   let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
 
-  function scheduleTokenRefreshAndSse(authData: IAuthTokenPushEnabled) {
+  function scheduleTokenRefreshAndSse(authData: IJwtCredentialV2) {
     // clear scheduled tasks if exist
     if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
@@ -117,11 +117,11 @@ export function pushManagerFactory(
       function (authData) {
         if (disconnected) return;
 
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+        // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
         // close the sseClient in case the org has been bloqued while the instance was connected to streaming
         if (!authData.pushEnabled) {
           log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -140,7 +140,7 @@ export function pushManagerFactory(
         // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
         if (error.statusCode >= 400 && error.statusCode < 500) {
           telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -168,7 +168,7 @@ export function pushManagerFactory(
 
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
-    splitsUpdateWorker.stop();
+    definitionsUpdateWorker.stop();
     if (userKey) forOwn(clients, ({ worker }) => worker.stop());
     else segmentsUpdateWorker!.stop();
   }
@@ -183,7 +183,7 @@ export function pushManagerFactory(
 
   /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
 
-  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+  pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
     disabled = true;
     // Note: `stopWorkers` is been called twice, but it is not harmful
     disconnectPush();
@@ -218,9 +218,9 @@ export function pushManagerFactory(
 
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
-  pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-  pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+  pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+  pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+  pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {
@@ -243,7 +243,7 @@ export function pushManagerFactory(
       case UpdateStrategy.KeyList: {
         let keyList: KeyList, added: Set<string>, removed: Set<string>;
         try {
-          keyList = parseKeyList(parsedData.d!, parsedData.c!);
+          keyList = parseCompressedData<KeyList>(parsedData.d!, parsedData.c!);
           added = new Set(keyList.a);
           removed = new Set(keyList.r);
         } catch (e) {

package/src/sync/streaming/types.ts

@@ -7,7 +7,7 @@ import { ControlType } from './constants';
 // Internal SDK events, subscribed by SyncManager and PushManager
 export type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP'
 export type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
-export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+export type PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
@@ -22,7 +22,7 @@ export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :

package/src/sync/submitters/impressionsSubmitter.ts

@@ -3,20 +3,20 @@ import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
 import { ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { EntityType, ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, entityType: EntityType | undefined, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 
   forOwn(groupedByFeature, (value, name) => {
     dto.push({
-      f: name, // Test Name
+      f: name, // Definition type
       i: value.map(entry => { // Key Impressions
-        const keyImpression = {
+        return {
           k: entry.keyName, // Key
           t: entry.treatment, // Treatment
           m: entry.time, // Timestamp
@@ -24,10 +24,9 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           r: sendLabels ? entry.label : undefined, // Rule
           b: entry.bucketingKey, // Bucketing Key
           pt: entry.pt, // Previous time
-          properties: entry.properties // Properties
+          properties: entry.properties, // Properties
+          et: entityType, // Definition type
         };
-
-        return keyImpression;
       })
     });
   });
@@ -43,11 +42,12 @@ export function impressionsSubmitterFactory(params: ISdkFactoryContextSync) {
   const {
     settings: { log, scheduler: { impressionsRefreshRate }, core: { labelsEnabled } },
     splitApi: { postTestImpressionsBulk },
-    storage: { impressions }
+    storage: { impressions },
+    entityType
   } = params;
 
   // retry impressions only once.
-  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
+  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
 
   // register impressions submitter to be executed when impressions cache is full
   impressions.setOnFullQueueCb(() => {

package/src/sync/submitters/telemetrySubmitter.ts

@@ -119,7 +119,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness } = params;
   const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
@@ -135,7 +135,6 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
     telemetry.recordTimeUntilReadyFromCache(stopTimer());
   });
 
-  sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
     telemetry.recordTimeUntilReady(stopTimer());
 

package/src/sync/submitters/types.ts

@@ -2,6 +2,7 @@
 import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
+import { EntityType } from '../../sdkFactory/types';
 
 type ImpressionPayload = {
   /** Matching Key */
@@ -20,6 +21,8 @@ type ImpressionPayload = {
   pt?: number;
   /** Stringified JSON object with properties */
   properties?: string;
+  /** Definition type */
+  et?: EntityType,
 };
 
 export type ImpressionsPayload = {

package/src/sync/syncManagerOnline.ts

@@ -9,8 +9,10 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
+import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
+import { IDefinitionChangesFetcher } from './polling/fetchers/types';
 
 /**
  * Online SyncManager factory.
@@ -19,10 +21,12 @@ import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
+ * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
+  pollingManagerFactory?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
+  definitionChangesFetcherFactory = splitChangesFetcherFactory
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -33,7 +37,7 @@ export function syncManagerOnlineFactory(
     const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionChangesFetcherFactory(params));
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
@@ -98,7 +102,7 @@ export function syncManagerOnlineFactory(
           if (startFirstTime) {
             // Emits SDK_READY_FROM_CACHE
             if (!cacheMetadata.initialCacheLoad) {
-              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+              readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
 
           }