@terrafirmagreg-team/data 1.2.7 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrafirmagreg-team/data",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "type": "module",
   "description": "Storage drivers and shared helpers",
   "license": "LGPL-3.0-only",

package/src/lib/persistent-cache.ts

@@ -8,6 +8,11 @@ type Entry = { value: unknown; expires: number };
 
 let tableReady: Promise<unknown> | undefined;
 
+const ready = () =>
+  (tableReady ??= dbSql`
+    CREATE TABLE IF NOT EXISTS tfg_cache (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires INTEGER NOT NULL)
+  `);
+
 function fileFor(key: string): string {
   const name = key.replace(/[^a-z0-9._-]+/gi, '_').slice(0, 60);
   const hash = createHash('sha1').update(key).digest('hex').slice(0, 8);
@@ -16,10 +21,7 @@ function fileFor(key: string): string {
 
 async function d1Read(key: string): Promise<Entry | undefined> {
   try {
-    tableReady ??= dbSql`
-      CREATE TABLE IF NOT EXISTS tfg_cache (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires INTEGER NOT NULL)
-    `;
-    await tableReady;
+    await ready();
     const rows = (await dbSql`
       SELECT value, expires FROM tfg_cache WHERE key = ${key}
     `) as { rows?: { value: string; expires: number }[] } | undefined;
@@ -34,7 +36,7 @@ async function d1Read(key: string): Promise<Entry | undefined> {
 
 async function d1Write(key: string, entry: Entry): Promise<void> {
   try {
-    await tableReady;
+    await ready();
     await dbSql`
       INSERT OR REPLACE INTO tfg_cache (key, value, expires)
       VALUES (${key}, ${JSON.stringify(entry.value)}, ${entry.expires})
@@ -42,21 +44,81 @@ async function d1Write(key: string, entry: Entry): Promise<void> {
   } catch {}
 }
 
+type Db = NonNullable<Awaited<ReturnType<typeof dataDb>>>;
+
+async function readEntry(
+  db: Db | undefined,
+  key: string,
+): Promise<Entry | undefined> {
+  return db
+    ? await d1Read(key)
+    : loadJsonFile<Entry | undefined>(fileFor(key), () => undefined);
+}
+
+async function writeEntry(
+  db: Db | undefined,
+  key: string,
+  entry: Entry,
+): Promise<void> {
+  if (db) await d1Write(key, entry);
+  else {
+    try {
+      saveJsonFile(fileFor(key), entry);
+    } catch {}
+  }
+}
+
+export async function persistentGet<T>(
+  key: string,
+): Promise<{ value: T; expires: number } | undefined> {
+  const db = await dataDb().catch(() => undefined);
+  return (await readEntry(db, key)) as
+    | { value: T; expires: number }
+    | undefined;
+}
+
+export async function persistentSet(
+  key: string,
+  value: unknown,
+  ttlMs: number,
+): Promise<void> {
+  const db = await dataDb().catch(() => undefined);
+  await writeEntry(db, key, { value, expires: Date.now() + ttlMs });
+}
+
+const inflight = new Map<string, Promise<unknown>>();
+
+async function loadAndStore<T>(
+  key: string,
+  ttlMs: number,
+  loader: () => Promise<T | undefined>,
+  db: Db | undefined,
+): Promise<T | undefined> {
+  const value = await loader();
+  if (value === undefined) return undefined;
+  await writeEntry(db, key, { value, expires: Date.now() + ttlMs });
+  return value;
+}
+
 export async function persistentCache<T>(
   key: string,
   ttlMs: number,
   loader: () => Promise<T | undefined>,
+  opts?: { staleWhileRevalidate?: boolean },
 ): Promise<T | undefined> {
   const db = await dataDb().catch(() => undefined);
-  const file = fileFor(key);
-  const entry = db
-    ? await d1Read(key)
-    : loadJsonFile<Entry | undefined>(file, () => undefined);
+  const entry = await readEntry(db, key);
   if (entry && entry.expires > Date.now()) return entry.value as T;
-  const value = await loader();
-  if (value === undefined) return entry?.value as T | undefined;
-  const next: Entry = { value, expires: Date.now() + ttlMs };
-  if (db) await d1Write(key, next);
-  else saveJsonFile(file, next);
-  return value;
+  if (entry && opts?.staleWhileRevalidate) {
+    const pending =
+      inflight.get(key) ??
+      loadAndStore(key, ttlMs, loader, db).finally(() =>
+        inflight.delete(key),
+      );
+    inflight.set(key, pending);
+    void pending.catch(() => {});
+    return entry.value as T;
+  }
+  const value = await loadAndStore(key, ttlMs, loader, db);
+  return value ?? (entry?.value as T | undefined);
 }