Refactor: Move cache storage logic from base class to concrete implementations

diegomvh · diegomvh · commit 1b3a94231dc4 · 2026-05-13T13:25:52.000-03:00
Move entries map and put/get/forget/flush methods from ODataBaseCache to ODataInMemoryCache.
Rewrite ODataInStorageCache to use storage directly per-key instead of serializing the entire cache.
Rename 'name' to 'prefix' in ODataInStorageCache for clarity.
diff --git a/projects/angular-odata/src/lib/cache/cache.ts b/projects/angular-odata/src/lib/cache/cache.ts
@@ -18,15 +18,19 @@ export interface ODataCacheEntry<T> {
 
 export abstract class ODataBaseCache implements ODataCache {
   maxAge: number;
-  entries: Map<string, ODataCacheEntry<any>>;
 
   constructor({ maxAge = DEFAULT_MAXAGE }: { maxAge?: number }) {
     this.maxAge = maxAge;
-    this.entries = new Map<string, ODataCacheEntry<any>>();
   }
 
-  abstract getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
-  abstract putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+  /**
+   * Check if the entry is expired
+   * @param entry The cache entry
+   * @returns Boolean indicating if the entry is expired
+   */
+  isExpired(entry: ODataCacheEntry<any>) {
+    return entry.date < (Date.now() - entry.maxAge);
+  }
 
   /**
    * Using the resource on the request build an array of string to identify the scope of the request
@@ -87,71 +91,11 @@ export abstract class ODataBaseCache implements ODataCache {
     return names.join(CACHE_KEY_SEPARATOR);
   }
 
-  /**
-   * Put some payload in the cache
-   * @param name The name for the entry
-   * @param payload The payload to store in the cache
-   * @param maxAge The maximum age for the entry
-   * @param scope The scope for the entry
-   * @param tags The tags for the entry
-   */
-  put<T>(
-    name: string,
-    payload: T,
-    { maxAge, scope, tags }: { maxAge?: number; scope?: string[]; tags?: string[] } = {},
-  ) {
-    const entry = this.buildEntry<T>(payload, { maxAge, tags });
-    const key = this.buildKey([...(scope ?? []), name]);
-    this.entries.set(key, entry);
-  }
-
-  /**
-   * Return the payload from the cache if it exists and is not expired
-   * @param name The name of the entry
-   * @param scope The scope of the entry
-   * @returns The payload of the entry
-   */
-  get<T>(name: string, { scope }: { scope?: string[] } = {}): T | undefined {
-    const key = this.buildKey([...(scope || []), name]);
-    const entry = this.entries.get(key);
-    return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
-  }
-
-  /**
-   * Remove all cache entries that are matching with the given options
-   * @param options The options to forget
-   */
-  forget({
-    name,
-    scope = [],
-    tags = [],
-  }: { name?: string; scope?: string[]; tags?: string[] } = {}) {
-    if (name !== undefined) scope.push(name);
-    const key = scope.length > 0 ? this.buildKey(scope) : undefined;
-    this.entries.forEach((entry, k) => {
-      if (
-        this.isExpired(entry) || // Expired
-        (key !== undefined && k.startsWith(key)) || // Key
-        (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1)) // Tags
-      ) {
-        this.entries.delete(k);
-      }
-    });
-  }
-
-  /**
-   * Remove all cache entries
-   */
-  flush() {
-    this.entries = new Map<string, ODataCacheEntry<any>>();
-  }
+  abstract put<T>(name: string, payload: T, { maxAge, scope, tags }: { maxAge?: number; scope?: string[]; tags?: string[] }): void;
+  abstract get<T>(name: string, { scope }: { scope?: string[] }): T | undefined;
+  abstract getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
+  abstract putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+  abstract forget({ name, scope, tags}: { name?: string; scope?: string[]; tags?: string[] }): void;
+  abstract flush(): void;
 
-  /**
-   * Check if the entry is expired
-   * @param entry The cache entry
-   * @returns Boolean indicating if the entry is expired
-   */
-  isExpired(entry: ODataCacheEntry<any>) {
-    return entry.date < Date.now() - entry.maxAge;
-  }
 }
diff --git a/projects/angular-odata/src/lib/cache/memory.ts b/projects/angular-odata/src/lib/cache/memory.ts
@@ -1,9 +1,41 @@
 import { ODataRequest, ODataResponse } from '../resources';
