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

package/src/storages/pluggable/DefinitionsCachePluggable.ts

@@ -75,11 +75,14 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
       let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
       try {
         parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        if (parsedPreviousDefinition && parsedPreviousDefinition.changeNumber >= definition.changeNumber) return false;
+
         stringifiedNewDefinition = JSON.stringify(definition);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
+
       return this.wrapper.set(definitionKey, stringifiedNewDefinition).then(() => {
         // avoid unnecessary increment/decrement operations
         if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
@@ -88,8 +91,8 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
         return this._incrementCounts(definition).then(() => {
           if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
         });
-      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
-    }).then(() => true);
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets)).then(() => true);
+    });
   }
 
   /**
@@ -99,11 +102,11 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
    */
   remove(name: string) {
     return this.get(name).then((definition) => {
-      if (definition) {
-        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
-      }
-    }).then(() => {
-      return this.wrapper.del(this.keys.buildDefinitionKey(name));
+      if (!definition) return false;
+
+      return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets)).then(() => {
+        return this.wrapper.del(this.keys.buildDefinitionKey(name));
+      });
     });
   }
 
@@ -202,8 +205,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,25 +36,36 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<string[]> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(toAdd => {
-        const key = this.keys.buildRBSegmentKey(toAdd.name);
-        const stringifiedNewRBSegment = JSON.stringify(toAdd);
-        return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
-      })),
-      Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove);
-        return this.wrapper.del(key);
-      }))
+      Promise.all(toAdd.map(rbSegment => this.add(rbSegment))),
+      Promise.all(toRemove.map(name => this.remove(name)))
     ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
+      return toRemove.filter((_, i) => removed[i])
+        .concat(toAdd.filter((_, i) => added[i]).map(rbSegment => rbSegment.name));
     });
   }
 
-  setChangeNumber(changeNumber: number) {
-    return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+  private add(rbSegment: IRBSegment): Promise<boolean> {
+    const key = this.keys.buildRBSegmentKey(rbSegment.name);
+    return this.get(rbSegment.name).then(previous => {
+      if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
+
+      const stringifiedNewRBSegment = JSON.stringify(rbSegment);
+      return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
+    });
+  }
+
+  private remove(name: string): Promise<boolean> {
+    const key = this.keys.buildRBSegmentKey(name);
+    return this.wrapper.del(key);
+  }
+
+  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<string[]>,
   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): string[],
   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<string[]>,
   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<string[]>,
   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): string[],
   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<string[]>,
   get(name: string): Promise<IRBSegment | null>,
   getChangeNumber(): Promise<number>,
   clear(): Promise<boolean | void>,

package/src/sync/offline/splitsParser/definitionChangesBuilder.ts

@@ -0,0 +1,49 @@
+import { IDefinition, IDefinitionChangesResponse } from '../../../dtos/types';
+import { CONTROL } from '../../../utils/constants';
+import { IDefinitionPartial } from './types';
+
+/**
+ * Factory of a stateful function that, given the current mocked definitions, returns the changes since the previous call
+ * as an `IDefinitionChangesResponse`, i.e., the full definitions that were added or modified, and the names of the removed ones.
+ * Definitions are compared by value. The response `till` is an incrementing value based on the current time.
+ * Definitions have no `changeNumber`, so storages never consider them outdated.
+ *
+ * The response has no `d` property if there are no changes, except for the first call, which reports the (possibly empty) mock.
+ * It is meant to be used by `IDefinitionsParser` implementations, such as `splitsParserFromSettings`.
+ */
+export function definitionChangesBuilderFactory() {
+
+  let previous: Record<string, string> | undefined; // serialized definitions of the last reported mock, by name
+  let lastTill = 0;
+
+  return function definitionChangesBuilder(mock: Record<string, IDefinitionPartial>): IDefinitionChangesResponse {
+    const current: Record<string, string> = {};
+    const updatedNames = Object.keys(mock).reduce((updatedNames: string[], name) => {
+      current[name] = JSON.stringify(mock[name]);
+      if (!previous || previous[name] !== current[name]) updatedNames.push(name);
+      return updatedNames;
+    }, []);
+
+    const removed = previous ? Object.keys(previous).filter(name => current[name] === undefined) : [];
+
+    // Only the first call reports an empty change
+    if (previous && updatedNames.length === 0 && removed.length === 0) return {};
+
+    previous = current;
+
+    // Incrementing `till` based on the current time
+    const till = lastTill = Math.max(Date.now(), lastTill + 1);
+
+    const updated = updatedNames.map(name => ({
+      name,
+      status: 'ACTIVE',
+      killed: false,
+      trafficAllocation: 100,
+      defaultTreatment: CONTROL, // `seed` is undefined in localhost mode
+      ...mock[name]
+    } as IDefinition));
+
+    return { d: { updated, removed, till } };
+  };
+
+}

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,52 +1,22 @@
 import { IDefinitionPartial } from './types';
