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

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -1,6 +1,4 @@
-import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
-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';
 /**
@@ -10,53 +8,35 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
     var log = settings.log, definitions = storage.definitions;
     var startingUp = true;
     return function objectUpdater() {
-        var splits = [];
-        var loadError = null;
-        var splitsMock = {};
+        var changes;
         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)]);
-            forOwn(splitsMock, function (val, name) {
-                // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-                splits.push({
-                    name: name,
-                    status: 'ACTIVE',
-                    killed: false,
-                    trafficAllocation: 100,
-                    defaultTreatment: CONTROL,
-                    conditions: val.conditions || [],
-                    configurations: val.configurations,
-                    trafficTypeName: val.trafficTypeName
-                });
-            });
-            return Promise.all([
-                definitions.clear(),
-                definitions.update(splits, [], Date.now())
-            ]).then(function () {
-                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(function (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 {
+        if (!changes || !changes.d)
             return Promise.resolve(true);
-        }
+        var _a = changes.d, updated = _a.updated, removed = _a.removed, till = _a.till;
+        log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(changes.d)]);
+        // 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(function () {
+            return definitions.update(updated, removed, till);
+        }).then(function (names) {
+            readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: names });
+            if (startingUp) {
+                startingUp = false;
+                Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (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/esm/sync/polling/fetchers/splitChangesFetcher.js

@@ -13,7 +13,7 @@ function isSplitChangesLegacyResponse(data) {
 function partitionByStatus(items, till, since) {
     var updated = [], removed = [];
     items.forEach(function (item) { return item.status === 'ARCHIVED' ? removed.push(item.name) : updated.push(item); });
-    return { updated: updated, removed: removed, till: till, since: since };
+    return { updated: updated, removed: removed, till: till, since: since !== null && since !== void 0 ? since : undefined };
 }
 /**
  * Factory of SplitChanges fetcher.

package/esm/sync/polling/updaters/definitionChangesUpdater.js

@@ -5,6 +5,7 @@ import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
 import { RB_SEGMENT_UPDATE } from '../../streaming/constants';
+import { thenable } from '../../../utils/promise/thenable';
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -67,9 +68,8 @@ export function computeMutation(update, segments, filters) {
         else {
             accum.removed.push(ruleEntity.name);
         }
-        accum.names.push(ruleEntity.name);
         return accum;
-    }, { updated: [], removed: update.removed, names: update.removed.slice() });
+    }, { updated: [], removed: update.removed });
 }
 function convertInstantUpdateToDefinitionChanges(instantUpdate) {
     var payload = instantUpdate.payload, changeNumber = instantUpdate.changeNumber;
@@ -110,7 +110,7 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
      * @param noCache - true to revalidate data to fetch
      * @param till - query param to bypass CDN requests
      */
