fix(cache): update cache eviction strategy

Author: dvcol

src/services/common/base-client.ts

@@ -88,13 +88,16 @@ export type BaseTemplate<P extends RecursiveRecord = RecursiveRecord, O extends
   transform?: (param: P) => P;
 };
 
+export type CacheResponse<T> = {
+  previous?: CacheStoreEntity<TypedResponse<T>>;
+  current?: CacheStoreEntity<TypedResponse<T>>;
+  isCache?: boolean;
+  evict?: () => string | boolean | undefined | Promise<string | boolean | undefined>;
+};
+
 export type TypedResponse<T> = Omit<Response, 'json'> & {
   json(): Promise<T>;
-  cache?: {
-    previous?: CacheStoreEntity<TypedResponse<T>>;
-    current?: CacheStoreEntity<TypedResponse<T>>;
-    isCache?: boolean;
-  };
+  cache?: CacheResponse<T>;
 };
 
 export type ResponseOrTypedResponse<T = unknown> = T extends never ? Response : TypedResponse<T>;
@@ -203,28 +206,30 @@ export const getCachedFunction = <
 ): ClientEndpointCache<Parameter, ResponseBody> => {
   const cachedFn = async (param: Parameter, init: BaseInit, cacheOptions: BaseCacheOption) => {
     const _key = typeof key === 'function' ? key(param, init) : key;
+    const evict = () => cache.delete(_key);
     const cached = await cache.get(_key);
     if (cached && !cacheOptions?.force) {
       let templateRetention = typeof retention === 'number' ? retention : undefined;
       if (typeof retention === 'object') templateRetention = retention.retention;
       const _retention = cacheOptions?.retention ?? templateRetention ?? cache.retention;
-      if (!_retention) return cloneResponse<ResponseType>(cached.value, { previous: cached, current: cached, isCache: true });
+      if (!_retention) return cloneResponse<ResponseType>(cached.value, { previous: cached, current: cached, isCache: true, evict });
       const expires = cached.cachedAt + _retention;
-      if (expires > Date.now()) return cloneResponse(cached.value, { previous: cached, current: cached, isCache: true });
+      if (expires > Date.now()) return cloneResponse(cached.value, { previous: cached, current: cached, isCache: true, evict });
     }
 
     try {
       const result: TypedResponse<ResponseBody> = await clientFn(param, init);
       const cacheEntry: CacheStoreEntity<ResponseType> = {
         cachedAt: Date.now(),
         value: cloneResponse(result) as ResponseType,
+        key: _key,
       };
       await cache.set(_key, cacheEntry);
-      result.cache = { previous: cached, current: cacheEntry, isCache: false };
+      result.cache = { previous: cached, current: cacheEntry, isCache: false, evict };
       return result;
     } catch (error) {
       if (cacheOptions?.evictOnError ?? (typeof retention === 'object' ? retention?.evictOnError : undefined) ?? cache.evictOnError) {
-        cache.delete(_key);
+        evict();
       }
       throw error;
     }

src/services/trakt.service.ts

@@ -19,7 +19,7 @@ import type { TraktWatchlistGetQuery } from '~/models/trakt/trakt-watchlist.mode
 import type { SettingsAuth, UserSetting } from '~/models/trakt-service.model';
 import type { TvdbApiResponse } from '~/models/tvdb/tvdb-client.model';
 
-import { type BaseCacheOption, getCachedFunction, type TypedResponse } from '~/services/common/base-client';
+import { type BaseCacheOption, type CacheResponse, getCachedFunction, type TypedResponse } from '~/services/common/base-client';
 import { LoadingBarService } from '~/services/loading-bar.service';
 import { tmdbApi } from '~/services/tmdb-client/api/tmdb-api.endpoints';
 import { TmdbClient } from '~/services/tmdb-client/clients/tmdb-client';
@@ -36,6 +36,20 @@ import { useUserSettingsStore } from '~/stores/settings/user.store';
 import { createTab } from '~/utils/browser/browser.utils';
 import { CacheRetention, ChromeCacheStore } from '~/utils/cache.utils';
 
+export const shouldEvict = (date?: string | number | Date, cache?: CacheResponse<unknown>): boolean => {
+  // no date or cache skip
+  if (!date || !cache?.evict) return false;
+  // date in the past skip
+  if (new Date(date) <= new Date()) return false;
+  // cached today skip
+  if (cache?.current?.cachedAt) {
+    const _cachedAt = new Date(cache.current.cachedAt).toLocaleDateString();
+    const _today = new Date().toLocaleDateString();
+    if (_cachedAt === _today) return false;
+  }
+  return true;
+};
+
 export class TraktService {
   private static traktClient: TraktClient;
   private static tmdbClient: TmdbClient;
@@ -352,40 +366,50 @@ export class TraktService {
   static show = {
     async summary(id: string | number) {
       const response = await TraktService.traktClient.shows.summary.cached({ id, extended: 'full' });
-      return response.json() as Promise<TraktShowExtended>;
+      const data = await response.json();
+      if (shouldEvict(data?.first_aired, response?.cache)) response.cache?.evict?.();
+      return data as TraktShowExtended;
     },
 
     async season(id: string | number, season: number) {
       const response = await TraktService.traktClient.seasons.season.cached({ id, season });
-      return response.json() as Promise<TraktEpisodeShort[]>;
+      const data = await response.json();
+      if (data.some(e => shouldEvict(e?.first_aired, response?.cache))) response.cache?.evict?.();
+      return data as TraktEpisodeShort[];
     },
 
     async seasons(id: string | number) {
       const response = await TraktService.traktClient.seasons.summary.cached({ id, extended: 'full' });
-      return response.json() as Promise<TraktSeasonExtended[]>;
+      const data = await response.json();
+      if (data.some(s => shouldEvict(s?.first_aired, response?.cache))) response.cache?.evict?.();
+      return data as TraktSeasonExtended[];
     },
 
     async episode({ id, season, episode }: { id: string | number; season: number; episode: number }) {
       const response = await TraktService.traktClient.episodes.summary.cached({ id, season, episode, extended: 'full' });
-      return response.json() as Promise<TraktEpisodeExtended>;
+      const data = await response.json();
+      if (shouldEvict(data?.first_aired, response?.cache)) response.cache?.evict?.();
+      return data as TraktEpisodeExtended;
     },
   };
 
-  static async activity() {
-    const response = await this.traktClient.sync.lastActivities();
-    return response.json();
-  }
-
   static async movie(id: string | number) {
     const response = await this.traktClient.movies.summary.cached({ id, extended: 'full' });
-    return response.json() as Promise<TraktMovieExtended>;
+    const data = await response.json();
+    if (shouldEvict(data?.released, response?.cache)) response.cache?.evict?.();
+    return data as TraktMovieExtended;
   }
 
   static async person(id: string | number) {
     const response = await this.traktClient.people.summary.cached({ id, extended: 'full' });
     return response.json() as Promise<TraktPersonExtended>;
   }
 
+  static async activity() {
+    const response = await this.traktClient.sync.lastActivities();
+    return response.json();
+  }
+
   static evict = {
     tmdb: () => TraktService.tmdbClient.clearCache(),
     trakt: () => TraktService.traktClient.clearCache(),

src/utils/cache.utils.ts

@@ -3,6 +3,7 @@ import type { ResponseOrTypedResponse, TypedResponse } from '~/services/common/b
 import { storage, type StorageArea } from '~/utils/browser/browser-storage.utils';
 
 export type CacheStoreEntity<V = unknown, T = string> = {
+  key: string;
   value: V;
   type?: T;
   cachedAt: number;