+import { IDefinitionChangesResponse } from '../../../dtos/types';
 import SplitIO from '../../../../types/splitio';
-import { isObject, forOwn, merge } from '../../../utils/lang';
+import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
-
-function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
-  if (typeof prev !== typeof curr) return true;
-
-  if (typeof prev === 'string') { // strings treatments, just compare
-    return prev !== curr;
-  } else { // has treatment and config, compare both
-    return prev.treatment !== (curr as SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
-  }
-}
+import { definitionChangesBuilderFactory } from './definitionChangesBuilder';
 
 export function splitsParserFromSettingsFactory() {
 
-  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
-
-  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
-    const names = Object.keys(currentData);
-
-    // Different amount of items
-    if (names.length !== Object.keys(previousMock).length) {
-      previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
-      return true;
-    }
-
-    return names.some(name => {
-      const newSplit = !previousMock[name];
-      const newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-      const changed = newSplit || newTreatment;
-
-      if (changed) previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
-
-      return changed;
-    });
-  }
+  const definitionChangesBuilder = definitionChangesBuilderFactory();
 
   /**
    *
    * @param settings - validated object with mocked features mapping.
    */
-  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): false | Record<string, IDefinitionPartial> {
+  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): IDefinitionChangesResponse {
     const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
-    if (!mockUpdated(features)) return false;
-
-    const splitObjects: Record<string, IDefinitionPartial> = {};
+    const mock: Record<string, IDefinitionPartial> = {};
 
     forOwn(features, (data, splitName) => {
       let treatment = data;
@@ -59,14 +29,14 @@ export function splitsParserFromSettingsFactory() {
       const configurations: Record<string, string> = {};
       if (config !== null) configurations[treatment as string] = config;
 
-      splitObjects[splitName] = {
+      mock[splitName] = {
         trafficTypeName: 'localhost',
         conditions: [parseCondition({ treatment: treatment as string })],
         configurations
       };
     });
 
-    return splitObjects;
+    return definitionChangesBuilder(mock);
   };
 
 }

package/src/sync/offline/splitsParser/types.ts

@@ -1,8 +1,12 @@
-import { IDefinition } from '../../../dtos/types';
+import { IDefinition, IDefinitionChangesResponse } from '../../../dtos/types';
 import { ISettings } from '../../../types';
 
 // Split definition used in offline mode
 export type IDefinitionPartial = Pick<IDefinition, 'conditions' | 'configurations' | 'trafficTypeName'>
 
-// Analog to `IDefinitionChangesFetcher` used by `definitionChangesUpdaterFactory`
-export type IDefinitionsParser = (settings: ISettings) => false | Record<string, IDefinitionPartial>
+/**
+ * Analog to `IDefinitionChangesFetcher` used by `definitionChangesUpdaterFactory`.
+ * It returns the definitions changes since the last call, with an incrementing `till`.
+ * The response has no `d` property if there are no changes, e.g., if the mocked definitions were not modified since the last call.
+ */
+export type IDefinitionsParser = (settings: ISettings) => IDefinitionChangesResponse

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

@@ -1,12 +1,10 @@
-import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { IStorageSync } from '../../../storages/types';
-import { IDefinitionsParser, IDefinitionPartial } from '../splitsParser/types';
-import { IDefinition } from '../../../dtos/types';
+import { IDefinitionsParser } from '../splitsParser/types';
+import { IDefinitionChangesResponse } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
-import { CONTROL } from '../../../utils/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';
 
@@ -24,55 +22,37 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: IDefinition[] = [];
-    let loadError = null;
-    let splitsMock: false | Record<string, IDefinitionPartial> = {};
+    let changes: IDefinitionChangesResponse | undefined;
     try {
-      splitsMock = splitsParser(settings);
+      changes = splitsParser(settings);
     } catch (err) {
-      loadError = err;
       log.error(ERROR_SYNC_OFFLINE_LOADING, [err]);
     }
 
-    if (!loadError && splitsMock) {
-      log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
+    if (!changes || !changes.d) return Promise.resolve(true);
 
-      forOwn(splitsMock, (val, name) => {
-        // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-        splits.push({
-          name,
-          status: 'ACTIVE',
-          killed: false,
-          trafficAllocation: 100,
-          defaultTreatment: CONTROL,
-          conditions: val.conditions || [],
-          configurations: val.configurations,
-          trafficTypeName: val.trafficTypeName
-        });
-      });
+    const { updated, removed, till } = changes.d;
+    log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(changes.d)]);
 
