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

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -36,23 +36,32 @@ 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));
     });
   }
 
+  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 + '');

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/updaters/definitionChangesUpdater.ts

@@ -48,7 +48,6 @@ export function parseSegments(ruleEntity: IDefinition | IRBSegment, matcherType:
 interface IDefinitionMutations<T extends IDefinition | IRBSegment> {
   updated: T[],
   removed: string[],
-  names: string[]
 }
 
 /**
@@ -88,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) {
@@ -173,33 +171,31 @@ export function definitionChangesUpdaterFactory(
         .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/UpdateWorkers/DefinitionsUpdateWorker.ts

@@ -1,6 +1,6 @@
 import { IRBSegment, IDefinition } from '../../../dtos/types';
 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 { ISdkFactoryContextSync } from '../../../sdkFactory/types';
 import { IRBSegmentsCacheSync, IDefinitionsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
@@ -133,7 +133,7 @@ export function DefinitionsUpdateWorker(
     killDefinition({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
       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 } as ISplitUpdateData);

package/src/sync/syncManagerOnline.ts

@@ -100,7 +100,6 @@ export function syncManagerOnlineFactory(
             if (!cacheMetadata.initialCacheLoad) {
               readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
-
           }
 
           // start syncing splits and segments