@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.0

package/src/evaluator/matchers/rbsegment.ts

@@ -0,0 +1,61 @@
+import { IRBSegment, MaybeThenable } from '../../dtos/types';
+import { IStorageAsync, IStorageSync } from '../../storages/types';
+import { ILogger } from '../../logger/types';
+import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
+import { thenable } from '../../utils/promise/thenable';
+import { getMatching, keyParser } from '../../utils/key';
+import { parser } from '../parser';
+
+
+export function ruleBasedSegmentMatcherContext(segmentName: string, storage: IStorageSync | IStorageAsync, log: ILogger) {
+
+  return function ruleBasedSegmentMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+
+    function matchConditions(rbsegment: IRBSegment) {
+      const conditions = rbsegment.conditions;
+      const evaluator = parser(log, conditions, storage);
+
+      const evaluation = evaluator(
+        keyParser(key),
+        undefined,
+        undefined,
+        undefined,
+        attributes,
+        splitEvaluator
+      );
+
+      return thenable(evaluation) ?
+        evaluation.then(evaluation => evaluation ? true : false) :
+        evaluation ? true : false;
+    }
+
+    function isExcluded(rbSegment: IRBSegment) {
+      const matchingKey = getMatching(key);
+
+      if (rbSegment.excluded.keys.indexOf(matchingKey) !== -1) return true;
+
+      const isInSegment = rbSegment.excluded.segments.map(segmentName => {
+        return storage.segments.isInSegment(segmentName, matchingKey);
+      });
+
+      return isInSegment.length && thenable(isInSegment[0]) ?
+        Promise.all(isInSegment).then(results => results.some(result => result)) :
+        isInSegment.some(result => result);
+    }
+
+    function isInSegment(rbSegment: IRBSegment | null) {
+      if (!rbSegment) return false;
+      const excluded = isExcluded(rbSegment);
+
+      return thenable(excluded) ?
+        excluded.then(excluded => excluded ? false : matchConditions(rbSegment)) :
+        excluded ? false : matchConditions(rbSegment);
+    }
+
+    const rbSegment = storage.rbSegments.get(segmentName);
+
+    return thenable(rbSegment) ?
+      rbSegment.then(isInSegment) :
+      isInSegment(rbSegment);
+  };
+}

package/src/evaluator/matchersTransform/index.ts

@@ -95,6 +95,9 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER
     ) {
       value = stringMatcherData;
+    } else if (type === matcherTypes.IN_RULE_BASED_SEGMENT) {
+      value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
+      dataType = matcherDataTypes.NOT_SPECIFIED;
     }
 
     return {

package/src/evaluator/parser/index.ts

@@ -37,7 +37,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       }
 
       // Evaluator function.
-      return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
+      return (key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         let result: MaybeThenable<boolean> = false;
 
@@ -71,12 +71,12 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
     predicates.push(conditionContext(
       log,
       andCombinerContext(log, expressions),
-      Treatments.parse(partitions),
+      partitions && Treatments.parse(partitions),
       label,
       conditionType
     ));
   }
 
-  // Instanciate evaluator given the set of conditions using if else if logic
+  // Instantiate evaluator given the set of conditions using if else if logic
   return ifElseIfCombinerContext(log, predicates);
 }

package/src/evaluator/types.ts

@@ -29,6 +29,6 @@ export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDi
 
 export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
+export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
 
