@splitsoftware/splitio-commons 3.1.1-rc.11 → 3.1.1-rc.12

package/src/services/types.ts

@@ -1,4 +1,4 @@
-import { IFetchAuth } from '../sync/streaming/AuthClient/types';
+import { IDecodedJWTToken } from '../utils/jwt/types';
 
 export type IRequestOptions = {
 	method?: string,
@@ -30,14 +30,31 @@ export type NetworkError = Error & { statusCode?: number }
 // Reduced version of Fetch API
 export type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>
 
-// IFetch specialization
-export type IHealthCheckAPI = () => Promise<boolean>
-
 export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean) => Promise<IResponse>
 
 // @TODO: remove `newVersionHeader` and `useJwt` arguments when all service endpoints are migrated to the new auth mechanism
 export type ISecureSplitHttpClient = ((url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean, useJwt?: boolean) => Promise<IResponse>) & { stop(): void }
 
+export type IJwtCredential = {
+	token: string; // empty string ("") when `"pushEnabled": false`
+	decodedToken: IDecodedJWTToken
+	channels: { [channel: string]: string[] }
+	// /api/v2/auth fields
+	pushEnabled?: boolean | null;
+	connDelay?: number | null;
+	// /api/v3/auth fields
+	config?: {
+		streaming?: {
+			delay?: number | null;
+			enabled?: boolean | null;
+		} | null;
+	} | null;
+}
+
+export type IFetchAuth = (userKeys?: string[]) => Promise<IJwtCredential>
+
+export type IHealthCheckAPI = () => Promise<boolean>
+
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>

package/src/storages/AbstractDefinitionsCacheAsync.ts

@@ -1,5 +1,5 @@
 import { IDefinitionsCacheAsync } from './types';
-import { IDefinition } from '../dtos/types';
+import { IDefinition, MaybeThenable } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
@@ -10,9 +10,9 @@ export abstract class AbstractDefinitionsCacheAsync implements IDefinitionsCache
 
   protected abstract add(definition: IDefinition): Promise<boolean>
   protected abstract remove(name: string): Promise<boolean>
-  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
+  protected abstract setChangeNumber(changeNumber?: number): MaybeThenable<boolean | void>
 
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(addedFF => this.add(addedFF))),

package/src/storages/AbstractDefinitionsCacheSync.ts

@@ -11,9 +11,9 @@ export abstract class AbstractDefinitionsCacheSync implements IDefinitionsCacheS
 
   protected abstract add(definition: IDefinition): boolean
   protected abstract remove(name: string): boolean
