@splitsoftware/splitio-commons 2.11.1-rc.2 → 3.0.0-rc.0

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -2,7 +2,7 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { returnDifference } from '../../utils/lang/sets';
@@ -31,14 +31,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: IDefinition) {
     const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
     return this.wrapper.decr(ttKey).then(count => {
       if (count === 0) return this.wrapper.del(ttKey);
     });
   }
 
-  private _incrementCounts(split: ISplit) {
+  private _incrementCounts(split: IDefinition) {
     const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
     return this.wrapper.incr(ttKey);
   }
@@ -66,13 +66,13 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(split: ISplit): Promise<boolean> {
+  addSplit(split: IDefinition): Promise<boolean> {
     const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
+      let parsedPreviousSplit: IDefinition, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
         stringifiedNewSplit = JSON.stringify(split);
@@ -112,7 +112,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<ISplit | null> {
+  getSplit(name: string): Promise<IDefinition | null> {
     return this.wrapper.get(this.keys.buildSplitKey(name))
       .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
@@ -122,11 +122,11 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
+  getSplits(names: string[]): Promise<Record<string, IDefinition | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, ISplit | null> = {};
+      const splits: Record<string, IDefinition | null> = {};
       names.forEach((name, idx) => {
         const split = splitDefinitions[idx];
         splits[name] = split && JSON.parse(split);
@@ -140,7 +140,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<ISplit[]> {
+  getAll(): Promise<IDefinition[]> {
     return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
       .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
       .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {

package/src/storages/types.ts

@@ -1,5 +1,6 @@
 import SplitIO from '../../types/splitio';
-import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse, IMembershipsResponse, ISegmentChangesResponse, ISplitChangesResponse } from '../dtos/types';
+import { MaybeThenable, IDefinition, IRBSegment, IMySegmentsResponse, IMembershipsResponse, ISegmentChangesResponse } from '../dtos/types';
+import { ISplitChangesResponse } from '../sync/polling/fetchers/splitChangesFetcher';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { ISettings } from '../types';
@@ -194,12 +195,12 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): MaybeThenable<boolean>,
-  getSplit(name: string): MaybeThenable<ISplit | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
+  getSplit(name: string): MaybeThenable<IDefinition | null>,
+  getSplits(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.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<ISplit[]>,
+  getAll(): MaybeThenable<IDefinition[]>,
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
@@ -211,11 +212,11 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean,
-  getSplit(name: string): ISplit | null,
-  getSplits(names: string[]): Record<string, ISplit | null>,
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean,
+  getSplit(name: string): IDefinition | null,
+  getSplits(names: string[]): Record<string, IDefinition | null>,
   getChangeNumber(): number,
-  getAll(): ISplit[],
+  getAll(): IDefinition[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
@@ -225,11 +226,11 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean>,
-  getSplit(name: string): Promise<ISplit | null>,
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
+  getSplit(name: string): Promise<IDefinition | null>,
+  getSplits(names: string[]): Promise<Record<string, IDefinition | null>>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<ISplit[]>,
+  getAll(): Promise<IDefinition[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
@@ -241,7 +242,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 /** Rule-Based Segments cache */
 
 export interface IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): MaybeThenable<boolean>,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
   get(name: string): MaybeThenable<IRBSegment | null>,
   getChangeNumber(): MaybeThenable<number>,
   clear(): MaybeThenable<boolean | void>,
@@ -249,7 +250,7 @@ export interface IRBSegmentsCacheBase {
 }
 
 export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean,
   get(name: string): IRBSegment | null,
   getChangeNumber(): number,
   getAll(): IRBSegment[],
@@ -260,7 +261,7 @@ export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
 }
 
 export interface IRBSegmentsCacheAsync extends IRBSegmentsCacheBase {
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean>,
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean>,
   get(name: string): Promise<IRBSegment | null>,
   getChangeNumber(): Promise<number>,
   clear(): Promise<boolean | void>,
@@ -527,6 +528,10 @@ export interface IStorageFactoryParams {
    * For emitting SDK_READY_FROM_CACHE event in consumer mode with Redis to allow immediate evaluations
    */
   onReadyFromCacheCb: () => void,
+  /**
+   * If true, telemetry will not be recorded.
+   */
+  disableTelemetry?: boolean,
 }
 
 

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

@@ -1,4 +1,4 @@
-import { ISplitCondition } from '../../../dtos/types';
+import { IDefinitionCondition } from '../../../dtos/types';
 import { isString } from '../../../utils/lang';
 
 export interface IMockSplitEntry {
@@ -7,7 +7,7 @@ export interface IMockSplitEntry {
   config?: string
 }
 
-export function parseCondition(data: IMockSplitEntry): ISplitCondition {
+export function parseCondition(data: IMockSplitEntry): IDefinitionCondition {
   const treatment = data.treatment;
 
   if (data.keys) {

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

@@ -1,4 +1,4 @@
-import { ISplitPartial } from '../../../dtos/types';
+import { IDefinitionPartial } from './types';
 import SplitIO from '../../../../types/splitio';
 import { isObject, forOwn, merge } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
@@ -41,12 +41,12 @@ export function splitsParserFromSettingsFactory() {
    *
    * @param settings - validated object with mocked features mapping.
    */
-  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): false | Record<string, ISplitPartial> {
+  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): false | Record<string, IDefinitionPartial> {
     const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;
 
-    const splitObjects: Record<string, ISplitPartial> = {};
+    const splitObjects: Record<string, IDefinitionPartial> = {};
 
     forOwn(features, (data, splitName) => {
       let treatment = data;

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

@@ -1,5 +1,8 @@
-import { ISplitPartial } from '../../../dtos/types';
+import { IDefinition } from '../../../dtos/types';
 import { ISettings } from '../../../types';
 
-// Analog to `ISplitChangesFetcher` used by `splitChangesUpdaterFactory`
-export type ISplitsParser = (settings: ISettings) => false | Record<string, ISplitPartial>
+// 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>

package/src/sync/offline/syncManagerOffline.ts

@@ -1,7 +1,7 @@
 import { ISyncManagerCS } from '../types';
 import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
 import { objectAssign } from '../../utils/lang/objectAssign';
-import { ISplitsParser } from './splitsParser/types';
+import { IDefinitionsParser } from './splitsParser/types';
 import { IReadinessManager } from '../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
@@ -17,7 +17,7 @@ function flush() {
  * @param splitsParser - e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
 export function syncManagerOfflineFactory(
-  splitsParserFactory: () => ISplitsParser
+  splitsParserFactory: () => IDefinitionsParser
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**

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

@@ -1,8 +1,8 @@
 import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { IStorageSync } from '../../../storages/types';
-import { ISplitsParser } from '../splitsParser/types';
-import { ISplit, ISplitPartial } from '../../../dtos/types';
+import { IDefinitionsParser, IDefinitionPartial } from '../splitsParser/types';
+import { IDefinition } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
@@ -14,7 +14,7 @@ import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/c
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 export function fromObjectUpdaterFactory(
-  splitsParser: ISplitsParser,
+  splitsParser: IDefinitionsParser,
   storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings,
@@ -24,9 +24,9 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: ISplit[] = [];
+    const splits: IDefinition[] = [];
     let loadError = null;
-    let splitsMock: false | Record<string, ISplitPartial> = {};
+    let splitsMock: false | Record<string, IDefinitionPartial> = {};
     try {
       splitsMock = splitsParser(settings);
     } catch (err) {
@@ -80,7 +80,7 @@ export function fromObjectUpdaterFactory(
  * PollingManager in Offline mode
  */
 export function fromObjectSyncTaskFactory(
-  splitsParser: ISplitsParser,
+  splitsParser: IDefinitionsParser,
   storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings

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[]
+  },
+  rbs?: {
+    t: number,
+    s?: number,
+    d: IRBSegment[]
+  }
+}
+
+/** 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) =>
+            .then((splitChangesResponse: IDefinitionChangesResponse) =>
               Promise.all([storage.splits.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 { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
 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> = {};
@@ -44,7 +46,7 @@ export function pollingManagerCSFactory(
 
   // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
+    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']);
@@ -71,14 +73,14 @@ export function pollingManagerCSFactory(
   }
 
   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,27 +1,26 @@
 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,
@@ -30,6 +29,6 @@ export function splitsSyncTaskFactory(
       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, splitUpdateNotification?: { 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
 }