🐛 set cache state to cached after fetching

Author: fgladisch

src/cache/storage-cache.ts

@@ -18,6 +18,7 @@ export class StorageCache implements ContactCache {
     this.storage = storageAdapter;
 
     const { CACHE_REFRESH_INTERVAL } = process.env;
+
     if (CACHE_REFRESH_INTERVAL) {
       this.cacheRefreshIntervalMs =
         Math.max(Number(CACHE_REFRESH_INTERVAL), 1) * 1000;
@@ -34,49 +35,35 @@ export class StorageCache implements ContactCache {
     key: string,
     getFreshValue?: (key: string) => Promise<Contact[]>
   ): Promise<Contact[] | CacheItemState> {
+    const anonKey = anonymizeKey(key);
+
     try {
-      this.log(`[${anonymizeKey(key)}] Trying to get Contacts from cache…`);
-      const start = performance.now();
+      this.log(`[${anonKey}] Trying to get contacts from cache`);
+
       const cacheItemState = await this.storage.get<CacheItemState>(
         this.getCacheItemKey(key)
       );
 
-      const value = await this.storage.get<Contact[]>(key);
-      console.log(
-        `[${anonymizeKey(key)}] loading contacts took ${
-          performance.now() - start
-        }ms`
-      );
+      const contacts = await this.storage.get<Contact[]>(key);
 
-      if (
-        cacheItemState &&
-        cacheItemState.state === CacheItemStateType.FETCHING
-      ) {
+      if (cacheItemState?.state === CacheItemStateType.FETCHING) {
         this.log(
-          `[${anonymizeKey(
-            key
-          )}] Not refreshing for because fetching is already in progress.`
+          `[${anonKey}] Not refreshing contacts, because cache state is FETCHING`
         );
 
         // if we have old contacts saved in cache we return them instead
-        if (value && value.length > 0) {
+        if (contacts && contacts?.length > 0) {
           this.log(
-            `[${anonymizeKey(key)}] Returning previously cached contacts (${
-              value.length
-            }), because new contacts are still being fetched.`
+            `[${anonKey}] Returning previously cached contacts (${contacts.length}), because new contacts are still being fetched`
           );
-          return value;
+          return contacts;
         }
 
         return cacheItemState;
       }
 
-      if (value) {
-        this.log(
-          `[${anonymizeKey(key)}] Found contacts ${
-            value.length
-          } for key in cache.`
-        );
+      if (contacts) {
+        this.log(`[${anonKey}] Found ${contacts.length} contacts in cache`);
 
         const now: number = new Date().getTime();
 
@@ -88,65 +75,59 @@ export class StorageCache implements ContactCache {
 
         if (getFreshValue && isValueStale) {
           this.log(
-            `[${anonymizeKey(key)}] value was stale, fetching fresh contacts`
+            `[${anonKey}] cached value was stale, fetching fresh contacts`
           );
           // we don't return the fresh value here because we don't want to wait on the result.
           // We return the old value instead, the fresh value is returned the next time it is requested
           this.getRefreshed(key, getFreshValue).catch((error) => {
-            this.logErr(
-              `[${anonymizeKey(
-                key
-              )}] Unable to get fresh values, error was ${error}`
-            );
+            this.logErr(`[${anonKey}] Unable to get fresh contacts`, error);
           });
         }
 
-        return value;
+        return contacts;
       }
     } catch (e) {
-      this.logErr(`[${anonymizeKey(key)}] Unable to get cache".`, e);
+      this.logErr(`[${anonKey}] Unable to get cache".`, e);
     }
 
     if (!getFreshValue) {
       this.log(
-        `[${anonymizeKey(
-          key
-        )}] No getFreshValue function provided. Returning empty array.`
+        `[${anonKey}] No getFreshValue function provided - returning empty array`
       );
       return [];
     }
 
-    this.log(
-      `[${anonymizeKey(key)}] Found no match in cache. Getting fresh value.`
-    );
+    this.log(`[${anonKey}] Found no match in cache. Getting fresh value.`);
     return this.getRefreshed(key, getFreshValue);
   }
 
-  public async set(key: string, value: Contact[]): Promise<void> {
-    this.log(
-      `[${anonymizeKey(key)}] Saving ${value.length} contacts to cache.`
-    );
+  public async set(key: string, contacts: Contact[]): Promise<void> {
+    const anonKey = anonymizeKey(key);
+    this.log(`[${anonKey}] Saving ${contacts.length} contacts to cache`);
     try {
-      await this.storage.set(key, value);
+      await this.storage.set(key, contacts);
     } catch (e) {
-      this.logErr(`[${anonymizeKey(key)}] Unable to set cache.`, e);
+      this.logErr(`[${anonKey}] Unable to set cache`, e);
     }
   }
 
   public async delete(key: string): Promise<void> {
-    this.log(`[${anonymizeKey(key)}] Removing contacts from cache.`);
+    const anonKey = anonymizeKey(key);
+    this.log(`[${anonKey}] Removing contacts from cache`);
     try {
       await this.storage.delete(key);
     } catch (e) {
-      this.logErr(`[${anonymizeKey(key)}] Unable to delete cache`, e);
+      this.logErr(`[${anonKey}] Unable to delete cache`, e);
     }
   }
 
   private async getRefreshed(
     key: string,
     getFreshValue: (key: string) => Promise<Contact[]>
   ): Promise<Contact[]> {
-    this.log(`[${anonymizeKey(key)}] Refreshing value…`);
+    const anonKey = anonymizeKey(key);
+
+    this.log(`[${anonKey}] Setting cache state to FETCHING`);
 
     await this.storage.set<CacheItemState>(
       this.getCacheItemKey(key),
@@ -159,13 +140,19 @@ export class StorageCache implements ContactCache {
     try {
       const freshValue = await getFreshValue(key);
 
-      if (freshValue) {
-        await this.set(key, freshValue);
-      }
+      await this.set(key, freshValue);
+
+      this.log(`[${anonKey}] Setting cache state to CACHED`);
+
+      await this.storage.set<CacheItemState>(this.getCacheItemKey(key), {
+        state: CacheItemStateType.CACHED,
+        updated: Date.now(),
+      });
 
       return freshValue;
     } catch (error) {
-      this.log(`[${anonymizeKey(key)}] Error while refreshing value`, error);
+      this.log(`[${anonKey}] Error while refreshing value`, error);
+      await this.storage.delete(this.getCacheItemKey(key));
       throw error;
     }
   }

src/cache/storage/memory-storage-adapter.ts

@@ -17,12 +17,12 @@ export class MemoryStorageAdapter implements StorageAdapter {
       sizeCalculation: sizeof,
     });
 
-    console.log(`[CACHE] Initialized Memory storage`);
+    console.log(`Initialized memory cache`);
   }
 
   public async get<T>(key: string): Promise<T | null> {
-    const cached = this.cache.get(key) as T;
-    return cached ? cached : null;
+    const cached = await this.cache.get<T>(key);
+    return cached ?? null;
   }
 
   public async set<T>(key: string, value: T): Promise<void> {

src/cache/storage/redis-storage-adapter.ts

@@ -21,39 +21,35 @@ export class RedisStorageAdapter implements StorageAdapter {
     console.log(`Initialized Redis storage with URL ${url}`);
 
     this.client.on("error", (error) => {
-      console.warn("Redis error: ", error.message);
+      console.error("Redis error: ", error.message);
     });
 
     this.client.on("ready", () => {
-      console.info("Redis is ready.");
+      console.info("Redis is ready");
     });
 
     this.client.on("reconnecting", () => {
-      console.warn("Redis is reconnecting.");
+      console.warn("Redis is reconnecting");
     });
 
     this.client
       .connect()
       .then(() => {
-        console.info("Redis successfully connected.");
+        console.info("Redis successfully connected");
       })
       .catch((error) => {
         console.warn("Redis connection error: ", error.message);
       });
   }
 
   public async get<T>(key: string): Promise<T | null> {
-    try {
-      const value = await this.client.get(key);
-      if (!value) {
-        return null;
-      }
-      const decompressed = await inflate(Buffer.from(value, "base64"));
-      const result = JSON.parse(decompressed.toString());
-      return result;
-    } catch {
+    const value = await this.client.get(key);
+    if (!value) {
       return null;
     }
+    const decompressed = await inflate(Buffer.from(value, "base64"));
+    const result = JSON.parse(decompressed.toString());
+    return result;
   }
 
   public async set<T>(key: string, value: T, ttl?: number): Promise<void> {

src/index.ts

@@ -4,7 +4,7 @@ import cors from "cors";
 import express from "express";
 import { Server } from "http";
 import { errorHandlerMiddleware, extractHeaderMiddleware } from "./middlewares";
-import { Adapter, Controller } from "./models";
+import { Adapter, ContactCache, Controller } from "./models";
 import { CustomRouter } from "./models/custom-router.model";
 import { getContactCache } from "./util/get-contact-cache";
 
@@ -22,12 +22,14 @@ app.use(
 app.use(bodyParser.json());
 app.use(extractHeaderMiddleware);
 
-const cache = getContactCache();
+let cache: ContactCache | null = null;
 
 export function start(
   adapter: Adapter,
   customRouters: CustomRouter[] = []
 ): Server {
+  cache = getContactCache();
+
   const controller: Controller = new Controller(adapter, cache);
 
   app.get("/contacts", (req, res, next) =>

src/util/get-contact-cache.ts

@@ -11,7 +11,7 @@ export function getContactCache(): ContactCache | null {
   }
 
   if (REDIS_URL) {
-    console.log("[CACHE] Using redis cache");
+    console.log("[CACHE] Using Redis cache");
     return new StorageCache(new RedisStorageAdapter(REDIS_URL));
   }