Divided up the cache and changed keys a bit

Author: fatfingers23

server/api/social/like.delete.ts

@@ -32,4 +32,8 @@ export default eventHandlerWithOAuthSession(async (event, oAuthSession) => {
     var result = await likesUtil.unlikeAPackageAndReturnLikes(body.packageName, loggedInUsersDid)
     return result
   }
+
+  console.error(
+    `User ${loggedInUsersDid} tried to unlike a package ${body.packageName} but it was not liked by them.`,
+  )
 })

server/utils/atproto/utils/likes.ts

@@ -1,4 +1,3 @@
-import { getCacheAdatper } from '../../cache'
 import { $nsid as likeNsid } from '#shared/types/lexicons/dev/npmx/feed/like.defs'
 import type { Backlink } from '#shared/utils/constellation'
 
@@ -14,7 +13,7 @@ export type PackageLikes = {
 
 //Cache keys and helpers
 const CACHE_PREFIX = 'atproto-likes:'
-const CACHE_PACKAGE_TOTAL_KEY = (packageName: string) => `${CACHE_PREFIX}:${packageName}:total`
+const CACHE_PACKAGE_TOTAL_KEY = (packageName: string) => `${CACHE_PREFIX}${packageName}:total`
 const CACHE_USER_LIKES_KEY = (packageName: string, did: string) =>
   `${CACHE_PREFIX}${packageName}:users:${did}:liked`
 const CACHE_USERS_BACK_LINK = (packageName: string, did: string) =>
@@ -41,7 +40,7 @@ export class PackageLikesUtils {
         return { data, isStale: false, cachedAt: null }
       },
     )
-    this.cache = getCacheAdatper(CACHE_PREFIX)
+    this.cache = getCacheAdatper('generic')
   }
 
   /**

server/utils/cache.ts

@@ -0,0 +1,14 @@
+import { Redis } from '@upstash/redis'
+
+export function getCacheAdatper(prefix: string): CacheAdapter {
+  const config = useRuntimeConfig()
+
+  if (!import.meta.dev && config.upstash?.redisRestUrl && config.upstash?.redisRestToken) {
+    const redis = new Redis({
+      url: config.upstash.redisRestUrl,
+      token: config.upstash.redisRestToken,
+    })
+    return new RedisCacheAdatper(redis, prefix)
+  }
+  return new StorageCacheAdapter()
+}

server/utils/cache/adapter.ts

@@ -0,0 +1,45 @@
+/**
+ * Local cache data entry
+ */
+interface LocalCachedEntry<T = unknown> {
+  value: T
+  ttl?: number
+  cachedAt: number
+}
+
+/**
+ * Checks to see if a cache entry is stale locally
+ * @param entry - The entry from the locla cache
+ * @returns
+ */
+function isCacheEntryStale(entry: LocalCachedEntry): boolean {
+  if (!entry.ttl) return false
+  const now = Date.now()
+  const expiresAt = entry.cachedAt + entry.ttl * 1000
+  return now > expiresAt
+}
+
+/**
+ * Local implmentation of a cache to be used during development
+ */
+export class StorageCacheAdapter implements CacheAdapter {
+  private readonly storage = useStorage('generic-cache')
+
+  async get<T>(key: string): Promise<T | undefined> {
+    const result = await this.storage.getItem<LocalCachedEntry<T>>(key)
+    if (!result) return
+    if (isCacheEntryStale(result)) {
+      await this.storage.removeItem(key)
+      return
+    }
+    return result.value
+  }
+
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    await this.storage.setItem(key, { value, ttl, cachedAt: Date.now() })
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.storage.removeItem(key)
+  }
+}

server/utils/cache/local.ts

@@ -0,0 +1,39 @@
+import type { Redis } from '@upstash/redis'
+
+/**
+ * Redis cache storage with TTL handled by redis for use in production
+ */
+export class RedisCacheAdatper implements CacheAdapter {
+  private readonly redis: Redis
+  private readonly prefix: string
+
+  formatKey(key: string): string {
+    return `${this.prefix}:${key}`
+  }
+
+  constructor(redis: Redis, prefix: string) {
+    this.redis = redis
+    this.prefix = prefix
+  }
+
+  async get<T>(key: string): Promise<T | undefined> {
+    const formattedKey = this.formatKey(key)
+    const value = await this.redis.get<T>(formattedKey)
+    if (!value) return
+    return value
+  }
+
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    const formattedKey = this.formatKey(key)
+    if (ttl) {
+      await this.redis.setex(formattedKey, ttl, value)
+    } else {
+      await this.redis.set(formattedKey, value)
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    const formattedKey = this.formatKey(key)
+    await this.redis.del(formattedKey)
+  }
+}

server/utils/cache/redis.ts

@@ -0,0 +1,8 @@
+/**
+ * Generic cache adapter to allow using a local cache during development and redis in production
+ */
+export interface CacheAdapter {
+  get<T>(key: string): Promise<T | undefined>
+  set<T>(key: string, value: T, ttl?: number): Promise<void>
+  delete(key: string): Promise<void>
+}