Polishing

Author: EmilianoSanchez

src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -3,28 +3,28 @@ import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
-import SplitIO from '../../../types/splitio';
+import { StorageAdapter } from '../types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
-  private readonly localStorage: SplitIO.Storage;
+  private readonly storage: StorageAdapter;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder, localStorage: SplitIO.Storage) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder, storage: StorageAdapter) {
     super();
     this.log = log;
     this.keys = keys;
-    this.localStorage = localStorage;
+    this.storage = storage;
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
   protected addSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (this.localStorage.getItem(segmentKey) === DEFINED) return false;
-      this.localStorage.setItem(segmentKey, DEFINED);
+      if (this.storage.getItem(segmentKey) === DEFINED) return false;
+      this.storage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -36,8 +36,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (this.localStorage.getItem(segmentKey) !== DEFINED) return false;
-      this.localStorage.removeItem(segmentKey);
+      if (this.storage.getItem(segmentKey) !== DEFINED) return false;
+      this.storage.removeItem(segmentKey);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -46,13 +46,13 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   isInSegment(name: string): boolean {
-    return this.localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+    return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
   getRegisteredSegments(): string[] {
     const registeredSegments: string[] = [];
-    for (let i = 0; i < this.localStorage.length; i++) {
-      const segmentName = this.keys.extractSegmentName(this.localStorage.key(i)!);
+    for (let i = 0; i < this.storage.length; i++) {
+      const segmentName = this.keys.extractSegmentName(this.storage.key(i)!);
       if (segmentName) registeredSegments.push(segmentName);
     }
     return registeredSegments;
@@ -64,16 +64,16 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   protected setChangeNumber(changeNumber?: number) {
     try {
-      if (changeNumber) this.localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else this.localStorage.removeItem(this.keys.buildTillKey());
+      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else this.storage.removeItem(this.keys.buildTillKey());
     } catch (e) {
       this.log.error(e);
     }
   }
 
   getChangeNumber() {
     const n = -1;
-    let value: string | number | null = this.localStorage.getItem(this.keys.buildTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -5,25 +5,24 @@ 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 { IRBSegmentsCacheSync, StorageAdapter } from '../types';
 import { LOG_PREFIX } from './constants';
-import SplitIO from '../../../types/splitio';
 
 export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
-  private readonly localStorage: SplitIO.Storage;
+  private readonly storage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: SplitIO.Storage) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
     this.keys = keys;
     this.log = settings.log;
-    this.localStorage = localStorage;
+    this.storage = storage;
   }
 
   clear() {
     this.getNames().forEach(name => this.remove(name));
-    this.localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+    this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
@@ -35,29 +34,28 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private setChangeNumber(changeNumber: number) {
     try {
-      this.localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      this.localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      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.localStorage.getItem(segmentsCountKey)) + diff;
-    // @ts-expect-error
-    if (count > 0) this.localStorage.setItem(segmentsCountKey, count);
-    else this.localStorage.removeItem(segmentsCountKey);
+    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 rbSegmentFromLocalStorage = this.localStorage.getItem(rbSegmentKey);
-      const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+      const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+      const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
-      this.localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+      this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
       let usesSegmentsDiff = 0;
       if (previous && usesSegments(previous)) usesSegmentsDiff--;
@@ -76,7 +74,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
       const rbSegment = this.get(name);
       if (!rbSegment) return false;
 
-      this.localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+      this.storage.removeItem(this.keys.buildRBSegmentKey(name));
 
       if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
@@ -88,13 +86,13 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private getNames(): string[] {
-    const len = this.localStorage.length;
+    const len = this.storage.length;
     const accum = [];
 
     let cur = 0;
 
     while (cur < len) {
-      const key = this.localStorage.key(cur);
+      const key = this.storage.key(cur);
 
       if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
 
@@ -105,7 +103,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   get(name: string): IRBSegment | null {
-    const item = this.localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    const item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
     return item && JSON.parse(item);
   }
 
@@ -117,7 +115,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   getChangeNumber(): number {
     const n = -1;
-    let value: string | number | null = this.localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);
@@ -129,7 +127,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   usesSegments(): boolean {
-    const storedCount = this.localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     return isFiniteNumber(splitsWithSegmentsCount) ?