-export type IMatcher = (...args: any) => MaybeThenable<boolean>
+export type IMatcher = (value: string | number | boolean | string[] | IDependencyMatcherValue, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
+export function sanitizeValue(log: ILogger, key: SplitIO.SplitKey, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: SplitIO.SplitKey, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -60,6 +60,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
     case matcherTypes.BETWEEN:
       return dataType === 'DATETIME' ? zeroSinceSS : undefined;
     case matcherTypes.IN_SPLIT_TREATMENT:
+    case matcherTypes.IN_RULE_BASED_SEGMENT:
       return dependencyProcessor;
     default:
       return undefined;
@@ -69,9 +70,9 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | SplitIO.SplitKey | undefined, dataType: string, attributes?: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
-  let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
+  let sanitizedValue: string | number | boolean | Array<string> | IDependencyMatcherValue | undefined;
 
   switch (dataType) {
     case matcherDataTypes.NUMBER:
@@ -88,7 +89,7 @@ export function sanitize(log: ILogger, matcherTypeID: number, value: string | nu
       sanitizedValue = sanitizeBoolean(value);
       break;
     case matcherDataTypes.NOT_SPECIFIED:
-      sanitizedValue = value;
+      sanitizedValue = value as any;
       break;
     default:
       sanitizedValue = undefined;

package/src/logger/constants.ts

@@ -20,9 +20,8 @@ export const RETRIEVE_CLIENT_EXISTING = 28;
 export const RETRIEVE_MANAGER = 29;
 export const SYNC_OFFLINE_DATA = 30;
 export const SYNC_SPLITS_FETCH = 31;
-export const SYNC_SPLITS_NEW = 32;
-export const SYNC_SPLITS_REMOVED = 33;
-export const SYNC_SPLITS_SEGMENTS = 34;
+export const SYNC_SPLITS_UPDATE = 32;
+export const SYNC_RBS_UPDATE = 33;
 export const STREAMING_NEW_MESSAGE = 35;
 export const SYNC_TASK_START = 36;
 export const SYNC_TASK_EXECUTE = 37;

package/src/logger/messages/debug.ts

@@ -20,10 +20,9 @@ export const codesDebug: [number, string][] = codesInfo.concat([
   [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],
   // synchronizer
   [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
-  [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s'],
-  [c.SYNC_SPLITS_NEW, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s'],
-  [c.SYNC_SPLITS_REMOVED, c.LOG_PREFIX_SYNC_SPLITS + 'Removed feature flags %s'],
-  [c.SYNC_SPLITS_SEGMENTS, c.LOG_PREFIX_SYNC_SPLITS + 'Segment names collected %s'],
+  [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s and rbSince = %s.'],
+  [c.SYNC_SPLITS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s. Removed feature flags %s.'],
+  [c.SYNC_RBS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New rule-based segments %s. Removed rule-based segments %s.'],
   [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
   [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],
   [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],

package/src/logger/messages/warn.ts

@@ -33,7 +33,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
 
   [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
-  [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
+  [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing %s notification: %s'],
   [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
   [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
   [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],

package/src/sdkManager/index.ts

@@ -17,7 +17,7 @@ function collectTreatments(splitObject: ISplit) {
   // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.
   if (!allTreatmentsCondition) allTreatmentsCondition = conditions[0];
   // Then extract the treatments from the partitions
-  return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
+  return allTreatmentsCondition ? allTreatmentsCondition.partitions!.map(v => v.treatment) : [];
 }
 
 function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {

package/src/services/splitApi.ts

@@ -53,8 +53,8 @@ export function splitApiFactory(
       return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
     },
 
-    fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
-      const url = `${urls.sdk}/splitChanges?s=${flagSpecVersion}&since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+    fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
+      const url = `${urls.sdk}/splitChanges?s=${flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
         .catch((err) => {
           if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);

package/src/services/types.ts

@@ -35,7 +35,7 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
-export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>
+export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -8,12 +8,22 @@ import { objectAssign } from '../utils/lang/objectAssign';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  abstract addSplit(name: string, split: ISplit): Promise<boolean>
-  abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>
-  abstract removeSplits(names: string[]): Promise<boolean[] | void>
+  protected abstract addSplit(split: ISplit): Promise<boolean>
+  protected abstract removeSplit(name: string): Promise<boolean>
+  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
+
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
+      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF.name)))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
   abstract getSplit(name: string): Promise<ISplit | null>
   abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
-  abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   abstract getChangeNumber(): Promise<number>
   abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
@@ -52,7 +62,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
         newSplit.defaultTreatment = defaultTreatment;
         newSplit.changeNumber = changeNumber;
 
-        return this.addSplit(name, newSplit);
+        return this.addSplit(newSplit);
       }
       return false;
     }).catch(() => false);

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,5 @@
 import { ISplitsCacheSync } from './types';
-import { ISplit } from '../dtos/types';
+import { IRBSegment, ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
@@ -9,16 +9,14 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: ISplit): boolean
+  protected abstract addSplit(split: ISplit): boolean
+  protected abstract removeSplit(name: string): boolean
+  protected abstract setChangeNumber(changeNumber: number): boolean | void
 
-  addSplits(entries: [string, ISplit][]): boolean[] {
-    return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
-  }
-
-  abstract removeSplit(name: string): boolean
-
-  removeSplits(names: string[]): boolean[] {
-    return names.map(name => this.removeSplit(name));
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null
@@ -31,8 +29,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean | void
-
   abstract getChangeNumber(): number
 
   getAll(): ISplit[] {
@@ -71,7 +67,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
       newSplit.defaultTreatment = defaultTreatment;
       newSplit.changeNumber = changeNumber;
 
-      return this.addSplit(name, newSplit);
+      return this.addSplit(newSplit);
     }
     return false;
   }
@@ -84,8 +80,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
  * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesSegments(split: ISplit) {
-  const conditions = split.conditions || [];
+export function usesSegments(ruleEntity: ISplit | IRBSegment) {
+  const conditions = ruleEntity.conditions || [];
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
 
@@ -95,5 +91,8 @@ export function usesSegments(split: ISplit) {
     }
   }
 
+  const excluded = (ruleEntity as IRBSegment).excluded;
+  if (excluded && excluded.segments && excluded.segments.length > 0) return true;
+
   return false;
 }

package/src/storages/KeyBuilder.ts

@@ -1,5 +1,4 @@
 import { ISettings } from '../types';
-import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 
 const everythingAtTheEnd = /[^.]+$/;
@@ -34,22 +33,20 @@ export class KeyBuilder {
     return `${this.prefix}.splits.till`;
   }
 
-  // NOT USED
-  // buildSplitsReady() {
-  //   return `${this.prefix}.splits.ready`;
-  // }
+  buildSplitKeyPrefix() {
+    return `${this.prefix}.split.`;
+  }
 
-  isSplitKey(key: string) {
-    return startsWith(key, `${this.prefix}.split.`);
+  buildRBSegmentKey(rbsegmentName: string) {
+    return `${this.prefix}.rbsegment.${rbsegmentName}`;
   }
 
-  buildSplitKeyPrefix() {
-    return `${this.prefix}.split.`;
+  buildRBSegmentsTillKey() {
+    return `${this.prefix}.rbsegments.till`;
   }
 
-  // Only used by InLocalStorage.
-  buildSplitsWithSegmentCountKey() {
-    return `${this.prefix}.splits.usingSegments`;
+  buildRBSegmentKeyPrefix() {
+    return `${this.prefix}.rbsegment.`;
   }
 
   buildSegmentNameKey(segmentName: string) {
@@ -60,11 +57,6 @@ export class KeyBuilder {
     return `${this.prefix}.segment.${segmentName}.till`;
   }
 
-  // NOT USED
-  // buildSegmentsReady() {
-  //   return `${this.prefix}.segments.ready`;
-  // }
-
   extractKey(builtKey: string) {
     const s = builtKey.match(everythingAtTheEnd);
 

package/src/storages/KeyBuilderCS.ts

@@ -15,7 +15,7 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   constructor(prefix: string, matchingKey: string) {
     super(prefix);
     this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
+    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet|rbsegment)\\.`);
   }
 
   /**
@@ -28,8 +28,7 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   extractSegmentName(builtSegmentKeyName: string) {
     const prefix = `${this.prefix}.${this.matchingKey}.segment.`;
 
-    if (startsWith(builtSegmentKeyName, prefix))
-      return builtSegmentKeyName.substr(prefix.length);
+    if (startsWith(builtSegmentKeyName, prefix)) return builtSegmentKeyName.slice(prefix.length);
   }
 
   buildLastUpdatedKey() {
@@ -43,6 +42,18 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   buildTillKey() {
     return `${this.prefix}.${this.matchingKey}.segments.till`;
   }
+
+  isSplitKey(key: string) {
+    return startsWith(key, `${this.prefix}.split.`);
+  }
+
+  isRBSegmentKey(key: string) {
+    return startsWith(key, `${this.prefix}.rbsegment.`);
+  }
+
+  buildSplitsWithSegmentCountKey() {
+    return `${this.prefix}.splits.usingSegments`;
+  }
 }
 
 export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {
@@ -54,7 +65,7 @@ export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string):
     extractSegmentName(builtSegmentKeyName: string) {
       const p = `${prefix}.${matchingKey}.largeSegment.`;
 
-      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
+      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.slice(p.length);
     },
 
     buildTillKey() {

package/src/storages/KeyBuilderSS.ts

@@ -53,6 +53,10 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.buildSplitKeyPrefix()}*`;
   }
 
+  searchPatternForRBSegmentKeys() {
+    return `${this.buildRBSegmentKeyPrefix()}*`;
+  }
+
   /* Telemetry keys */
 
   buildLatencyKey(method: Method, bucket: number) {

package/src/storages/dataLoader.ts

@@ -35,10 +35,9 @@ export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
-    storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+    storage.splits.update(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])), [], since);
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -0,0 +1,136 @@
+import { IRBSegment } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
+import { ISettings } from '../../types';
+import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import { IRBSegmentsCacheSync } from '../types';
+import { LOG_PREFIX } from './constants';
+
+export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
+
+  private readonly keys: KeyBuilderCS;
+  private readonly log: ILogger;
+
+  constructor(settings: ISettings, keys: KeyBuilderCS) {
+    this.keys = keys;
+    this.log = settings.log;
+  }
+
+  clear() {
+    this.getNames().forEach(name => this.remove(name));
+    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
+    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+  }
+
+  private setChangeNumber(changeNumber: number) {
+    try {
+      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+    }
+  }
+
+  private updateSegmentCount(diff: number) {
+    const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
+    // @ts-expect-error
+    if (count > 0) localStorage.setItem(segmentsCountKey, count);
+    else localStorage.removeItem(segmentsCountKey);
+  }
+
+  private add(rbSegment: IRBSegment): boolean {
+    try {
+      const name = rbSegment.name;
+      const rbSegmentKey = this.keys.buildRBSegmentKey(name);
+      const rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+      const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+
+      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+
+      let usesSegmentsDiff = 0;
+      if (previous && usesSegments(previous)) usesSegmentsDiff--;
+      if (usesSegments(rbSegment)) usesSegmentsDiff++;
+      if (usesSegmentsDiff !== 0) this.updateSegmentCount(usesSegmentsDiff);
+
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
+  }
+
+  private remove(name: string): boolean {
+    try {
+      const rbSegment = this.get(name);
+      if (!rbSegment) return false;
+
+      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+
+      if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
+
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
+  }
+
+  private getNames(): string[] {
+    const len = localStorage.length;
+    const accum = [];
+
+    let cur = 0;
+
+    while (cur < len) {
+      const key = localStorage.key(cur);
+
+      if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
+
+      cur++;
+    }
+
+    return accum;
+  }
+
+  get(name: string): IRBSegment | null {
+    const item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    return item && JSON.parse(item);
+  }
+
+  contains(names: Set<string>): boolean {
+    const namesArray = setToArray(names);
+    const namesInStorage = this.getNames();
+    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
+  }
+
+  getChangeNumber(): number {
+    const n = -1;
+    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+
+    if (value !== null) {
+      value = parseInt(value, 10);
+
+      return isNaNNumber(value) ? n : value;
+    }
+
+    return n;
+  }
+
+  usesSegments(): boolean {
+    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+
+    return isFiniteNumber(splitsWithSegmentsCount) ?
+      splitsWithSegmentsCount > 0 :
+      true;
+  }
+
+}