-      return Promise.all([
-        definitions.clear(), // required to sync removed splits from mock
-        definitions.update(splits, [], Date.now())
-      ]).then(() => {
-        readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
+    // On start, clear definitions that might be in the storage from a previous session (InLocalStorage), since the parser only tracks its own changes.
+    return Promise.resolve(startingUp && definitions.clear()).then(() => {
+      return definitions.update(updated, removed, till);
+    }).then((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.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
-            }
-            // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
-          });
-        }
-        return true;
-      });
-    } else {
-      return Promise.resolve(true);
-    }
+      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.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+          }
+          // Emits SDK_READY
+          readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
+        });
+      }
+      return true;
+    });
   };
 }
 

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.
@@ -49,7 +48,6 @@ export function parseSegments(ruleEntity: IDefinition | IRBSegment, matcherType:
 interface IDefinitionMutations<T extends IDefinition | IRBSegment> {
   updated: T[],
   removed: string[],
-  names: string[]
 }
 
 /**
@@ -89,9 +87,8 @@ export function computeMutation<T extends IDefinition | IRBSegment>(update: { up
     } else {
       accum.removed.push(ruleEntity.name);
     }
-    accum.names.push(ruleEntity.name);
     return accum;
-  }, { updated: [], removed: update.removed, names: update.removed.slice() } as IDefinitionMutations<T>);
+  }, { updated: [], removed: update.removed } as IDefinitionMutations<T>);
 }
 
 function convertInstantUpdateToDefinitionChanges(instantUpdate: InstantUpdate) {
@@ -142,58 +139,63 @@ 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>();
 
-          let updatedDefinitions: string[] = [];
-          let ffUpdate: MaybeThenable<boolean> = false;
+          let updatedDefinitions: MaybeThenable<string[]> = [];
           if (definitionChanges.d) {
-            const { updated, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
-            updatedDefinitions = names;
+            const { updated, removed } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
             log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, updated.length, removed.length]);
-            ffUpdate = definitions.update(updated, removed, definitionChanges.d.till);
+            updatedDefinitions = definitions.update(updated, removed, definitionChanges.d.till);
           }
 
-          let rbsUpdate: MaybeThenable<boolean> = false;
+          let updatedRBSNames: MaybeThenable<string[]> = [];
           if (definitionChanges.rbs) {
             const { updated, removed } = computeMutation(definitionChanges.rbs, usedSegments);
             log.debug(SYNC_UPDATE, ['rule-based segments', updated.length, removed.length]);
-            rbsUpdate = rbSegments.update(updated, removed, definitionChanges.rbs.till);
+            updatedRBSNames = rbSegments.update(updated, removed, definitionChanges.rbs.till);
           }
 
-          return Promise.all([ffUpdate, rbsUpdate,
+          return Promise.all([updatedDefinitions, updatedRBSNames,
             // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
             segments.registerSegments(setToArray(usedSegments))
-          ]).then(([ffChanged, rbsChanged]) => {
+          ]).then(([updatedDefinitions, updatedRBSNames]) => {
             if (storage.save) storage.save();
 
             startingUp = false;
 
             if (definitionsEventEmitter) {
               // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must wait for all registered segments to be fetched
-              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
+              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((updatedDefinitions.length > 0 || updatedRBSNames.length > 0) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events

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;