-  protected abstract setChangeNumber(changeNumber: number): boolean | void
+  protected abstract setChangeNumber(changeNumber?: number): boolean | void
 
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): boolean {
     let updated = toAdd.map(addedFF => this.add(addedFF)).some(result => result);
     updated = toRemove.map(removedFF => this.remove(removedFF)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);

package/src/storages/inLocalStorage/DefinitionsCacheInLocal.ts

@@ -115,9 +115,9 @@ export class DefinitionsCacheInLocal extends AbstractDefinitionsCacheSync {
     return item && JSON.parse(item);
   }
 
-  setChangeNumber(changeNumber: number): boolean {
+  setChangeNumber(changeNumber?: number): boolean {
     try {
-      this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+      if (changeNumber !== undefined) this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
       this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
       this.hasSync = true;

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -25,16 +25,16 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): boolean {
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
     updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
     return updated;
   }
 
-  private setChangeNumber(changeNumber: number) {
+  private setChangeNumber(changeNumber?: number) {
     try {
-      this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      if (changeNumber !== undefined) this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
       this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
     } catch (e) {
       this.log.error(LOG_PREFIX + e);

package/src/storages/inMemory/DefinitionsCacheInMemory.ts

@@ -77,8 +77,8 @@ export class DefinitionsCacheInMemory extends AbstractDefinitionsCacheSync {
     return this.definitionsCache[name] || null;
   }
 
-  setChangeNumber(changeNumber: number): boolean {
-    this.changeNumber = changeNumber;
+  setChangeNumber(changeNumber?: number): boolean {
+    if (changeNumber !== undefined) this.changeNumber = changeNumber;
     return true;
   }
 

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -15,10 +15,10 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     this.segmentsCount = 0;
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): boolean {
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
     updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
-    this.changeNumber = changeNumber;
+    if (changeNumber !== undefined) this.changeNumber = changeNumber;
     return updated;
   }
 

package/src/storages/inRedis/DefinitionsCacheInRedis.ts

@@ -143,10 +143,12 @@ export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
    * The returned promise is resolved when the operation success,
    * or rejected if it fails.
    */
-  setChangeNumber(changeNumber: number): Promise<boolean> {
-    return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(
-      (status: string | null) => status === 'OK'
-    );
+  setChangeNumber(changeNumber?: number) {
+    if (changeNumber !== undefined) {
+      return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(
+        (status: string | null) => status === 'OK'
+      );
+    }
   }
 
   /**

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -37,7 +37,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -54,10 +54,12 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     });
   }
 
-  setChangeNumber(changeNumber: number) {
-    return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
-      (status: string | null) => status === 'OK'
-    );
+  setChangeNumber(changeNumber?: number) {
+    if (changeNumber !== undefined) {
+      return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
+        (status: string | null) => status === 'OK'
+      );
+    }
   }
 
   getChangeNumber(): Promise<number> {

package/src/storages/pluggable/DefinitionsCachePluggable.ts

@@ -202,8 +202,10 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
    * The returned promise is resolved when the operation success,
    * or rejected if it fails (e.g., wrapper operation fails).
    */
-  setChangeNumber(changeNumber: number) {
-    return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+  setChangeNumber(changeNumber?: number) {
+    if (changeNumber !== undefined) {
+      return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+    }
   }
 
   /**

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -36,7 +36,7 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -53,8 +53,10 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     });
   }
 
-  setChangeNumber(changeNumber: number) {
-    return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+  setChangeNumber(changeNumber?: number) {
+    if (changeNumber !== undefined) {
+      return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+    }
   }
 
   getChangeNumber(): Promise<number> {

package/src/storages/types.ts

@@ -195,7 +195,7 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface IDefinitionsCacheBase {
-  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber?: number): MaybeThenable<boolean>,
   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.
@@ -212,7 +212,7 @@ export interface IDefinitionsCacheBase {
 }
 
 export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
-  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): boolean,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber?: number): boolean,
   get(name: string): IDefinition | null,
   getMany(names: string[]): Record<string, IDefinition | null>,
   getChangeNumber(): number,
@@ -226,7 +226,7 @@ export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
 }
 
 export interface IDefinitionsCacheAsync extends IDefinitionsCacheBase {
-  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber?: number): Promise<boolean>,
   get(name: string): Promise<IDefinition | null>,
   getMany(names: string[]): Promise<Record<string, IDefinition | null>>,
   getChangeNumber(): Promise<number>,
@@ -242,7 +242,7 @@ export interface IDefinitionsCacheAsync extends IDefinitionsCacheBase {
 /** Rule-Based Segments cache */
 
 export interface IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): MaybeThenable<boolean>,
   get(name: string): MaybeThenable<IRBSegment | null>,
   getChangeNumber(): MaybeThenable<number>,
   clear(): MaybeThenable<boolean | void>,
@@ -250,7 +250,7 @@ export interface IRBSegmentsCacheBase {
 }
 
 export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): boolean,
   get(name: string): IRBSegment | null,
   getChangeNumber(): number,
   getAll(): IRBSegment[],
@@ -261,7 +261,7 @@ export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
 }
 
 export interface IRBSegmentsCacheAsync extends IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean>,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<boolean>,
   get(name: string): Promise<IRBSegment | null>,
   getChangeNumber(): Promise<number>,
   clear(): Promise<boolean | void>,

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

@@ -21,12 +21,12 @@ export type ISplit = IDefinition;
 export interface ISplitChangesResponse {
   ff?: {
     t: number,
-    s?: number,
+    s?: number | null,
     d?: ISplit[] | null,
   },
   rbs?: {
     t: number,
-    s?: number,
+    s?: number | null,
     d?: IRBSegment[] | null,
   }
 }
@@ -34,7 +34,7 @@ export interface ISplitChangesResponse {
 /** JSON response of `/splitChanges` for flag spec version 1.2 or below */
 export interface ISplitChangesLegacyResponse {
   till: number,
-  since?: number,
+  since?: number | null,
   splits: ISplit[]
 }
 
@@ -42,10 +42,10 @@ function isSplitChangesLegacyResponse(data: ISplitChangesResponse | ISplitChange
   return (data as ISplitChangesLegacyResponse).splits != null;
 }
 
-function partitionByStatus<T extends { status?: string; name: string }>(items: T[], till: number, since?: number) {
+function partitionByStatus<T extends { status?: string; name: string }>(items: T[], till: number, since?: number | null) {
   const updated: T[] = [], removed: string[] = [];
   items.forEach(item => item.status === 'ARCHIVED' ? removed.push(item.name) : updated.push(item));
-  return { updated, removed, till, since };
+  return { updated, removed, till, since: since ?? undefined };
 }
 
 /**

package/src/sync/polling/types.ts

@@ -4,7 +4,28 @@ 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, definitionUpdateNotification?: { payload: IDefinition | IRBSegment, changeNumber: number }], boolean> { }
+export type InstantUpdate = {
+  payload: IDefinition | IRBSegment,
+  /**
+   * Environment-scoped change number to track as the storage change number.
+   * If not provided, the storage change number is preserved. That's the case of config instant
+   * updates, where the notification change number is scoped to the config rather than to the
+   * environment.
+   */
+  changeNumber?: number,
+  type: string
+};
+
+/**
+ * `pcn` of CONFIG_UPDATE and RB_SEGMENT_UPDATE notifications for the Configs SDK, used as lower bounds for the `since` and `rbSince` fetch params.
+ * Added for robustness, although in practice `pcn` should never be lower than the current storage change number.
+ */
+export type PreviousChangeNumbers = {
+  since?: number, // `pcn` of CONFIG_UPDATE notifications
+  rbSince?: number // `pcn` of RB_SEGMENT_UPDATE notifications
+};
+
+export interface IDefinitionsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, instantUpdate?: InstantUpdate, pcns?: PreviousChangeNumbers], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 

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

@@ -11,11 +11,10 @@ import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT
 import { setToArray } from '../../../utils/lang/sets';
 import { RB_SEGMENT_UPDATE } from '../../streaming/constants';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
-import { ISplit } from '../fetchers/splitChangesFetcher';
-import { ISegmentsSyncTask } from '../types';
+import { InstantUpdate, ISegmentsSyncTask, PreviousChangeNumbers } from '../types';
+import { thenable } from '../../../utils/promise/thenable';
 
-export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
-type DefinitionChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
+type DefinitionChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate, pcns?: PreviousChangeNumbers) => Promise<boolean>
 
 /**
  * Collect segments from a raw FF or RBS definition.
@@ -142,28 +141,35 @@ export function definitionChangesUpdaterFactory(
    * @param noCache - true to revalidate data to fetch
    * @param till - query param to bypass CDN requests
    */
-  return function definitionChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) {
+  return function definitionChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate, pcns?: PreviousChangeNumbers) {
 
     /**
      * @param since - current changeNumber at definitionsCache
      * @param retry - current number of retry attempts
      */
     function _definitionChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
-      const [since, rbSince] = sinces;
-      log.debug(SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
-
-      return Promise.resolve(
-        instantUpdate ?
-          instantUpdate.type === RB_SEGMENT_UPDATE ?
-            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
-            // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
-            Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
-              return contains ?
-                { d: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['d'] } :
-                definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-            }) :
-          definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
-      )
+      let [since, rbSince] = sinces;
+
+      // If provided, `since` and `rbSince` must not be higher than it, to avoid missing an update that the scoped `pcn` indicates hasn't been fetched yet.
+      if (pcns) {
+        if (pcns.since !== undefined && pcns.since < since) since = pcns.since;
+        if (pcns.rbSince !== undefined && pcns.rbSince < rbSince) rbSince = pcns.rbSince;
+      }
+
+      const definitionChangesRequest = instantUpdate ?
+        instantUpdate.type === RB_SEGMENT_UPDATE ?
+          { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
+          // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
+          Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
+            return contains ?
+              { d: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['d'] } :
+              definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
+          }) :
+        definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
+
+      if (thenable(definitionChangesRequest)) log.debug(SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
+
+      return Promise.resolve(definitionChangesRequest)
         .then((definitionChanges: IDefinitionChangesResponse) => {
           const usedSegments = new Set<string>();
 

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 { IJwtCredential } from '../AuthClient/types';
+import { IJwtCredential } from '../../../services/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
 const ABLY_API_VERSION = '1.1';

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

@@ -1,4 +1,4 @@
-import { IJwtCredential } from '../AuthClient/types';
+import { IJwtCredential } from '../../../services/types';
 
 export interface ISseEventHandler {
   handleError: (ev: Event) => any;

package/src/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.ts

@@ -1,24 +1,28 @@
 import { IRBSegment, IDefinition } from '../../../dtos/types';
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { ILogger } from '../../../logger/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 { ISdkFactoryContextSync } from '../../../sdkFactory/types';
+import { IRBSegmentsCacheSync, IDefinitionsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
-import { IDefinitionsSyncTask } from '../../polling/types';
-import { InstantUpdate } from '../../polling/updaters/definitionChangesUpdater';
+import { IPollingManager } from '../../polling/types';
+import { InstantUpdate } from '../../polling/types';
 import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
+import { parseUpdatePayload } from '../parseUtils';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
-import { IUpdateWorker } from './types';
+import { IDefinitionsUpdateWorker } from './types';
 
 /**
- * DefinitionsUpdateWorker factory
+ * DefinitionsUpdateWorker factory for Flags SDKs, where notifications pcn and changeNumber are environment-scoped
  */
-export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, definitionsSyncTask: IDefinitionsSyncTask, definitionsEventEmitter: IDefinitionsEventEmitter, telemetryTracker: ITelemetryTracker): IUpdateWorker<[updateData: ISplitUpdateData]> & { killDefinition(event: ISplitKillData): void } {
+export function DefinitionsUpdateWorker(
+  params: Pick<ISdkFactoryContextSync, 'settings' | 'storage' | 'telemetryTracker' | 'readiness'>,
+  pollingManager: Pick<IPollingManager, 'definitionsSyncTask'>,
+): IDefinitionsUpdateWorker {
+
+  const { settings: { log }, storage, telemetryTracker, readiness: { definitions: definitionsEventEmitter } } = params;
+  const { definitionsSyncTask } = pollingManager;
 
   const ff = DefinitionsUpdateWorker(storage.definitions);
   const rbs = DefinitionsUpdateWorker(storage.rbSegments);
@@ -108,7 +112,7 @@ export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, def
     put(parsedData) {
       if (parsedData.d && parsedData.c !== undefined) {
         try {
-          const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+          const payload = parseUpdatePayload<IDefinition | IRBSegment>(parsedData.c, parsedData.d);
           if (payload) {
             (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
             return;

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

@@ -1,4 +1,10 @@
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
+
 export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
   put(...args: T): void // handle new update event
 }
+
+export interface IDefinitionsUpdateWorker extends IUpdateWorker<[updateData: ISplitUpdateData]> {
+  killDefinition: (event: ISplitKillData) => void
+}

package/src/sync/streaming/parseUtils.ts

@@ -2,7 +2,6 @@ import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { hash } from '../../utils/murmur3/murmur3';
 import { Compression, IMembershipMSUpdateData } from './SSEHandler/types';
-import { IRBSegment, IDefinition } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -80,11 +79,11 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 }
 
 /**
- * Parse feature flags notifications for instant feature flag updates
+ * Parse notifications for instant updates
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): IDefinition | IRBSegment | undefined {
+export function parseUpdatePayload<T>(compression: Compression, data: string): T | undefined {
   return compression > 0 ?
-    parseCompressedData<IDefinition | IRBSegment>(data, compression, false) :
+    parseCompressedData<T>(data, compression, false) :
     JSON.parse(decodeFromBase64(data));
 }
 

package/src/sync/streaming/pushManager.ts

@@ -15,7 +15,7 @@ import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STRE
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IJwtCredential } from './AuthClient/types';
+import { IJwtCredential } from '../../services/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -27,9 +27,10 @@ import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 export function pushManagerFactory(
   params: ISdkFactoryContextSync,
   pollingManager: IPollingManager,
+  definitionsUpdateWorkerFactory = DefinitionsUpdateWorker
 ): IPushManager | undefined {
 
-  const { settings, storage, serviceApi, readiness, platform, telemetryTracker } = params;
+  const { settings, storage, serviceApi, platform, telemetryTracker } = params;
 
   // `userKey` is the matching key of main client in client-side SDK.
   // It can be used to check if running on client-side or server-side SDK.
@@ -54,7 +55,7 @@ export function pushManagerFactory(
   // 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 DefinitionsUpdateWorker to fetch new segments
-  const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
+  const definitionsUpdateWorker = definitionsUpdateWorkerFactory(params, pollingManager);
 
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.

package/cjs/sync/streaming/AuthClient/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/esm/sync/streaming/AuthClient/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,19 +0,0 @@
-import { IDecodedJWTToken } from '../../../utils/jwt/types';
-
-export type IJwtCredential = {
-  token: string; // empty string ("") when `"pushEnabled": false`
-  decodedToken: IDecodedJWTToken
-  channels: { [channel: string]: string[] }
-  // /api/v2/auth fields
-  pushEnabled?: boolean | null;
-  connDelay?: number | null;
-  // /api/v3/auth fields
-  config?: {
-    streaming?: {
-      delay?: number | null;
-      enabled?: boolean | null;
-    } | null;
-  } | null;
-}
-
-export type IFetchAuth = (userKeys?: string[]) => Promise<IJwtCredential>