fix: auto-reconnect stale SQLite Cloud connection in getDb()

The cached Database client could hold a dead websocket after the
SQLite Cloud node auto-pauses (free tier) and resumes, making every
query fail with "Connection unavailable" until the process restarts —
which silently emptied /blog and broke CrawlProof webhook inserts.

Wrap the client's `sql` tagged-template so disconnect-class errors drop
the client and retry once on a fresh connection. Drop-in: all call
sites use only `db.sql`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ralyodio

apps/web/lib/db.ts

@@ -2,14 +2,55 @@ import 'server-only';
 import { Database } from '@sqlitecloud/drivers';
 import { loadRootEnv } from './root-env';
 
-let db: Database | null = null;
+let client: Database | null = null;
 
-export function getDb(): Database {
-  if (!db) {
-    loadRootEnv();
-    const url = process.env.SQLITECLOUD_URL;
-    if (!url) throw new Error('SQLITECLOUD_URL is not set');
-    db = new Database({ connectionstring: url, usewebsocket: true });
+function createClient(): Database {
+  loadRootEnv();
+  const url = process.env.SQLITECLOUD_URL;
+  if (!url) throw new Error('SQLITECLOUD_URL is not set');
+  return new Database({ connectionstring: url, usewebsocket: true });
+}
+
+// A cached client can hold a dead websocket after the SQLite Cloud node pauses
+// and resumes (free-tier auto-pause). Without this, getDb() keeps returning the
+// same broken connection and every query fails with "Connection unavailable"
+// until the process is restarted — which is exactly how /blog silently emptied.
+// Treat disconnect-class errors as recoverable: drop the client and retry once
+// with a fresh connection.
+function isDisconnect(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /connection unavailable|got disconnected|disconnected|connection not been established|ERR_CONNECTION/i.test(
+    msg
+  );
+}
+
+async function runSql(args: unknown[]): Promise<unknown> {
+  if (!client) client = createClient();
+  try {
+    return await (client.sql as (...a: unknown[]) => Promise<unknown>)(...args);
+  } catch (err) {
+    if (!isDisconnect(err)) throw err;
+    try {
+      (client as unknown as { close?: () => void }).close?.();
+    } catch {
+      /* ignore close failures on an already-dead socket */
+    }
+    client = createClient();
+    return await (client.sql as (...a: unknown[]) => Promise<unknown>)(...args);
   }
-  return db;
+}
+
+// Returns the shared client with its `sql` tagged-template wrapped so a stale
+// connection self-heals. All call sites use only `db.sql`, so this is drop-in.
+export function getDb(): Database {
+  if (!client) client = createClient();
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === 'sql') {
+        return (...args: unknown[]) => runSql(args);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
 }