fix(cache): rework cache clear to only evict with a regex pattern

Author: dvcol

src/services/common/base-client.test.ts

@@ -228,12 +228,20 @@ describe('base-client.ts', () => {
       expect(spyCacheStore.delete).toHaveBeenCalledWith('key');
     });
 
-    it('should delete a cached entry', async () => {
+    it('should delete all cached entry matching regex', async () => {
+      expect.assertions(1);
+
+      await client.clearCache('key', false);
+
+      expect(spyCacheStore.clear).toHaveBeenCalledWith('key');
+    });
+
+    it('should delete all cached entry', async () => {
       expect.assertions(1);
 
       await client.clearCache();
 
-      expect(spyCacheStore.clear).toHaveBeenCalledWith();
+      expect(spyCacheStore.clear).toHaveBeenCalledWith(undefined);
     });
 
     describe('cache', () => {

src/services/common/base-client.ts

@@ -263,10 +263,11 @@ export abstract class BaseClient<
    * If no key is provided, clears the entire cache.
    *
    * @param key - The cache key.
+   * @param exact - If the key to be evicted needs to be an exact match or a regex pattern (defaults to true).
    */
-  clearCache(key?: string) {
-    if (key) return this._cache?.delete(key);
-    return this._cache?.clear();
+  clearCache(key?: string, exact = true) {
+    if (key && exact) return this._cache?.delete(key);
+    return this._cache?.clear(key);
   }
 
   /**

src/utils/browser/browser-storage.utils.ts

@@ -15,8 +15,11 @@ export const localStorage: chrome.storage.LocalStorageArea = window?.chrome?.sto
  */
 export const sessionStorage: chrome.storage.StorageArea = window?.chrome?.storage?.session;
 
-const filterObject = (object: Record<string, unknown>, regex: string) =>
-  Object.fromEntries(Object.entries(object).filter(([key]) => new RegExp(regex).test(key)));
+const filterObject = (object: Record<string, unknown>, regex: string | RegExp) =>
+  Object.fromEntries(Object.entries(object).filter(([key]) => (typeof regex === 'string' ? new RegExp(regex) : regex).test(key)));
+
+const reverseFilterObject = (object: Record<string, unknown>, regex: string | RegExp) =>
+  Object.fromEntries(Object.entries(object).filter(([key]) => !(typeof regex === 'string' ? new RegExp(regex) : regex).test(key)));
 
 /**
  * This function is used to wrap the storage areas to provide type inference and a more convenient interface.
@@ -50,18 +53,31 @@ export const storageWrapper = (area: chrome.storage.StorageArea, name: string) =
 
     window.trakt = { ...window.trakt, [name]: storage };
     return {
-      getAll: async <T>(regex?: string): Promise<T> => (regex ? filterObject(storage.values, regex) : storage.values) as T,
+      getAll: async <T>(regex?: string | RegExp): Promise<T> => (regex ? filterObject(storage.values, regex) : storage.values) as T,
       get: async <T>(key: string): Promise<T> => storage.values[key] as T,
       set: async <T>(key: string, value: T): Promise<void> => storage.setItem(key, value),
       remove: async (key: string): Promise<void> => storage.removeItem(key),
+      removeAll: async (regex: string | RegExp): Promise<void> => {
+        storage.values = reverseFilterObject(storage.values, regex);
+      },
       clear: async (): Promise<void> => storage.clear(),
     };
   }
   return {
-    getAll: <T>(regex?: string): Promise<T> => area.get().then(data => (regex ? filterObject(data, regex) : data) as T),
+    getAll: <T>(regex?: string | RegExp): Promise<T> => area.get().then(data => (regex ? filterObject(data, regex) : data) as T),
     get: <T>(key: string): Promise<T> => area.get(key).then(({ [key]: value }) => value),
     set: <T>(key: string, value: T): Promise<void> => area.set({ [key]: value }),
     remove: (key: string): Promise<void> => area.remove(key),
+    removeAll: async (regex: string | RegExp): Promise<void> => {
+      const data = await area.get();
+      const _regex = typeof regex === 'string' ? new RegExp(regex) : regex;
+      await Promise.all(
+        Object.keys(data).map(key => {
+          if (_regex.test(key)) return area.remove(key);
+          return Promise.resolve();
+        }),
+      );
+    },
     clear: (): Promise<void> => area.clear(),
   };
 };

src/utils/cache.utils.ts

@@ -13,7 +13,7 @@ export type CacheStore<T = unknown> = {
   get(key: string): CacheStoreEntity<T> | Promise<CacheStoreEntity<T>> | undefined;
   set(key: string, value: CacheStoreEntity<T>): CacheStore<T> | Promise<CacheStore<T>>;
   delete(key: string): boolean | Promise<boolean>;
-  clear(): void;
+  clear(regex?: string): void;
   /** the duration in milliseconds after which the cache will be cleared */
   retention?: number;
   /** if true, the cache will be deleted if an error occurs */
@@ -90,7 +90,7 @@ export class ChromeCacheStore<T> implements CacheStore<T> {
     return true;
   }
 
-  async clear() {
-    return this.store.clear();
+  async clear(regex: string = '') {
+    return this.store.removeAll(`^${this.prefix}:${regex}`);
   }
 }