@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -1,137 +0,0 @@
-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, StorageAdapter } from '../types';
-import { LOG_PREFIX } from './constants';
-
-export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
-
-  private readonly keys: KeyBuilderCS;
-  private readonly log: ILogger;
-  private readonly storage: StorageAdapter;
-
-  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
-    this.keys = keys;
-    this.log = settings.log;
-    this.storage = storage;
-  }
-
-  clear() {
-    this.getNames().forEach(name => this.remove(name));
-    this.storage.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 {
-      this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      this.storage.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(this.storage.getItem(segmentsCountKey)) + diff;
-    if (count > 0) this.storage.setItem(segmentsCountKey, count + '');
-    else this.storage.removeItem(segmentsCountKey);
-  }
-
-  private add(rbSegment: IRBSegment): boolean {
-    try {
-      const name = rbSegment.name;
-      const rbSegmentKey = this.keys.buildRBSegmentKey(name);
-      const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-      const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
-
-      this.storage.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;
-
-      this.storage.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 = this.storage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = this.storage.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 = this.storage.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 = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  usesSegments(): boolean {
-    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
-  }
-
-}

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,241 +0,0 @@
-import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
-import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger } from '../../logger/types';
-import { LOG_PREFIX } from './constants';
-import { ISettings } from '../../types';
-import { setToArray } from '../../utils/lang/sets';
-import { StorageAdapter } from '../types';
-
-export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
-
-  private readonly keys: KeyBuilderCS;
-  private readonly log: ILogger;
-  private readonly flagSetsFilter: string[];
-  private hasSync?: boolean;
-  private readonly storage: StorageAdapter;
-
-  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
-    super();
-    this.keys = keys;
-    this.log = settings.log;
-    this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-    this.storage = storage;
-  }
-
-  private _decrementCount(key: string) {
-    const count = toNumber(this.storage.getItem(key)) - 1;
-    if (count > 0) this.storage.setItem(key, count + '');
-    else this.storage.removeItem(key);
-  }
-
-  private _decrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this._decrementCount(ttKey);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this._decrementCount(segmentsCountKey);
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-  private _incrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-
-  /**
-   * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
-   * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-   */
-  clear() {
-    // collect item keys
-    const len = this.storage.length;
-    const accum = [];
-    for (let cur = 0; cur < len; cur++) {
-      const key = this.storage.key(cur);
-      if (key != null && this.keys.isSplitsCacheKey(key)) accum.push(key);
-    }
-    // remove items
-    accum.forEach(key => {
-      this.storage.removeItem(key);
-    });
-
-    this.hasSync = false;
-  }
-
-  addSplit(split: ISplit) {
-    try {
-      const name = split.name;
-      const splitKey = this.keys.buildSplitKey(name);
-      const splitFromStorage = this.storage.getItem(splitKey);
-      const previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-
-      if (previousSplit) {
-        this._decrementCounts(previousSplit);
-        this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-      }
-
-      this.storage.setItem(splitKey, JSON.stringify(split));
-
-      this._incrementCounts(split);
-      this.addToFlagSets(split);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  removeSplit(name: string): boolean {
-    try {
-      const split = this.getSplit(name);
-      if (!split) return false;
-
-      this.storage.removeItem(this.keys.buildSplitKey(name));
-
-      this._decrementCounts(split);
-      this.removeFromFlagSets(split.name, split.sets);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  getSplit(name: string): ISplit | null {
-    const item = this.storage.getItem(this.keys.buildSplitKey(name));
-    return item && JSON.parse(item);
-  }
-
-  setChangeNumber(changeNumber: number): boolean {
-    try {
-      this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
-      // update "last updated" timestamp with current time
-      this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-      this.hasSync = true;
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  getChangeNumber(): number {
-    const n = -1;
-    let value: string | number | null = this.storage.getItem(this.keys.buildSplitsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  getSplitNames(): string[] {
-    const len = this.storage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = this.storage.key(cur);
-
-      if (key != null && this.keys.isSplitKey(key)) accum.push(this.keys.extractKey(key));
-
-      cur++;
-    }
-
-    return accum;
-  }
-
-  trafficTypeExists(trafficType: string): boolean {
-    const ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-    return isFiniteNumber(ttCount) && ttCount > 0;
-  }
-
-  usesSegments() {
-    // If cache hasn't been synchronized with the cloud, assume we need them.
-    if (!this.hasSync) return true;
-
-    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
-  }
-
-  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
-    return flagSets.map(flagSet => {
-      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-      return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-    });
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
-
-      const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-      const flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-      flagSetCache.add(featureFlag.name);
-
-      this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
-    if (!flagSets) return;
-
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-
-    const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-    if (!flagSetFromStorage) return;
-
-    const flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-    flagSetCache.delete(featureFlagName);
-
-    if (flagSetCache.size === 0) {
-      this.storage.removeItem(flagSetKey);
-      return;
-    }
-
-    this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-  }
-
-}

package/src/storages/inLocalStorage/constants.ts

@@ -1,2 +0,0 @@
-export const LOG_PREFIX = 'storage:localstorage: ';
-export const DEFINED = '1';

package/src/storages/inLocalStorage/index.ts

@@ -1,104 +0,0 @@
-import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory, StorageAdapter } from '../types';
-import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
-import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
-import { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
-import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
-import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
-import { ILogger } from '../../logger/types';
-import SplitIO from '../../../types/splitio';
-import { storageAdapter } from './storageAdapter';
-
-function validateStorage(log: ILogger, prefix: string, wrapper?: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): StorageAdapter | undefined {
-  if (wrapper) {
-    if (isValidStorageWrapper(wrapper)) {
-      return isWebStorage(wrapper) ?
-        wrapper as StorageAdapter: // localStorage and sessionStorage don't need adapter
-        storageAdapter(log, prefix, wrapper);
-    }
-    log.warn(LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
-  }
-
-  if (isLocalStorageAvailable()) return localStorage;
-
-  log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-}
-
-/**
- * InLocal storage factory for standalone client-side SplitFactory
- */
-export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): IStorageSyncFactory {
-
-  const prefix = validatePrefix(options.prefix);
-
-  function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
-
-    const storage = validateStorage(log, prefix, options.wrapper);
-    if (!storage) return InMemoryStorageCSFactory(params);
-
-    const matchingKey = getMatching(settings.core.key);
-    const keys = new KeyBuilderCS(prefix, matchingKey);
-
-    const splits = new SplitsCacheInLocal(settings, keys, storage);
-    const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
-    const segments = new MySegmentsCacheInLocal(log, keys, storage);
-    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
-    let validateCachePromise: Promise<boolean> | undefined;
-
-    return {
-      splits,
-      rbSegments,
-      segments,
-      largeSegments,
-      impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-      impressionCounts: new ImpressionCountsCacheInMemory(),
-      events: new EventsCacheInMemory(eventsQueueSize),
-      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-      uniqueKeys: new UniqueKeysCacheInMemoryCS(),
-
-      validateCache() {
-        return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
-      },
-
-      save() {
-        return storage.save && storage.save();
-      },
-
-      destroy() {
-        return storage.whenSaved && storage.whenSaved();
-      },
-
-      // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
-      shared(matchingKey: string) {
-
-        return {
-          splits: this.splits,
-          rbSegments: this.rbSegments,
-          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
-          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),
-          impressions: this.impressions,
-          impressionCounts: this.impressionCounts,
-          events: this.events,
-          telemetry: this.telemetry,
-          uniqueKeys: this.uniqueKeys,
-
-          destroy() { }
-        };
-      },
-    };
-  }
-
-  InLocalStorageCSFactory.type = STORAGE_LOCALSTORAGE;
-  return InLocalStorageCSFactory;
-}

package/src/storages/inLocalStorage/storageAdapter.ts

@@ -1,62 +0,0 @@
-import { ILogger } from '../../logger/types';
-import SplitIO from '../../../types/splitio';
-import { LOG_PREFIX } from './constants';
-import { StorageAdapter } from '../types';
-
-
-export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): Required<StorageAdapter> {
-  let keys: string[] = [];
-  let cache: Record<string, string> = {};
-
-  let loadPromise: Promise<void> | undefined;
-  let savePromise = Promise.resolve();
-
-  return {
-    load() {
-      return loadPromise || (loadPromise = Promise.resolve().then(() => {
-        return wrapper.getItem(prefix);
-      }).then((storedCache) => {
-        cache = JSON.parse(storedCache || '{}');
-        keys = Object.keys(cache);
-      }).catch((e) => {
-        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
-      }));
-    },
-
-    save() {
-      return savePromise = savePromise.then(() => {
-        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
-      }).catch((e) => {
-        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
-      });
-    },
-
-    whenSaved() {
-      return savePromise;
-    },
-
-    get length() {
-      return keys.length;
-    },
-
-    getItem(key: string) {
-      return cache[key] || null;
-    },
-
-    key(index: number) {
-      return keys[index] || null;
-    },
-
-    removeItem(key: string) {
-      const index = keys.indexOf(key);
-      if (index === -1) return;
-      keys.splice(index, 1);
-      delete cache[key];
-    },
-
-    setItem(key: string, value: string) {
-      if (keys.indexOf(key) === -1) keys.push(key);
-      cache[key] = value;
-    }
-  };
-}

package/src/storages/inLocalStorage/validateCache.ts

@@ -1,99 +0,0 @@
-import { ISettings } from '../../types';
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { getStorageHash } from '../KeyBuilder';
-import { LOG_PREFIX } from './constants';
-import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
-import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { KeyBuilderCS } from '../KeyBuilderCS';
-import SplitIO from '../../../types/splitio';
-import { StorageAdapter } from '../types';
-
-const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
-const MILLIS_IN_A_DAY = 86400000;
-
-/**
- * Validates if cache should be cleared and sets the cache `hash` if needed.
- *
- * @returns `true` if cache should be cleared, `false` otherwise
- */
-function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
-  const { log } = settings;
-
-  // Check expiration
-  const lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()) as string, 10);
-  if (!isNaNNumber(lastUpdatedTimestamp)) {
-    const cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
-    const expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
-    if (lastUpdatedTimestamp < expirationTimestamp) {
-      log.info(LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
-      return true;
-    }
-  }
-
-  // Check hash
-  const storageHashKey = keys.buildHashKey();
-  const storageHash = storage.getItem(storageHashKey);
-  const currentStorageHash = getStorageHash(settings);
-
-  if (storageHash !== currentStorageHash) {
-    try {
-      storage.setItem(storageHashKey, currentStorageHash);
-    } catch (e) {
-      log.error(LOG_PREFIX + e);
-    }
-    if (isThereCache) {
-      log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
-      return true;
-    }
-    return false; // No cache to clear
-  }
-
-  // Clear on init
-  if (options.clearOnInit) {
-    const lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()) as string, 10);
-
-    if (isNaNNumber(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
-      log.info(LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
-      return true;
-    }
-  }
-}
-
-/**
- * Clean cache if:
- * - it has expired, i.e., its `lastUpdated` timestamp is older than the given `expirationTimestamp`
- * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
- * - `clearOnInit` was set and cache was not cleared in the last 24 hours
- *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
- */
-export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
-
-  return Promise.resolve(storage.load && storage.load()).then(() => {
-    const currentTimestamp = Date.now();
-    const isThereCache = splits.getChangeNumber() > -1;
-
-    if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-      splits.clear();
-      rbSegments.clear();
-      segments.clear();
-      largeSegments.clear();
-
-      // Update last clear timestamp
-      try {
-        storage.setItem(keys.buildLastClear(), currentTimestamp + '');
-      } catch (e) {
-        settings.log.error(LOG_PREFIX + e);
-      }
-
-      // Persist clear
-      if (storage.save) storage.save();
-
-      return false;
-    }
-
-    // Check if ready from cache
-    return isThereCache;
-  });
-}