Allow to provide a custom http cache store in provider config in place of cache service override

Author: nebarf

src/cache/http-cache-store.ts

@@ -0,0 +1,33 @@
+import { HttpCacheEntry } from './types';
+
+export abstract class HttpCacheStore<Identifier = string> {
+  /**
+   * Gets the cached entry for the given identifier.
+   */
+  abstract get<T>(identifier: Identifier): HttpCacheEntry<T> | undefined;
+
+  /**
+   * Stores the entry.
+   */
+  abstract put<T>(entry: HttpCacheEntry<T>): () => void;
+
+  /**
+   * Determines if the entry is in the store.
+   */
+  abstract has(idenitifier: Identifier): boolean;
+
+  /**
+   * Deletes the cached entry for the given identifier.
+   */
+  abstract delete(idenitifier: Identifier): void;
+
+  /**
+   * Gets all stored entries.
+   */
+  abstract entries(): HttpCacheEntry<unknown>[];
+
+  /**
+   * Flushes the store by deleting all entries.
+   */
+  abstract flush(): void;
+}

src/cache/http-cache.ts

@@ -1,13 +1,121 @@
+import { HttpCacheStore } from './http-cache-store';
 import { HttpRequest } from '../client';
+import { HttpCacheEntry } from './types';
+
+export class HttpCacheService {
+  constructor(private store: HttpCacheStore) {}
+
+  /**
+   * Gets the unique key used as idenitifier to store
+   * a cached response for the given http request.
+   */
+  private getRequestIdentifier(request: HttpRequest): string {
+    const fullUrl = request.urlWithParams;
+    return fullUrl;
+  }
+
+  /**
+   * Tells if a cached entry is expired.
+   */
+  private isEntryExpired<T>(entry: HttpCacheEntry<T>): boolean {
+    const nowTime = new Date().getTime();
+    const cachedAtDate = entry.cachedAt instanceof Date ? entry.cachedAt : new Date(entry.cachedAt);
+    const cachedTime = cachedAtDate.getTime();
+    return cachedTime + entry.maxAge < nowTime;
+  }
+
+  /**
+   * Gets the cached entry associated with the request.
+   */
+  private getEntry<T>(request: HttpRequest): HttpCacheEntry<T> | undefined {
+    const reqIdentifier = this.getRequestIdentifier(request);
+    return this.store.get(reqIdentifier) as HttpCacheEntry<T>;
+  }
+
+  /**
+   * Removes a cached entry.
+   */
+  private removeEntry<T>(entry: HttpCacheEntry<T>): void {
+    this.store.delete(entry.identifier);
+  }
+
+  /**
+   * Determines if for the given request is available a cached response.
+   */
+  has(request: HttpRequest): boolean {
+    const key = this.getRequestIdentifier(request);
+    return this.store.has(key);
+  }
 
-export abstract class HttpCache {
   /**
-   * Gets the cached parsed response for the given request.
+   * Tells if the cached request is expired or not.
    */
-  abstract get<T>(request: HttpRequest): T | undefined;
+  isExpired(request: HttpRequest): boolean {
+    const cachedEntry = this.getEntry(request);
+    if (!cachedEntry) {
+      return true;
+    }
+
+    return this.isEntryExpired(cachedEntry);
+  }
+
+  /**
+   * Gets the cached entry in the map for the given request.
+   */
+  get<T>(request: HttpRequest): T | undefined {
+    const cachedEntry = this.getEntry(request);
+    if (!cachedEntry) {
+      return undefined;
+    }
+
+    const isExpired = this.isEntryExpired(cachedEntry);
+    return isExpired ? undefined : (cachedEntry.response as T);
+  }
+
+  /**
+   * Puts a new cached response for the given request.
+   */
+  put<T>(request: HttpRequest, response: T): void {
+    if (!request.maxAge) {
+      return;
+    }
+
+    const reqKey = this.getRequestIdentifier(request);
+    const entry: HttpCacheEntry<T> = {
+      response,
+      identifier: reqKey,
+      cachedAt: new Date(),
+      maxAge: request.maxAge,
+    };
+
+    // Update the store.
+    this.store.put(entry);
+
+    // Remove the entry from the cache once expired.
+    const timerRef = setTimeout(() => {
+      this.removeEntry(entry);
+      clearTimeout(timerRef);
+    }, request.maxAge);
+  }
+
+  /**
+   * Founds all expired entry and deletes them from the cache.
+   */
+  prune(): void {
+    const entries = this.store.entries();
+    entries.forEach((entry) => {
+      const isEntryExpired = this.isEntryExpired(entry);
+
+      if (isEntryExpired) {
+        this.removeEntry(entry);
+      }
+    });
+  }
 
   /**
-   * Caches the parsed response for the given request.
+   * Flush the cache by removing all entries.
    */
-  abstract put<T>(request: HttpRequest, response: T): void;
+  flush(): void {
+    this.store.flush();
+  }
 }

src/cache/http-in-memory-cache-store.ts

@@ -0,0 +1,55 @@
+import { HttpCacheEntry } from './types';
+import { HttpCacheStore } from './http-cache-store';
+
+export class HttpInMemoryCacheStore extends HttpCacheStore {
+  /**
+   * The local cache providing for a request identifier
+   * the corresponding cached entry.
+   */
+  private readonly store = new Map<string, HttpCacheEntry<unknown>>();
+
+  /**
+   * @inheritdoc
+   */
+  get<T>(identifier: string): HttpCacheEntry<T> | undefined {
+    return this.store.get(identifier) as HttpCacheEntry<T>;
+  }
+
+  /**
+   * @inheritdoc
+   */
+  put<T>(entry: HttpCacheEntry<T>): () => void {
+    this.store.set(entry.identifier, entry);
+    return () => this.delete(entry.identifier);
+  }
+
+  /**
+   * @inheritdoc
+   */
+  has(identifier: string): boolean {
+    return this.store.has(identifier);
+  }
+
+  /**
+   * @inheritdoc
+   */
+  delete(identifier: string): void {
+    this.store.delete(identifier);
+  }
+
+  /**
+   * Gets all stored entries.
+   */
+  entries(): HttpCacheEntry<unknown>[] {
+    return Array.from(this.store.values());
+  }
+
+  /**
+   * @inheritdoc
+   */
+  flush(): void {
+    this.store.forEach((entry) => {
+      this.delete(entry.identifier);
+    });
+  }
+}

src/cache/http-in-memory-cache.ts

@@ -1,3 +1,4 @@
 export * from './http-cache';
-export * from './http-in-memory-cache';
+export * from './http-cache-store';
+export * from './http-in-memory-cache-store';
 export * from './types';

src/cache/index.ts

@@ -1,7 +1,7 @@
 import { HttpClientContextProps, HttpClientConfig } from './types';
 import { httpResponseParser } from './response-parser';
 import { serializeRequestBody } from './request-body-serializer';
-import { HttpInMemoryCacheService } from '../cache';
+import { HttpCacheService, HttpInMemoryCacheStore } from '../cache';
 
 export const defaultHttpReqConfig: HttpClientConfig = {
   baseUrl: '',
@@ -12,7 +12,7 @@ export const defaultHttpReqConfig: HttpClientConfig = {
       'Content-Type': 'application/json',
     },
   },
-  cache: new HttpInMemoryCacheService(),
+  cache: new HttpCacheService(new HttpInMemoryCacheStore()),
 };
 
 export const defaultClientProps: HttpClientContextProps = {

src/config/defaults.ts

@@ -1,4 +1,4 @@
-import { HttpCache } from '../cache';
+import { HttpCacheService } from '../cache';
 import { ReactElement } from 'react';
 import { HttpRequestOptions, HttpResponseParser } from '../client';
 
@@ -16,7 +16,7 @@ export interface HttpClientConfig {
   baseUrl: string;
   responseParser: HttpResponseParser;
   requestBodySerializer: HttpRequestBodySerializer;
-  cache: HttpCache;
+  cache: HttpCacheService;
 }
 
 export type HttpInterceptor = (request: Promise<Response>) => Promise<void>;