feat(key-storage): adds key based storage provider (#20)

Author: geometricpanda

apps/www/src/app/library-components/utilities/index.ts

@@ -0,0 +1 @@
+export * from './key-storage';

apps/www/src/app/library-components/utilities/key-storage/create-key-storage.spec.ts

@@ -0,0 +1,42 @@
+import {TestBed} from "@angular/core/testing";
+import {createKeyStorage} from "./create-key-storage";
+import {KeyStorage} from "./key-storage";
+import {InMemoryStore, LocalStorageStore} from "./stores";
+
+describe('Create Key Storage', () => {
+
+  const key = 'key';
+  const defaultValue = 'default-value';
+
+  it('should return an Angular injection token', () => {
+    const token = createKeyStorage(key, defaultValue);
+    const store = TestBed.inject(token);
+    expect(store).toBeInstanceOf(KeyStorage);
+  });
+
+  it('should configure the key storage correctly', () => {
+    const token = createKeyStorage(key, defaultValue);
+    const store = TestBed.inject(token);
+    expect(store['_key']).toBe(key)
+    expect(store['_defaultValue']).toBe(defaultValue)
+  });
+
+  it('should configure the key storage to use the localStorageStore by default', () => {
+    const token = createKeyStorage(key, defaultValue);
+    const store = TestBed.inject(token);
+    expect(store['_store']).toBeInstanceOf(LocalStorageStore)
+  });
+
+  it('should configure the key storage to use the localStorage Store', () => {
+    const token = createKeyStorage(key, defaultValue, );
+    const store = TestBed.inject(token);
+    expect(store['_store']).toBeInstanceOf(LocalStorageStore)
+  });
+
+  it('should configure the key storage to use the InMemory Store', () => {
+    const token = createKeyStorage(key, defaultValue, new InMemoryStore());
+    const store = TestBed.inject(token);
+    expect(store['_store']).toBeInstanceOf(InMemoryStore)
+  });
+
+})

apps/www/src/app/library-components/utilities/key-storage/create-key-storage.ts

@@ -0,0 +1,15 @@
+import {InjectionToken} from "@angular/core";
+import {KeyStorage} from "./key-storage";
+import {localStorageStore} from "./stores";
+
+export const createKeyStorage = <T = unknown>(
+  key: string,
+  defaultValue: T,
+  store: Storage = localStorageStore,
+) =>
+  new InjectionToken(
+    `storage-key-${key}`, {
+      providedIn: 'root',
+      factory: () => new KeyStorage<T>(key, defaultValue, store)
+    });
+

apps/www/src/app/library-components/utilities/key-storage/index.ts

@@ -0,0 +1,3 @@
+export * from './stores';
+export * from './key-storage';
+export * from './create-key-storage';

apps/www/src/app/library-components/utilities/key-storage/key-storage.spec.ts

@@ -0,0 +1,52 @@
+import {KeyStorage} from "./key-storage";
+import {InMemoryStore} from "./stores";
+
+describe('Key Storage', () => {
+
+  const key = 'key';
+  const defaultValue = 'default';
+
+  let store: KeyStorage;
+
+  beforeEach(() => {
+    store = new KeyStorage(
+      key,
+      defaultValue,
+      new InMemoryStore(),
+    );
+  });
+
+  it('should return a stored record', () => {
+    const record = 'value';
+    store.setItem(record);
+
+    const returnedRecord = store.getItem();
+    expect(returnedRecord).toEqual(record);
+  });
+
+  it('should overwrite the value', () => {
+    const record1 = 'value';
+    const record2 = 'value-2';
+
+    store.setItem(record1);
+    store.setItem(record2);
+
+    const returnedRecord = store.getItem();
+    expect(returnedRecord).toEqual(record2);
+  });
+
+  it('should return the default value if the record doesnt exist', () => {
+    const returnedRecord = store.getItem();
+    expect(returnedRecord).toBe(defaultValue);
+  });
+
+  it('should return the default value for removed records', () => {
+    const record = 'value';
+    store.setItem(record);
+    store.removeItem();
+
+    const returnedRecord = store.getItem();
+    expect(returnedRecord).toEqual(defaultValue);
+  });
+
+})

apps/www/src/app/library-components/utilities/key-storage/key-storage.ts

@@ -0,0 +1,26 @@
+export class KeyStorage<T = unknown> {
+
+  constructor(
+    private _key: string,
+    private _defaultValue: T,
+    private _store: Storage,
+  ) {
+  }
+
+  getItem(): T {
+    const data = this._store.getItem(this._key);
+    return data
+      ? JSON.parse(data)
+      : this._defaultValue;
+  }
+
+  setItem(value: T): void {
+    const data = JSON.stringify(value);
+    this._store.setItem(this._key, data);
+  }
+
+  removeItem(): void {
+    this._store.removeItem(this._key);
+  }
+
+}

apps/www/src/app/library-components/utilities/key-storage/stores/in-memory.store.spec.ts

@@ -0,0 +1,119 @@
+import {InMemoryStore} from "./in-memory.store";
+
+describe('In Memory Store', () => {
+
+  let store: InMemoryStore;
+
+  beforeEach(() => {
+    store = new InMemoryStore();
+  });
+
+  it('should return the size of the store', () => {
+    const key0 = 'key-0';
+    const record0 = 'value';
+
+    const key1 = 'key-1';
+    const record1 = 'value-1';
+
+    store.setItem(key0, record0);
+    store.setItem(key1, record1);
+
+    const size = store.length;
+
+    expect(size).toEqual(2);
+  });
+
+  it('should store a record', () => {
+    const key = 'key';
+    const record = 'value';
+    store.setItem(key, record);
+    expect(store.length).toBe(1);
+  });
+
+  it('should return a stored record', () => {
+    const key = 'key';
+    const record = 'value';
+    store.setItem(key, record);
+
+    const returnedRecord = store.getItem(key);
+    expect(returnedRecord).toEqual(record);
+  });
+
+  it('should respect the integrity of individual records', () => {
+    const key1 = 'key';
+    const record1 = 'value';
+
+    const key2 = 'key-2';
+    const record2 = 'value-2';
+
+    store.setItem(key1, record1);
+    store.setItem(key2, record2);
+
+    const returnedRecord1 = store.getItem(key1);
+    const returnedRecord2 = store.getItem(key2);
+
+    expect(returnedRecord1).toEqual(record1);
+    expect(returnedRecord2).toEqual(record2);
+  });
+
+  it('should return null if a record doesnt exist', () => {
+    const key = 'key';
+    const returnedRecord = store.getItem(key);
+    expect(returnedRecord).toBeNull();
+  });
+
+  it('should remove records', () => {
+    const key = 'key';
+    const record = 'value';
+    store.setItem(key, record);
+
+    expect(store.length).toBe(1);
+
+    store.removeItem(key);
+    expect(store.length).toBe(0);
+  });
+
+  it('should return null for removed records', () => {
+    const key = 'key';
+    const record = 'value';
+    store.setItem(key, record);
+
+    expect(store.length).toBe(1);
+
+    store.removeItem(key);
+    const returnedRecord = store.getItem(key);
+    expect(returnedRecord).toBeNull();
+  });
+
+  it('should return the zero indexed key for index 1', () => {
+    const key0 = 'key-0';
+    const record0 = 'value';
+
+    const key1 = 'key-1';
+    const record1 = 'value-1';
+
+    store.setItem(key0, record0);
+    store.setItem(key1, record1);
+
+    const returnedKey = store.key(1);
+    expect(returnedKey).toEqual(key1);
+
+  });
+
+  it('should remove all keys', () => {
+    const key0 = 'key-0';
+    const record0 = 'value';
+
+    const key1 = 'key-1';
+    const record1 = 'value-1';
+
+    store.setItem(key0, record0);
+    store.setItem(key1, record1);
+
+    store.clear();
+    const size = store.length;
+
+    expect(size).toEqual(0);
+  });
+
+})

apps/www/src/app/library-components/utilities/key-storage/stores/in-memory.store.ts

@@ -0,0 +1,30 @@
+export class InMemoryStore implements Storage {
+  private store = new Map<string, string>()
+
+  get length(): number {
+    return this.store.size;
+  }
+
+  key(index: number): string | null {
+    const keys = Object.keys(Object.fromEntries(this.store));
+    return keys[index] || null;
+  }
+
+  getItem(key: string): string | null {
+    return this.store.get(key) || null;
+  }
+
+  setItem(key: string, value: string): void {
+    this.store.set(key, value);
+  }
+
+  removeItem(key: string): void {
+    this.store.delete(key);
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+export const inMemoryStore = new InMemoryStore();

apps/www/src/app/library-components/utilities/key-storage/stores/index.ts

@@ -0,0 +1,2 @@
+export * from './in-memory.store';
+export * from './local-storage.store';