-    return function definitionChangesUpdater(noCache, till, instantUpdate) {
+    return function definitionChangesUpdater(noCache, till, instantUpdate, pcns) {
         /**
          * @param since - current changeNumber at definitionsCache
          * @param retry - current number of retry attempts
@@ -118,8 +118,14 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
         function _definitionChangesUpdater(sinces, retry) {
             if (retry === void 0) { retry = 0; }
             var since = sinces[0], rbSince = sinces[1];
-            log.debug(SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
-            return Promise.resolve(instantUpdate ?
+            // 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;
+            }
+            var definitionChangesRequest = instantUpdate ?
                 instantUpdate.type === RB_SEGMENT_UPDATE ?
                     { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                     // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
@@ -128,34 +134,35 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                             { d: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                             definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
                     }) :
-                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(function (definitionChanges) {
                 var usedSegments = new Set();
                 var updatedDefinitions = [];
-                var ffUpdate = false;
                 if (definitionChanges.d) {
-                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), updated = _a.updated, removed = _a.removed, names = _a.names;
-                    updatedDefinitions = names;
+                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), updated = _a.updated, removed = _a.removed;
                     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);
                 }
-                var rbsUpdate = false;
+                var updatedRBSNames = [];
                 if (definitionChanges.rbs) {
                     var _b = computeMutation(definitionChanges.rbs, usedSegments), updated = _b.updated, removed = _b.removed;
                     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(function (_a) {
-                    var ffChanged = _a[0], rbsChanged = _a[1];
+                    var updatedDefinitions = _a[0], updatedRBSNames = _a[1];
                     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(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

package/esm/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.js

@@ -1,14 +1,16 @@
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, FLAGS_UPDATE } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
+import { parseUpdatePayload } from '../parseUtils';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
- * DefinitionsUpdateWorker factory
+ * DefinitionsUpdateWorker factory for Flags SDKs, where notifications pcn and changeNumber are environment-scoped
  */
-export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker) {
+export function DefinitionsUpdateWorker(params, pollingManager) {
+    var log = params.settings.log, storage = params.storage, telemetryTracker = params.telemetryTracker, definitionsEventEmitter = params.readiness.definitions;
+    var definitionsSyncTask = pollingManager.definitionsSyncTask;
     var ff = DefinitionsUpdateWorker(storage.definitions);
     var rbs = DefinitionsUpdateWorker(storage.rbSegments);
     function DefinitionsUpdateWorker(cache) {
@@ -93,7 +95,7 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
         put: function (parsedData) {
             if (parsedData.d && parsedData.c !== undefined) {
                 try {
-                    var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+                    var payload = parseUpdatePayload(parsedData.c, parsedData.d);
                     if (payload) {
                         (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
                         return;
@@ -116,7 +118,7 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
             if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
-                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, true);
+                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [splitName] }, true /* isSplitKill */);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });

package/esm/sync/streaming/parseUtils.js

@@ -73,9 +73,9 @@ export function isInBitmap(bitmap, hash64hex) {
     return (bitmap[internal] & 1 << offset) > 0;
 }
 /**
- * Parse feature flags notifications for instant feature flag updates
+ * Parse notifications for instant updates
  */
-export function parseFFUpdatePayload(compression, data) {
+export function parseUpdatePayload(compression, data) {
     return compression > 0 ?
         parseCompressedData(data, compression, false) :
         JSON.parse(decodeFromBase64(data));

package/esm/sync/streaming/pushManager.js

@@ -18,8 +18,9 @@ import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+export function pushManagerFactory(params, pollingManager, definitionsUpdateWorkerFactory) {
+    if (definitionsUpdateWorkerFactory === void 0) { definitionsUpdateWorkerFactory = DefinitionsUpdateWorker; }
+    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `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.
     var userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
@@ -41,7 +42,7 @@ export function pushManagerFactory(params, pollingManager) {
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
-    var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
+    var 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.
     var clients = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.11",
+  "version": "3.1.1-rc.13",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -243,14 +243,14 @@ export interface IDefinition extends TargetingEntity {
 /** Interface of the parsed JSON response of `/splitChanges` */
 export interface IDefinitionChangesResponse {
   d?: {
-    till: number,
-    since?: number | null,
+    till?: number,
+    since?: number,
     updated: IDefinition[],
     removed: string[],
   },
   rbs?: {
-    till: number,
-    since?: number | null,
+    till?: number,
+    since?: number,
     updated: IRBSegment[],
     removed: string[],
   }

package/src/services/authProvider.ts

@@ -1,6 +1,6 @@
 import { ISplitHttpClient, NetworkError } from './types';
-import { IJwtCredential } from '../sync/streaming/AuthClient/types';
-import { fetchAuthFactory } from '../sync/streaming/AuthClient';
+import { IJwtCredential } from './types';
+import { fetchAuthFactory } from './fetchAuth';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { ISettings } from '../types';

package/src/{sync/streaming/AuthClient/index.ts → services/fetchAuth.ts}

@@ -1,7 +1,6 @@
-import { IJwtCredential, IFetchAuth } from './types';
-import { objectAssign } from '../../../utils/lang/objectAssign';
-import { decodeJWTtoken } from '../../../utils/jwt';
-import { IResponse } from '../../../services/types';
+import { IJwtCredential, IFetchAuth, IResponse } from './types';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { decodeJWTtoken } from '../utils/jwt';
 
 /**
  * Factory of authentication function.

package/src/services/splitApi.ts

@@ -6,7 +6,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
-import { fetchAuthFactory } from '../sync/streaming/AuthClient';
+import { fetchAuthFactory } from './fetchAuth';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 

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,15 +10,16 @@ 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<string[]> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(addedFF => this.add(addedFF))),
       Promise.all(toRemove.map(removedFF => this.remove(removedFF)))
     ]).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(addedFF => addedFF.name));
     });
   }
 

package/src/storages/AbstractDefinitionsCacheSync.ts

@@ -11,11 +11,11 @@ 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 {
-    let updated = toAdd.map(addedFF => this.add(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.remove(removedFF)).some(result => result) || updated;
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(removedFF => this.remove(removedFF))
+      .concat(toAdd.filter(addedFF => this.add(addedFF)).map(addedFF => addedFF.name));
     this.setChangeNumber(changeNumber);
     return updated;
   }

package/src/storages/inLocalStorage/DefinitionsCacheInLocal.ts

@@ -79,13 +79,15 @@ export class DefinitionsCacheInLocal extends AbstractDefinitionsCacheSync {
     this.hasSync = false;
   }
 
-  add(definition: IDefinition) {
+  add(definition: IDefinition): boolean {
     const name = definition.name;
     const definitionKey = this.keys.buildDefinitionKey(name);
     const definitionFromStorage = this.storage.getItem(definitionKey);
     const previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
 
     if (previousDefinition) {
+      if (previousDefinition.changeNumber >= definition.changeNumber) return false;
+
       this._decrementCounts(previousDefinition);
       this.removeFromSets(previousDefinition.name, previousDefinition.sets);
     }
@@ -115,9 +117,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 {
-    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(name => this.remove(name))
+      .concat(toAdd.filter(rbSegment => this.add(rbSegment)).map(rbSegment => rbSegment.name));
     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);
@@ -54,6 +54,8 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
     const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
+    if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
+
     this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
     let usesSegmentsDiff = 0;

package/src/storages/inMemory/DefinitionsCacheInMemory.ts

@@ -31,6 +31,7 @@ export class DefinitionsCacheInMemory extends AbstractDefinitionsCacheSync {
     const name = definition.name;
     const previousDefinition = this.get(name);
     if (previousDefinition) { // We had this Split already
+      if (previousDefinition.changeNumber >= definition.changeNumber) return false;
 
       const previousTtName = previousDefinition.trafficTypeName;
       this.ttCache[previousTtName]--;
@@ -77,8 +78,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,16 +15,17 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     this.segmentsCount = 0;
   }
 
-  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;
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(name => this.remove(name))
+      .concat(toAdd.filter(rbSegment => this.add(rbSegment)).map(rbSegment => rbSegment.name));
+    if (changeNumber !== undefined) this.changeNumber = changeNumber;
     return updated;
   }
 
   private add(rbSegment: IRBSegment): boolean {
     const name = rbSegment.name;
     const previous = this.get(name);
+    if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
     if (previous && usesSegments(previous)) this.segmentsCount--;
 
     this.cache[name] = rbSegment;

package/src/storages/inRedis/DefinitionsCacheInRedis.ts

@@ -91,6 +91,8 @@ export class DefinitionsCacheInRedis 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);
@@ -104,8 +106,8 @@ export class DefinitionsCacheInRedis 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);
+    });
   }
 
   /**
@@ -115,11 +117,11 @@ export class DefinitionsCacheInRedis 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.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
+      if (!definition) return false;
+
+      return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets)).then(() => {
+        return this.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
+      });
     });
   }
 
@@ -143,10 +145,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,27 +37,38 @@ export class RBSegmentsCacheInRedis 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.redis.set(key, stringifiedNewRBSegment).then(() => true);
-      })),
-      Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove);
-        return this.redis.del(key).then((status: number) => status === 1);
-      }))
+      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.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
-      (status: string | null) => status === 'OK'
-    );
+  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.redis.set(key, stringifiedNewRBSegment).then(() => true);
+    });
+  }
+
+  private remove(name: string): Promise<boolean> {
+    const key = this.keys.buildRBSegmentKey(name);
+    return this.redis.del(key).then((status: number) => status === 1);
+  }
+
+  setChangeNumber(changeNumber?: number) {
+    if (changeNumber !== undefined) {
+      return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
+        (status: string | null) => status === 'OK'
+      );
+    }
   }
 
   getChangeNumber(): Promise<number> {