-import { ODataBaseCache } from './cache';
+import { ODataBaseCache, ODataCacheEntry } from './cache';
 
 export class ODataInMemoryCache extends ODataBaseCache {
+  entries: Map<string, ODataCacheEntry<any>>;
   constructor({ maxAge }: { maxAge?: number } = {}) {
     super({ maxAge });
+    this.entries = new Map<string, ODataCacheEntry<any>>();
+  }
+
+  /**
+   * Put some payload in the cache
+   * @param name The name for the entry
+   * @param payload The payload to store in the cache
+   * @param maxAge The maximum age for the entry
+   * @param scope The scope for the entry
+   * @param tags The tags for the entry
+   */
+  override put<T>(
+    name: string,
+    payload: T,
+    { maxAge, scope, tags }: { maxAge?: number; scope?: string[]; tags?: string[] } = {},
+  ) {
+    const entry = this.buildEntry<T>(payload, { maxAge, tags });
+    const key = this.buildKey([...(scope ?? []), name]);
+    this.entries.set(key, entry);
+  }
+
+  /**
+   * Return the payload from the cache if it exists and is not expired
+   * @param name The name of the entry
+   * @param scope The scope of the entry
+   * @returns The payload of the entry
+   */
+  override get<T>(name: string, { scope }: { scope?: string[] } = {}): T | undefined {
+    const key = this.buildKey([...(scope || []), name]);
+    const entry = this.entries.get(key);
+    return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
   }
 
   /**
@@ -30,4 +62,33 @@ export class ODataInMemoryCache extends ODataBaseCache {
     let scope = this.scope(req);
     return this.get(req.cacheKey, { scope });
   }
+
+  /**
+   * Remove all cache entries that are matching with the given options
+   * @param options The options to forget
+   */
+  override forget({
+    name,
+    scope = [],
+    tags = [],
+  }: { name?: string, scope?: string[]; tags?: string[] } = {}) {
+    if (name) scope.push(name);
+    const key = scope.length > 0 ? this.buildKey(scope) : undefined;
+    this.entries.forEach((entry, k) => {
+      if (
+        this.isExpired(entry) || // Expired
+        (key !== undefined && k.startsWith(key)) || // Key
+        (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1)) // Tags
+      ) {
+        this.entries.delete(k);
+      }
+    });
+  }
+
+  /**
+   * Remove all cache entries
+   */
+  override flush() {
+    this.entries = new Map<string, ODataCacheEntry<any>>();
+  }
 }
diff --git a/projects/angular-odata/src/lib/cache/storage.ts b/projects/angular-odata/src/lib/cache/storage.ts
@@ -2,59 +2,69 @@ import { ODataRequest, ODataResponse, ODataResponseJson } from '../resources';
 import { ODataBaseCache, ODataCacheEntry } from './cache';
 
 export class ODataInStorageCache extends ODataBaseCache {
-  name: string;
+  prefix: string;
   storage: Storage;
 
   constructor({
-    name,
+    prefix,
     storage = sessionStorage,
     maxAge,
   }: {
     maxAge?: number;
-    name: string;
+    prefix: string;
     storage?: Storage;
   }) {
     super({ maxAge });
-    this.name = name;
+    this.prefix = prefix;
     this.storage = storage;
-    this.restore();
-    window.addEventListener('beforeunload', () => this.store());
   }
 
-  /**
-   * Store the cache in the storage
-   */
-  store() {
-    this.storage.setItem(
-      this.name,
-      JSON.stringify(
-        Array.from(this.entries.entries()).map(([key, entry]) => [
-          key,
-          {
-            ...entry,
-            payload:
-              entry.payload instanceof ODataResponse ? entry.payload.toJson() : entry.payload,
-          } as ODataCacheEntry<any>,
-        ]),
-      ),
-    );
+  override buildKey(names: string[]): string {
+    return super.buildKey([this.prefix, ...names]);
   }
 
-  /**
-   * Restore the cache from the storage
-   */
-  restore() {
-    this.entries = new Map<string, ODataCacheEntry<any>>(
-      JSON.parse(this.storage.getItem(this.name) || '[]'),
-    );
+  override put<T>(
+    name: string,
+    payload: T,
+    { maxAge, scope, tags }: { maxAge?: number; scope?: string[]; tags?: string[] } = {},
+  ) {
+    const entry = this.buildEntry<T>(payload, { maxAge, tags });
+    const key = this.buildKey([...(scope ?? []), name]);
+    this.storage.setItem(key, JSON.stringify(entry));
+  }
+
+  override get<T>(name: string, { scope }: { scope?: string[] } = {}): T | undefined {
+    const key = this.buildKey([...(scope || []), name]);
+    const entry = JSON.parse(this.storage.getItem(key) ?? "{}");
+    return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
+  }
+
+  override forget({
+    name,
+    scope = [],
+    tags = [],
+  }: { name?: string, scope?: string[]; tags?: string[] }) {
+    if (name) scope.push(name);
+    const key = scope.length > 0 ? this.buildKey(scope) : undefined;
+    Object.keys(this.storage).filter(k => k.startsWith(this.prefix)).forEach(k => {
+      const entry = JSON.parse(this.storage.getItem(k) ?? "{}");
+      if (
+        this.isExpired(entry) || // Expired
+        (key !== undefined && k.startsWith(key)) || // Key
+        (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1)) // Tags
+      ) {
+        this.storage.removeItem(k);
+      }
+    });
   }
 
   /**
    * Flush the cache and clean the storage
    */
   override flush() {
-    super.flush();
-    this.store();
+    Object.keys(this.storage).filter(k => k.startsWith(this.prefix)).forEach(k => {
+      this.storage.removeItem(k);
+    });
   }
 
   /**
@@ -65,7 +75,7 @@ export class ODataInStorageCache extends ODataBaseCache {
   override putResponse(req: ODataRequest<any>, res: ODataResponse<any>) {
     const scope = this.scope(req);
     const tags = this.tags(res);
-    this.put<ODataResponse<any>>(req.cacheKey, res, {
+    this.put<ODataResponseJson<any>>(req.cacheKey, res.toJson(), {
       maxAge: req.maxAge ?? res.options.maxAge,
       scope,
       tags,
@@ -81,10 +91,6 @@ export class ODataInStorageCache extends ODataBaseCache {
     const scope = this.scope(req);
     const data = this.get<ODataResponseJson<any>>(req.cacheKey, { scope });
 
-    return data instanceof ODataResponse
-      ? data
-      : data !== undefined
-        ? ODataResponse.fromJson(req, data)
-        : undefined;
+    return data !== undefined ? ODataResponse.fromJson(req, data) : undefined;
   }
 }
