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

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

@@ -1,12 +1,12 @@
 import { ISettings } from '../../../types';
-import { ISplitChangesResponse } from '../../../dtos/types';
-import { IFetchSplitChanges, IResponse } from '../../../services/types';
-import { IStorageBase } from '../../../storages/types';
+import { IDefinition, IRBSegment, IDefinitionChangesResponse } from '../../../dtos/types';
+import { IResponse } from '../../../services/types';
 import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
-import { ISplitChangesFetcher } from './types';
-import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+import { IDefinitionChangesFetcher } from './types';
+import { LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { checkIfServerSide } from '../../../utils/key';
+import { ISdkFactoryContextSync } from '../../../sdkFactory/types';
 
 const PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
 const PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
@@ -15,25 +15,59 @@ function sdkEndpointOverridden(settings: ISettings) {
   return settings.urls.sdk !== base.urls.sdk;
 }
 
+export type ISplit = IDefinition;
+
+/** JSON response of `/splitChanges` */
+export interface ISplitChangesResponse {
+  ff?: {
+    t: number,
+    s?: number,
+    d?: ISplit[] | null,
+  },
+  rbs?: {
+    t: number,
+    s?: number,
+    d?: IRBSegment[] | null,
+  }
+}
+
+/** JSON response of `/splitChanges` for flag spec version 1.2 or below */
+export interface ISplitChangesLegacyResponse {
+  till: number,
+  since?: number,
+  splits: ISplit[]
+}
+
+function isSplitChangesLegacyResponse(data: ISplitChangesResponse | ISplitChangesLegacyResponse): data is ISplitChangesLegacyResponse {
+  return (data as ISplitChangesLegacyResponse).splits != null;
+}
+
+function partitionByStatus<T extends { status?: string; name: string }>(items: T[], till: number, since?: number) {
+  const updated: T[] = [], removed: string[] = [];
+  items.forEach(item => item.status === 'ARCHIVED' ? removed.push(item.name) : updated.push(item));
+  return { updated, removed, till, since };
+}
+
 /**
  * Factory of SplitChanges fetcher.
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
-export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
+export function splitChangesFetcherFactory(params: ISdkFactoryContextSync): IDefinitionChangesFetcher {
 
+  const { splitApi: { fetchSplitChanges }, settings, storage } = params;
   const log = settings.log;
   const PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
   let lastProxyCheckTimestamp: number | undefined;
 
-  return function splitChangesFetcher(
+  function splitChangesFetcher(
     since: number,
     noCache?: boolean,
     till?: number,
     rbSince?: number,
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<ISplitChangesResponse> {
+  ): Promise<IDefinitionChangesResponse> {
 
     // Recheck proxy
     if (lastProxyCheckTimestamp && (Date.now() - lastProxyCheckTimestamp) > PROXY_CHECK_INTERVAL_MILLIS) {
@@ -44,7 +78,7 @@ export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges
       .catch((err) => {
         // Handle proxy error with spec 1.3
         if ((!err.statusCode || err.statusCode === 400) && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === FLAG_SPEC_VERSION) {
-          log.error(LOG_PREFIX_SYNC_SPLITS + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
+          log.error(LOG_PREFIX_SYNC + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
           lastProxyCheckTimestamp = Date.now();
           settings.sync.flagSpecVersion = '1.2'; // fallback to 1.2 spec
           return fetchSplitChanges(since, noCache, till); // retry request without rbSince
@@ -56,31 +90,32 @@ export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges
 
     return splitsPromise
       .then(resp => resp.json())
-      .then(data => {
+      .then((data: ISplitChangesResponse | ISplitChangesLegacyResponse) => {
         // Using flag spec version 1.2 or below
-        if (data.splits) {
-          return {
-            ff: {
-              d: data.splits,
-              s: data.since,
-              t: data.till
-            }
-          };
+        if (isSplitChangesLegacyResponse(data)) {
+          return { d: partitionByStatus(data.splits || [], data.till, data.since) };
         }
 
         // Proxy recovery
         if (lastProxyCheckTimestamp) {
-          log.info(LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
+          log.info(LOG_PREFIX_SYNC + 'Proxy error recovered');
           lastProxyCheckTimestamp = undefined;
           return splitChangesFetcher(-1, undefined, undefined, -1)
-            .then((splitChangesResponse: ISplitChangesResponse) =>
-              Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+            .then((splitChangesResponse: IDefinitionChangesResponse) =>
+              Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
                 .then(() => splitChangesResponse)
             );
         }
 
-        return data;
+        const { ff, rbs } = data;
+
+        return {
+          d: ff?.d ? partitionByStatus(ff.d, ff.t, ff.s) : undefined,
+          rbs: rbs?.d ? partitionByStatus(rbs.d, rbs.t, rbs.s) : undefined,
+        };
       });
-  };
+  }
 
+  splitChangesFetcher.type = 'feature flags' as const;
+  return splitChangesFetcher;
 }

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

@@ -1,13 +1,15 @@
-import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
+import { IDefinitionChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
 import { IResponse } from '../../../services/types';
 
-export type ISplitChangesFetcher = (
+export type IDefinitionChangesFetcher = ((
   since: number,
   noCache?: boolean,
   till?: number,
   rbSince?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-) => Promise<ISplitChangesResponse>
+) => Promise<IDefinitionChangesResponse>) & {
+  type: 'configs' | 'feature flags'
+}
 
 export type ISegmentChangesFetcher = (
   since: number,

package/src/sync/polling/pollingManagerCS.ts

@@ -3,26 +3,28 @@ import { forOwn } from '../../utils/lang';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
+import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { getMatching } from '../../utils/key';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 import { SdkUpdateMetadata } from '../../../types/splitio';
+import { IDefinitionChangesFetcher } from './fetchers/types';
 
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(
-  params: ISdkFactoryContextSync
+  params: ISdkFactoryContextSync,
+  definitionChangesFetcher: IDefinitionChangesFetcher
 ): IPollingManagerCS {
 
   const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
-  const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
+  const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, true);
 
   // Map of matching keys to their corresponding MySegmentsSyncTask.
   const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
@@ -43,8 +45,8 @@ export function pollingManagerCSFactory(
   }
 
   // smart pausing
-  readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
+  readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
+    if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
     const usingSegments = usesSegmentsSync(storage);
     if (usingSegments !== mySegmentsSyncTask.isRunning()) {
       log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
@@ -64,21 +66,21 @@ export function pollingManagerCSFactory(
       if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
     }
     if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
-    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+    else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
 
     mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
     return mySegmentsSyncTask;
   }
 
   return {
-    splitsSyncTask,
+    definitionsSyncTask,
     segmentsSyncTask: mySegmentsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
 
-      splitsSyncTask.start();
+      definitionsSyncTask.start();
       if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
     },
 
@@ -86,16 +88,16 @@ export function pollingManagerCSFactory(
     stop() {
       log.info(POLLING_STOP);
 
-      if (splitsSyncTask.isRunning()) splitsSyncTask.stop();
+      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
       stopMySegmentsSyncTasks();
     },
 
     // Used by SyncManager to know if running in polling mode.
-    isRunning: splitsSyncTask.isRunning,
+    isRunning: definitionsSyncTask.isRunning,
 
-    // fetch splits and segments
+    // fetch definitions and segments
     syncAll() {
-      const promises = [splitsSyncTask.execute()];
+      const promises = [definitionsSyncTask.execute()];
       forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
         promises.push(mySegmentsSyncTask.execute());
       });

package/src/sync/polling/pollingManagerSS.ts

@@ -1,36 +1,38 @@
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
+import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
+import { IPollingManager, ISegmentsSyncTask, IDefinitionsSyncTask } from './types';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { IDefinitionChangesFetcher } from './fetchers/types';
 
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
 export function pollingManagerSSFactory(
-  params: ISdkFactoryContextSync
+  params: ISdkFactoryContextSync,
+  definitionChangesFetcher: IDefinitionChangesFetcher
 ): IPollingManager {
 
   const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
-  const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
+  const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
   const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);
 
   return {
-    splitsSyncTask,
+    definitionsSyncTask,
     segmentsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `Splits will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
+      log.debug(LOG_PREFIX_SYNC_POLLING + `${definitionChangesFetcher.type} will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
+      log.debug(LOG_PREFIX_SYNC_POLLING + `segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
 
-      const startingUp = splitsSyncTask.start();
+      const startingUp = definitionsSyncTask.start();
       if (startingUp) {
         startingUp.then(() => {
-          if (splitsSyncTask.isRunning()) segmentsSyncTask.start();
+          if (definitionsSyncTask.isRunning()) segmentsSyncTask.start();
         });
       }
     },
@@ -39,16 +41,16 @@ export function pollingManagerSSFactory(
     stop() {
       log.info(POLLING_STOP);
 
-      if (splitsSyncTask.isRunning()) splitsSyncTask.stop();
+      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
       if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
     },
 
     // Used by SyncManager to know if running in polling mode.
-    isRunning: splitsSyncTask.isRunning,
+    isRunning: definitionsSyncTask.isRunning,
 
     syncAll() {
-      // fetch splits and segments. There is no need to catch this promise (`SplitChangesUpdater` is always resolved with a boolean value)
-      return splitsSyncTask.execute().then(() => {
+      // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+      return definitionsSyncTask.execute().then(() => {
         return segmentsSyncTask.execute();
       });
     }

package/src/sync/polling/syncTasks/{splitsSyncTask.ts → definitionsSyncTask.ts}

@@ -1,35 +1,34 @@
 import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
-import { ISplitsSyncTask } from '../types';
-import { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';
-import { IFetchSplitChanges } from '../../../services/types';
+import { IDefinitionsSyncTask } from '../types';
 import { ISettings } from '../../../types';
-import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
+import { definitionChangesUpdaterFactory } from '../updaters/definitionChangesUpdater';
+import { IDefinitionChangesFetcher } from '../fetchers/types';
 
 /**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
+ * Creates a sync task that periodically executes a `definitionChangesUpdater` task
  */
-export function splitsSyncTaskFactory(
-  fetchSplitChanges: IFetchSplitChanges,
+export function definitionsSyncTaskFactory(
+  definitionChangesFetcher: IDefinitionChangesFetcher,
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
   isClientSide?: boolean
-): ISplitsSyncTask {
+): IDefinitionsSyncTask {
   return syncTaskFactory(
     settings.log,
-    splitChangesUpdaterFactory(
+    definitionChangesUpdaterFactory(
       settings.log,
-      splitChangesFetcherFactory(fetchSplitChanges, settings, storage),
+      definitionChangesFetcher,
       storage,
       settings.sync.__splitFiltersValidation,
-      readiness.splits,
+      readiness.definitions,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       isClientSide
     ),
     settings.scheduler.featuresRefreshRate,
-    'splitChangesUpdater',
+    'definitionChangesUpdater',
   );
 }

package/src/sync/polling/types.ts

@@ -1,10 +1,10 @@
-import { IRBSegment, ISplit } from '../../dtos/types';
+import { IRBSegment, IDefinition } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit | IRBSegment, changeNumber: number }], boolean> { }
+export interface IDefinitionsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, definitionUpdateNotification?: { payload: IDefinition | IRBSegment, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
@@ -19,7 +19,7 @@ export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegment
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
-  splitsSyncTask: ISplitsSyncTask
+  definitionsSyncTask: IDefinitionsSyncTask
   segmentsSyncTask: ISyncTask
 }
 

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

@@ -0,0 +1,239 @@
+import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
+import { IDefinitionChangesFetcher } from '../fetchers/types';
+import { IRBSegment, IDefinition, IDefinitionChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
+import { IDefinitionsEventEmitter } from '../../../readiness/types';
+import { timeout } from '../../../utils/promise/timeout';
+import { SDK_DEFINITIONS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
+import { ILogger } from '../../../logger/types';
+import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_FETCH_RETRY } from '../../../logger/constants';
+import { startsWith } from '../../../utils/lang';
+import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
+import { setToArray } from '../../../utils/lang/sets';
+import { SPLIT_UPDATE } from '../../streaming/constants';
+import { SdkUpdateMetadata } from '../../../../types/splitio';
+import { ISplit } from '../fetchers/splitChangesFetcher';
+
+export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
+type DefinitionChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
+
+// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
+// Returns a promise that could be rejected.
+// @TODO review together with Segments and MySegments storage APIs
+function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
+  let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
+  return registeredSegments.then(segmentNames => {
+    return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
+      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
+  });
+}
+
+/**
+ * Collect segments from a raw FF or RBS definition.
+ * Exported for testing purposes.
+ */
+export function parseSegments(ruleEntity: IDefinition | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
+  const { conditions, excluded } = ruleEntity as IRBSegment;
+
+  const segments = new Set<string>();
+  if (excluded && excluded.segments) {
+    excluded.segments.forEach(({ type, name }) => {
+      if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
+        segments.add(name);
+      }
+    });
+  }
+
+  if (conditions) {
+    for (let i = 0; i < conditions.length; i++) {
+      const matchers = conditions[i].matcherGroup.matchers;
+
+      matchers.forEach(matcher => {
+        if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      });
+    }
+  }
+
+  return segments;
+}
+
+interface IDefinitionMutations<T extends IDefinition | IRBSegment> {
+  added: T[],
+  removed: string[],
+  names: string[]
+}
+
+/**
+ * If there are defined filters and one definition doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
+ * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
+ *
+ * @param definition - definition to be evaluated
+ * @param filters - splitFiltersValidation bySet | byName
+ */
+function matchFilters(definition: IDefinition, filters: ISplitFiltersValidation) {
+  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
+  if (setsFilter.length > 0) return definition.sets && definition.sets.some((definitionSet: string) => setsFilter.indexOf(definitionSet) > -1);
+
+  const namesFilterConfigured = namesFilter.length > 0;
+  const prefixFilterConfigured = prefixFilter.length > 0;
+
+  if (!namesFilterConfigured && !prefixFilterConfigured) return true;
+
+  const matchNames = namesFilterConfigured && namesFilter.indexOf(definition.name) > -1;
+  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(definition.name, prefix));
+  return matchNames || matchPrefix;
+}
+
+/**
+ * Given the list of definitions from /splitChanges or /configs endpoint, it returns the mutations,
+ * i.e., an object with added definitions, removed definitions, and used segments.
+ * Exported for testing purposes.
+ */
+export function computeMutation<T extends IDefinition | IRBSegment>(update: { updated: T[], removed: string[] }, segments: Set<string>, filters?: ISplitFiltersValidation): IDefinitionMutations<T> {
+  return update.updated.reduce((accum, ruleEntity) => {
+    if (!filters || matchFilters(ruleEntity as IDefinition, filters)) {
+      accum.added.push(ruleEntity);
+
+      parseSegments(ruleEntity).forEach((segmentName: string) => {
+        segments.add(segmentName);
+      });
+    } else {
+      accum.removed.push(ruleEntity.name);
+    }
+    accum.names.push(ruleEntity.name);
+    return accum;
+  }, { added: [], removed: update.removed, names: update.removed.slice() } as IDefinitionMutations<T>);
+}
+
+function convertInstantUpdateToDefinitionChanges(instantUpdate: InstantUpdate) {
+  const { payload, changeNumber } = instantUpdate;
+  return payload.status === 'ARCHIVED' ?
+    { till: changeNumber, updated: [], removed: [payload.name] } :
+    { till: changeNumber, updated: [payload], removed: [] };
+}
+
+/**
+ * Factory of DefinitionChanges updater, a task that:
+ *  - fetches definition changes using `definitionChangesFetcher`
+ *  - updates definitions storage
+ *  - uses `definitionsEventEmitter` to emit events related to definition data updates
+ *
+ * @param log -  Logger instance
+ * @param definitionChangesFetcher -  Fetcher of `/splitChanges` or `/configs`
+ * @param definitions -  Definitions storage, with sync or async methods
+ * @param segments -  Segments storage, with sync or async methods
+ * @param definitionsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
+ * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
+ * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` or `/configs` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
+ */
+export function definitionChangesUpdaterFactory(
+  log: ILogger,
+  definitionChangesFetcher: IDefinitionChangesFetcher,
+  storage: Pick<IStorageBase, 'definitions' | 'rbSegments' | 'segments' | 'save'>,
+  splitFiltersValidation: ISplitFiltersValidation,
+  definitionsEventEmitter?: IDefinitionsEventEmitter,
+  requestTimeoutBeforeReady = 0,
+  retriesOnFailureBeforeReady = 0,
+  isClientSide?: boolean
+): DefinitionChangesUpdater {
+  const { definitions, rbSegments, segments } = storage;
+
+  let startingUp = true;
+
+  /** timeout decorator for `definitionChangesFetcher` promise  */
+  function _promiseDecorator<T>(promise: Promise<T>) {
+    if (startingUp && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
+    return promise;
+  }
+
+  /**
+   * DefinitionChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch definitions or synchronize them with the storage.
+   * Returned promise will not be rejected.
+   *
+   * @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) {
+
+    /**
+     * @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 === SPLIT_UPDATE ?
+            // 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);
+            }) :
+            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
+          definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
+      )
+        .then((definitionChanges: IDefinitionChangesResponse) => {
+          const usedSegments = new Set<string>();
+
+          let updatedDefinitions: string[] = [];
+          let ffUpdate: MaybeThenable<boolean> = false;
+          if (definitionChanges.d) {
+            const { added, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
+            updatedDefinitions = names;
+            log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, added.length, removed.length]);
+            ffUpdate = definitions.update(added, removed, definitionChanges.d.till);
+          }
+
+          let rbsUpdate: MaybeThenable<boolean> = false;
+          if (definitionChanges.rbs) {
+            const { added, removed } = computeMutation(definitionChanges.rbs, usedSegments);
+            log.debug(SYNC_UPDATE, ['rule-based segments', added.length, removed.length]);
+            rbsUpdate = rbSegments.update(added, removed, definitionChanges.rbs.till);
+          }
+
+          return Promise.all([ffUpdate, rbsUpdate,
+            // @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]) => {
+            if (storage.save) storage.save();
+
+            startingUp = false;
+
+            if (definitionsEventEmitter) {
+              // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+                .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
+                .then(emitSplitsArrivedEvent => {
+                  // emit SDK events
+                  if (emitSplitsArrivedEvent) {
+                    const metadata: SdkUpdateMetadata = {
+                      type: updatedDefinitions.length > 0 ? definitionChangesFetcher.type === 'configs' ? CONFIGS_UPDATE : FLAGS_UPDATE : SEGMENTS_UPDATE,
+                      names: updatedDefinitions.length > 0 ? updatedDefinitions : []
+                    };
+                    definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, metadata);
+                  }
+                  return true;
+                });
+            }
+            return true;
+          });
+        })
+        .catch(error => {
+          if (startingUp && retriesOnFailureBeforeReady > retry) {
+            retry += 1;
+            log.warn(SYNC_FETCH_RETRY, [definitionChangesFetcher.type, retry, error]);
+            return _definitionChangesUpdater(sinces, retry);
+          } else {
+            startingUp = false;
+            log.warn(SYNC_FETCH_FAILS, [definitionChangesFetcher.type, error]);
+          }
+          return false;
+        });
+    }
+
+    // `getChangeNumber` never rejects or throws error
+    return Promise.all([definitions.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
+  };
+}

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

@@ -4,11 +4,11 @@ import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
-import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../../storages/AbstractDefinitionsCacheSync';
 
 type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -76,7 +76,7 @@ export function mySegmentsUpdaterFactory(
     return updaterPromise.catch(error => {
       if (startingUp && retriesOnFailureBeforeReady > retry) {
         retry += 1;
-        log.warn(SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
+        log.warn(SYNC_FETCH_RETRY, ['memberships', retry, error]);
         return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
       } else {
         startingUp = false;