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

package/src/storages/pluggable/index.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCachePluggable } from './SplitsCachePluggable';
+import { DefinitionsCachePluggable } from './DefinitionsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
 import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
@@ -118,7 +118,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     });
 
     return {
-      splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+      definitions: new DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/src/storages/setRolloutPlan.ts

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { IRBSegmentsCacheSync, ISegmentsCacheSync, ISplitsCacheSync } from './types';
+import { IRBSegmentsCacheSync, ISegmentsCacheSync, IDefinitionsCacheSync } from './types';
 import { ILogger } from '../logger/types';
 import { isObject } from '../utils/lang';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
@@ -27,20 +27,20 @@ export function validateRolloutPlan(log: ILogger, settings: SplitIO.ISettings):
  * 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;
+export function setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage: { definitions?: IDefinitionsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  const { definitions, 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 (definitions && ff) {
+    definitions.clear();
+    definitions.update(ff.d || [], [], ff.t);
   }
 
   if (rbSegments && rbs) {
     rbSegments.clear();
-    rbSegments.update(rbs.d, [], rbs.t);
+    rbSegments.update(rbs.d || [], [], rbs.t);
   }
 
   const segmentChanges = rolloutPlan.segmentChanges;

package/src/storages/types.ts

@@ -194,49 +194,49 @@ export interface IPluggableStorageWrapper {
 
 /** Splits cache */
 
-export interface ISplitsCacheBase {
+export interface IDefinitionsCacheBase {
   update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
-  getSplit(name: string): MaybeThenable<IDefinition | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, IDefinition | null>>, // `fetchMany` in spec
+  get(name: string): MaybeThenable<IDefinition | null>,
+  getMany(names: string[]): MaybeThenable<Record<string, IDefinition | null>>, // `fetchMany` in spec
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
   getAll(): MaybeThenable<IDefinition[]>,
-  getSplitNames(): MaybeThenable<string[]>,
+  getNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
+  getNamesBySets(sets: string[]): MaybeThenable<Set<string>[]>
 }
 
-export interface ISplitsCacheSync extends ISplitsCacheBase {
+export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
   update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean,
-  getSplit(name: string): IDefinition | null,
-  getSplits(names: string[]): Record<string, IDefinition | null>,
+  get(name: string): IDefinition | null,
+  getMany(names: string[]): Record<string, IDefinition | null>,
   getChangeNumber(): number,
   getAll(): IDefinition[],
-  getSplitNames(): string[],
+  getNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): Set<string>[]
+  getNamesBySets(sets: string[]): Set<string>[]
 }
 
-export interface ISplitsCacheAsync extends ISplitsCacheBase {
+export interface IDefinitionsCacheAsync extends IDefinitionsCacheBase {
   update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
-  getSplit(name: string): Promise<IDefinition | null>,
-  getSplits(names: string[]): Promise<Record<string, IDefinition | null>>,
+  get(name: string): Promise<IDefinition | null>,
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>>,
   getChangeNumber(): Promise<number>,
   getAll(): Promise<IDefinition[]>,
-  getSplitNames(): Promise<string[]>,
+  getNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
+  getNamesBySets(sets: string[]): Promise<Set<string>[]>
 }
 
 /** Rule-Based Segments cache */
@@ -466,7 +466,7 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
  */
 
 export interface IStorageBase<
-  TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
+  TDefinitionsCache extends IDefinitionsCacheBase = IDefinitionsCacheBase,
   TRBSegmentsCache extends IRBSegmentsCacheBase = IRBSegmentsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
@@ -475,7 +475,7 @@ export interface IStorageBase<
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync = ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
-  splits: TSplitsCache,
+  definitions: TDefinitionsCache,
   rbSegments: TRBSegmentsCache,
   segments: TSegmentsCache,
   largeSegments?: TSegmentsCache,
@@ -490,7 +490,7 @@ export interface IStorageBase<
 }
 
 export interface IStorageSync extends IStorageBase<
-  ISplitsCacheSync,
+  IDefinitionsCacheSync,
   IRBSegmentsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
@@ -505,7 +505,7 @@ export interface IStorageSync extends IStorageBase<
 }
 
 export interface IStorageAsync extends IStorageBase<
-  ISplitsCacheAsync,
+  IDefinitionsCacheAsync,
   IRBSegmentsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -7,7 +7,7 @@ import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 
 /**
@@ -15,12 +15,12 @@ import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/c
  */
 export function fromObjectUpdaterFactory(
   splitsParser: IDefinitionsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: Pick<IStorageSync, 'definitions' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings,
 ): () => Promise<boolean> {
 
-  const log = settings.log, splitsCache = storage.splits;
+  const log = settings.log, definitions = storage.definitions;
   let startingUp = true;
 
   return function objectUpdater() {
@@ -52,17 +52,17 @@ export function fromObjectUpdaterFactory(
       });
 
       return Promise.all([
-        splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.update(splits, [], Date.now())
+        definitions.clear(), // required to sync removed splits from mock
+        definitions.update(splits, [], Date.now())
       ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
+        readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
 
         if (startingUp) {
           startingUp = false;
           Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then((cacheMetadata) => {
             // Emits SDK_READY_FROM_CACHE
             if (!cacheMetadata.initialCacheLoad) {
-              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+              readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
@@ -81,7 +81,7 @@ export function fromObjectUpdaterFactory(
  */
 export function fromObjectSyncTaskFactory(
   splitsParser: IDefinitionsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: Pick<IStorageSync, 'definitions' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings
 ): ISyncTask<[], boolean> {

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

@@ -22,12 +22,12 @@ export interface ISplitChangesResponse {
   ff?: {
     t: number,
     s?: number,
-    d: ISplit[]
+    d?: ISplit[] | null,
   },
   rbs?: {
     t: number,
     s?: number,
-    d: IRBSegment[]
+    d?: IRBSegment[] | null,
   }
 }
 
@@ -102,7 +102,7 @@ export function splitChangesFetcherFactory(params: ISdkFactoryContextSync): IDef
           lastProxyCheckTimestamp = undefined;
           return splitChangesFetcher(-1, undefined, undefined, -1)
             .then((splitChangesResponse: IDefinitionChangesResponse) =>
-              Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+              Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
                 .then(() => splitChangesResponse)
             );
         }

package/src/sync/polling/pollingManagerCS.ts

@@ -5,10 +5,10 @@ import { IStorageSync } from '../../storages/types';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { getMatching } from '../../utils/key';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 import { SdkUpdateMetadata } from '../../../types/splitio';
 import { IDefinitionChangesFetcher } from './fetchers/types';
 
@@ -45,7 +45,7 @@ export function pollingManagerCSFactory(
   }
 
   // smart pausing
-  readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
+  readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
     if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
     const usingSegments = usesSegmentsSync(storage);
     if (usingSegments !== mySegmentsSyncTask.isRunning()) {
@@ -66,7 +66,7 @@ export function pollingManagerCSFactory(
       if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
     }
     if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
-    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+    else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
 
     mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
     return mySegmentsSyncTask;

package/src/sync/polling/syncTasks/definitionsSyncTask.ts

@@ -23,7 +23,7 @@ export function definitionsSyncTaskFactory(
       definitionChangesFetcher,
       storage,
       settings.sync.__splitFiltersValidation,
-      readiness.splits,
+      readiness.definitions,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       isClientSide

package/src/sync/polling/types.ts

@@ -4,7 +4,7 @@ import { IStorageSync } from '../../storages/types';
 import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
-export interface IDefinitionsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: IDefinition | IRBSegment, changeNumber: number }], boolean> { }
+export interface IDefinitionsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, definitionUpdateNotification?: { payload: IDefinition | IRBSegment, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 

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

@@ -1,9 +1,9 @@
 import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
 import { IDefinitionChangesFetcher } from '../fetchers/types';
 import { IRBSegment, IDefinition, IDefinitionChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
-import { ISplitsEventEmitter } from '../../../readiness/types';
+import { IDefinitionsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
@@ -128,14 +128,14 @@ function convertInstantUpdateToDefinitionChanges(instantUpdate: InstantUpdate) {
 export function definitionChangesUpdaterFactory(
   log: ILogger,
   definitionChangesFetcher: IDefinitionChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
+  storage: Pick<IStorageBase, 'definitions' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
-  splitsEventEmitter?: ISplitsEventEmitter,
+  definitionsEventEmitter?: IDefinitionsEventEmitter,
   requestTimeoutBeforeReady = 0,
   retriesOnFailureBeforeReady = 0,
   isClientSide?: boolean
 ): DefinitionChangesUpdater {
-  const { splits, rbSegments, segments } = storage;
+  const { definitions, rbSegments, segments } = storage;
 
   let startingUp = true;
 
@@ -183,7 +183,7 @@ export function definitionChangesUpdaterFactory(
             const { added, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
             updatedDefinitions = names;
             log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, added.length, removed.length]);
-            ffUpdate = splits.update(added, removed, definitionChanges.d.till);
+            ffUpdate = definitions.update(added, removed, definitionChanges.d.till);
           }
 
           let rbsUpdate: MaybeThenable<boolean> = false;
@@ -201,9 +201,9 @@ export function definitionChangesUpdaterFactory(
 
             startingUp = false;
 
-            if (splitsEventEmitter) {
-              // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+            if (definitionsEventEmitter) {
+              // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events
@@ -212,7 +212,7 @@ export function definitionChangesUpdaterFactory(
                       type: updatedDefinitions.length > 0 ? definitionChangesFetcher.type === 'configs' ? CONFIGS_UPDATE : FLAGS_UPDATE : SEGMENTS_UPDATE,
                       names: updatedDefinitions.length > 0 ? updatedDefinitions : []
                     };
-                    splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
+                    definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, metadata);
                   }
                   return true;
                 });
@@ -234,6 +234,6 @@ export function definitionChangesUpdaterFactory(
     }
 
     // `getChangeNumber` never rejects or throws error
-    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
+    return Promise.all([definitions.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
   };
 }

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

@@ -8,7 +8,7 @@ import { SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
-import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../../storages/AbstractDefinitionsCacheSync';
 
 type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 

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,9 +1,9 @@
 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';
@@ -16,22 +16,22 @@ 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, definitionsSyncTask: IDefinitionsSyncTask, 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;
@@ -39,7 +39,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, definiti
         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, definiti
             } else {
               backoff.reset();
               cdnBypass = true;
-              __handleSplitUpdateCall();
+              __handleDefinitionUpdateCall();
             }
           }
         });
@@ -93,7 +93,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, definiti
           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, definiti
      * @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';