feat: umami migration

lib/services/cache/cache-service.ts

@@ -1,5 +1,9 @@
+export type CacheSetOptions = {
+  ttlSeconds?: number;
+};
+
 export interface CacheService {
-  get<T>(key: string): Promise<T | null>;
-  set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-  delete(key: string): Promise<void>;
+  get<T>(key: string): Promise<T | undefined>;
+  set<T>(key: string, value: T, options?: CacheSetOptions): Promise<void>;
+  del(key: string): Promise<void>;
 }

lib/services/cache/memory-cache-service.ts

@@ -1,26 +1,30 @@
-import type { CacheService } from "./cache-service";
+import type { CacheService, CacheSetOptions } from "./cache-service";
+
+type Entry = {
+  value: unknown;
+  expiresAt?: number;
+};
 
 export class MemoryCacheService implements CacheService {
-  private cache = new Map<string, { value: unknown; expiry: number | null }>();
+  private readonly store = new Map<string, Entry>();
 
-  async get<T>(key: string): Promise<T | null> {
-    const item = this.cache.get(key);
-    if (!item) return null;
-
-    if (item.expiry && item.expiry < Date.now()) {
-      this.cache.delete(key);
-      return null;
+  async get<T>(key: string) {
+    const entry = this.store.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return undefined;
     }
-
-    return item.value as T;
+    return entry.value as T;
   }
 
-  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {
-    const expiry = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null;
-    this.cache.set(key, { value, expiry });
+  async set<T>(key: string, value: T, options?: CacheSetOptions) {
+    const ttl = options?.ttlSeconds;
+    const expiresAt = ttl ? Date.now() + ttl * 1000 : undefined;
+    this.store.set(key, { value, expiresAt });
   }
 
-  async delete(key: string): Promise<void> {
-    this.cache.delete(key);
+  async del(key: string) {
+    this.store.delete(key);
   }
 }