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

package/src/storages/pluggable/DefinitionsCachePluggable.ts

@@ -0,0 +1,230 @@
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { KeyBuilder } from '../KeyBuilder';
+import { IPluggableStorageWrapper } from '../types';
+import { ILogger } from '../../logger/types';
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
+import { LOG_PREFIX } from './constants';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
+import { returnDifference } from '../../utils/lang/sets';
+
+/**
+ * IDefinitionsCacheAsync implementation for pluggable storages.
+ */
+export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilder;
+  private readonly wrapper: IPluggableStorageWrapper;
+  private readonly setsFilter: string[];
+
+  /**
+   * Create a DefinitionsCache that uses a storage wrapper.
+   * @param log -  Logger instance.
+   * @param keys -  Key builder.
+   * @param wrapper -  Adapted wrapper storage.
+   */
+  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation) {
+    super();
+    this.log = log;
+    this.keys = keys;
+    this.wrapper = wrapper;
+    this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+  }
+
+  private _decrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+    return this.wrapper.decr(ttKey).then(count => {
+      if (count === 0) return this.wrapper.del(ttKey);
+    });
+  }
+
+  private _incrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+    return this.wrapper.incr(ttKey);
+  }
+
+  private _updateSets(definitionName: string, setsOfRemovedDefinition?: string[] | null, setsOfAddedDefinition?: string[] | null) {
+    const removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+
+    let addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+    if (this.setsFilter.length > 0) {
+      addToSets = addToSets.filter(set => {
+        return this.setsFilter.some(filterSet => filterSet === set);
+      });
+    }
+
+    const items = [definitionName];
+
+    return Promise.all([
+      ...removeFromSets.map(setName => this.wrapper.removeItems(this.keys.buildSetKey(setName), items)),
+      ...addToSets.map(setName => this.wrapper.addItems(this.keys.buildSetKey(setName), items))
+    ]);
+  }
+
+  /**
+   * Add a given definition.
+   * The returned promise is resolved when the operation success
+   * or rejected if it fails (e.g., wrapper operation fails)
+   */
+  add(definition: IDefinition): Promise<boolean> {
+    const name = definition.name;
+    const definitionKey = this.keys.buildDefinitionKey(name);
+    return this.wrapper.get(definitionKey).then(definitionFromStorage => {
+
+      // handling parsing error
+      let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
+      try {
+        parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        stringifiedNewDefinition = JSON.stringify(definition);
+      } catch (e) {
+        throw new Error('Error parsing feature flag definition: ' + e);
+      }
+
+      return this.wrapper.set(definitionKey, stringifiedNewDefinition).then(() => {
+        // avoid unnecessary increment/decrement operations
+        if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
+
+        // update traffic type counts
+        return this._incrementCounts(definition).then(() => {
+          if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
+        });
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
+    }).then(() => true);
+  }
+
+  /**
+   * Remove a given definition.
+   * The returned promise is resolved when the operation success, with a boolean indicating if the definition existed or not.
+   * or rejected if it fails (e.g., wrapper operation fails).
+   */
+  remove(name: string) {
+    return this.get(name).then((definition) => {
+      if (definition) {
+        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
+      }
+    }).then(() => {
+      return this.wrapper.del(this.keys.buildDefinitionKey(name));
+    });
+  }
+
+  /**
+   * Get definition.
+   * The returned promise is resolved with the definition or null if it's not defined,
+   * or rejected if wrapper operation fails.
+   */
+  get(name: string): Promise<IDefinition | null> {
+    return this.wrapper.get(this.keys.buildDefinitionKey(name))
+      .then(maybeDefinition => maybeDefinition && JSON.parse(maybeDefinition));
+  }
+
+  /**
+   * Get list of definitions.
+   * The returned promise is resolved with a map of names to their definition or null if it's not defined,
+   * or rejected if wrapper operation fails.
+   */
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>> {
+    const keys = names.map(name => this.keys.buildDefinitionKey(name));
+
+    return this.wrapper.getMany(keys).then(stringifiedDefinitions => {
+      const definitions: Record<string, IDefinition | null> = {};
+      names.forEach((name, idx) => {
+        const definition = stringifiedDefinitions[idx];
+        definitions[name] = definition && JSON.parse(definition);
+      });
+      return Promise.resolve(definitions);
+    });
+  }
+
+  /**
+   * Get list of all definitions.
+   * The returned promise is resolved with the list of definitions,
+   * or rejected if wrapper operation fails.
+   */
+  getAll(): Promise<IDefinition[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((definitions) => definitions.map((definition) => {
+        return JSON.parse(definition as string);
+      }));
+  }
+
+  /**
+   * Get list of definition names.
+   * The returned promise is resolved with the list of names,
+   * or rejected if wrapper operation fails.
+   */
+  getNames(): Promise<string[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  /**
+   * Get list of definition names related to a given list of set names.
+   * The returned promise is resolved with the list of names per set.
+   * It never rejects (If there is a wrapper error for some set, an empty set is returned for it).
+   */
+  getNamesBySets(sets: string[]): Promise<Set<string>[]> {
+    return Promise.all(sets.map(set => {
+      const setKey = this.keys.buildSetKey(set);
+      return this.wrapper.getItems(setKey).catch(() => []);
+    })).then(namesBySets => namesBySets.map(namesBySet => new Set(namesBySet)));
+  }
+
+  /**
+   * Check traffic type existence.
+   * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+   * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
+   * It will never be rejected.
+   */
+  trafficTypeExists(trafficType: string): Promise<boolean> {
+    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
+    return this.wrapper.get(this.keys.buildTrafficTypeKey(trafficType))
+      .then((ttCount: string | null | number) => {
+        if (ttCount === null) return false; // if entry doesn't exist, means that TT doesn't exist
+
+        ttCount = parseInt(ttCount as string, 10);
+        if (!isFiniteNumber(ttCount) || ttCount < 0) {
+          this.log.info(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to data corruption of some sorts.`);
+          return false;
+        }
+
+        return ttCount > 0;
+      }).catch(e => {
+        this.log.error(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to an error: ${e}.`);
+        // If there is an error, bypass the validation so the event can get tracked.
+        return true;
+      });
+  }
+
+  /**
+   * Set till number.
+   * The returned promise is resolved when the operation success,
+   * or rejected if it fails (e.g., wrapper operation fails).
+   */
+  setChangeNumber(changeNumber: number) {
+    return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+  }
+
+  /**
+   * Get till number or -1 if it's not defined.
+   * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
+   * The promise will never be rejected.
+   */
+  getChangeNumber(): Promise<number> {
+    return this.wrapper.get(this.keys.buildDefinitionsTillKey()).then((value) => {
+      const i = parseInt(value as string, 10);
+
+      return isNaNNumber(i) ? -1 : i;
+    }).catch((e) => {
+      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+      return -1;
+    });
+  }
+
+  // @TODO implement if required by DataLoader or producer mode
+  clear() {
+    return Promise.resolve(true);
+  }
+
+}

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -36,7 +36,7 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -45,7 +45,7 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
         return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
       })),
       Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        const key = this.keys.buildRBSegmentKey(toRemove);
         return this.wrapper.del(key);
       }))
     ]).then(([, added, removed]) => {

package/src/storages/pluggable/index.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCachePluggable } from './SplitsCachePluggable';
+import { DefinitionsCachePluggable } from './DefinitionsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
 import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
@@ -118,7 +118,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     });
 
     return {
-      splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+      definitions: new DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/src/storages/setRolloutPlan.ts

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { IRBSegmentsCacheSync, ISegmentsCacheSync, ISplitsCacheSync } from './types';
+import { IRBSegmentsCacheSync, ISegmentsCacheSync, IDefinitionsCacheSync } from './types';
 import { ILogger } from '../logger/types';
 import { isObject } from '../utils/lang';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
@@ -27,20 +27,20 @@ export function validateRolloutPlan(log: ILogger, settings: SplitIO.ISettings):
  * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
-export function setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  const { splits, rbSegments, segments, largeSegments } = storage;
+export function setRolloutPlan(log: ILogger, rolloutPlan: RolloutPlan, storage: { definitions?: IDefinitionsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  const { definitions, rbSegments, segments, largeSegments } = storage;
   const { splitChanges: { ff, rbs } } = rolloutPlan;
 
   log.debug(`storage: set feature flags and segments${matchingKey ? ` for key ${matchingKey}` : ''}`);
 
-  if (splits && ff) {
-    splits.clear();
-    splits.update(ff.d, [], ff.t);
+  if (definitions && ff) {
+    definitions.clear();
+    definitions.update(ff.d || [], [], ff.t);
   }
 
   if (rbSegments && rbs) {
     rbSegments.clear();
-    rbSegments.update(rbs.d, [], rbs.t);
+    rbSegments.update(rbs.d || [], [], rbs.t);
   }
 
   const segmentChanges = rolloutPlan.segmentChanges;

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';
@@ -193,55 +194,55 @@ 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
+export interface IDefinitionsCacheBase {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
+  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.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<ISplit[]>,
-  getSplitNames(): MaybeThenable<string[]>,
+  getAll(): MaybeThenable<IDefinition[]>,
+  getNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
+  getNamesBySets(sets: string[]): MaybeThenable<Set<string>[]>
 }
 
-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>,
+export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean,
+  get(name: string): IDefinition | null,
+  getMany(names: string[]): Record<string, IDefinition | null>,
   getChangeNumber(): number,
-  getAll(): ISplit[],
-  getSplitNames(): string[],
+  getAll(): IDefinition[],
+  getNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): Set<string>[]
+  getNamesBySets(sets: string[]): Set<string>[]
 }
 
-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>>,
+export interface IDefinitionsCacheAsync extends IDefinitionsCacheBase {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
+  get(name: string): Promise<IDefinition | null>,
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<ISplit[]>,
-  getSplitNames(): Promise<string[]>,
+  getAll(): Promise<IDefinition[]>,
+  getNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
+  getNamesBySets(sets: string[]): Promise<Set<string>[]>
 }
 
 /** 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>,
@@ -465,7 +466,7 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
  */
 
 export interface IStorageBase<
-  TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
+  TDefinitionsCache extends IDefinitionsCacheBase = IDefinitionsCacheBase,
   TRBSegmentsCache extends IRBSegmentsCacheBase = IRBSegmentsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
@@ -474,7 +475,7 @@ export interface IStorageBase<
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync = ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
-  splits: TSplitsCache,
+  definitions: TDefinitionsCache,
   rbSegments: TRBSegmentsCache,
   segments: TSegmentsCache,
   largeSegments?: TSegmentsCache,
@@ -489,7 +490,7 @@ export interface IStorageBase<
 }
 
 export interface IStorageSync extends IStorageBase<
-  ISplitsCacheSync,
+  IDefinitionsCacheSync,
   IRBSegmentsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
@@ -504,7 +505,7 @@ export interface IStorageSync extends IStorageBase<
 }
 
 export interface IStorageAsync extends IStorageBase<
-  ISplitsCacheAsync,
+  IDefinitionsCacheAsync,
   IRBSegmentsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
@@ -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,32 +1,32 @@
 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';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/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';
 
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 export function fromObjectUpdaterFactory(
-  splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  splitsParser: IDefinitionsParser,
+  storage: Pick<IStorageSync, 'definitions' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings,
 ): () => Promise<boolean> {
 
-  const log = settings.log, splitsCache = storage.splits;
+  const log = settings.log, definitions = storage.definitions;
   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) {
@@ -52,17 +52,17 @@ export function fromObjectUpdaterFactory(
       });
 
       return Promise.all([
-        splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.update(splits, [], Date.now())
+        definitions.clear(), // required to sync removed splits from mock
+        definitions.update(splits, [], Date.now())
       ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, 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.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+              readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
@@ -80,8 +80,8 @@ export function fromObjectUpdaterFactory(
  * PollingManager in Offline mode
  */
 export function fromObjectSyncTaskFactory(
-  splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  splitsParser: IDefinitionsParser,
+  storage: Pick<IStorageSync, 'definitions' | 'validateCache'>,
   readiness: IReadinessManager,
   settings: ISettings
 ): ISyncTask<[], boolean> {