Expand ecash explorer capabilities

Add Fedimint discovery, dual SQLite/Postgres storage, richer review handling, and generated social imagery.

api/src/check-offline.ts

@@ -8,44 +8,62 @@
  * a test that actually kills a mint rather than a unit test of a helper.
  *
  * Runs against a throwaway copy of the seeded database, so the real one is untouched.
+ * The copy is made with the migrator, which means the check works whichever backend
+ * holds the real data — and, as a side effect, exercises the migrator on every run.
+ *
+ * Set CHECK_DB_URL to run the copy on Postgres instead of a temporary SQLite file:
+ *
+ *   CHECK_DB_URL=postgres://localhost/cashumints_test pnpm --filter ./api test:offline
  */
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { parseDbTarget, resolveDbConfig } from './config.ts';
+import { TABLES } from './db-schema.ts';
+import { openDb } from './db.ts';
+import { migrate } from './migrate.ts';
 
-const source = process.env['DB_PATH'] ?? path.resolve(import.meta.dirname, '..', 'data', 'cashumints.db');
-if (!fs.existsSync(source)) {
-  console.error(`No seeded database at ${source}. Run "pnpm seed" first.`);
+const source = resolveDbConfig();
+if (source.dialect === 'sqlite' && !fs.existsSync(source.file)) {
+  console.error(`No seeded database at ${source.file}. Run "pnpm seed" first.`);
   process.exit(1);
 }
 
-// Point the whole process at a copy before anything opens the real database.
 const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'cashumints-offline-'));
-const copy = path.join(scratch, 'test.db');
-fs.copyFileSync(source, copy);
-process.env['DB_PATH'] = copy;
+const target = parseDbTarget(process.env['CHECK_DB_URL'] ?? path.join(scratch, 'test.db'));
+
+// A reused Postgres test database still holds the last run's rows, and a stale mint row
+// would be picked as the victim. Start empty either way.
+const wipe = await openDb(target);
+for (const table of TABLES) await wipe.run(`DELETE FROM ${table}`);
+await wipe.close();
+
+await migrate({ from: source, to: target, force: true, dryRun: false });
+
+// Point the whole process at the copy before anything else opens a database.
+process.env['DATABASE_URL'] = target.dialect === 'postgres' ? target.url : `sqlite:${target.file}`;
+delete process.env['DB_PATH'];
 
 const { getDb, closeDb } = await import('./db.ts');
 const { probeMint } = await import('./probe.ts');
-const { getMintDetail } = await import('./queries.ts');
+const { getMintDetail, listMints, resetStatsCache } = await import('./queries.ts');
 const { mintByUrl } = await import('./mints.ts');
 
-const db = getDb();
+const db = await getDb();
+assert.equal(db.label, target.label, 'the check must not be talking to the real database');
 
 // Pick a mint that is online and has real cached metadata to lose.
-const victim = db
-  .prepare(
-    `SELECT * FROM mints
-     WHERE status = 'online' AND info_json IS NOT NULL AND name IS NOT NULL
-     ORDER BY LENGTH(info_json) DESC LIMIT 1`,
-  )
-  .get() as { url: string; host: string; name: string } | undefined;
+const victim = await db.get<{ url: string; host: string; name: string }>(
+  `SELECT url, host, name FROM mints
+   WHERE status = 'online' AND info_json IS NOT NULL AND name IS NOT NULL
+   ORDER BY LENGTH(info_json) DESC LIMIT 1`,
+);
 
 assert.ok(victim, 'seeded database has no online mint with cached metadata');
 console.log(`victim: ${victim.name} (${victim.host})`);
 
-const before = getMintDetail(victim.host);
+const before = await getMintDetail(victim.host);
 assert.ok(before, 'detail must exist before the mint dies');
 assert.equal(before.status, 'online');
 assert.ok(before.info, 'must have cached /v1/info before');
@@ -53,18 +71,20 @@ assert.ok(before.nuts.length > 0, 'must have parsed NUTs before');
 
 // Rug it: same row, dead URL. This is the "point a mint row at a dead URL" test.
 const DEAD = 'https://this-mint-is-gone.invalid';
-db.prepare('UPDATE mints SET url = ? WHERE host = ?').run(DEAD, victim.host);
-db.prepare('UPDATE reviews SET mint_url = ? WHERE mint_url = ?').run(DEAD, victim.url);
+await db.run('UPDATE mints SET url = ? WHERE host = ?', DEAD, victim.host);
+await db.run('UPDATE reviews SET mint_url = ? WHERE mint_url = ?', DEAD, victim.url);
 
 // Three failures is the offline threshold.
 for (let i = 0; i < 3; i++) {
-  const row = mintByUrl(DEAD);
+  const row = await mintByUrl(DEAD);
   assert.ok(row, 'row must survive the URL change');
   const result = await probeMint(row);
   assert.equal(result.ok, false, 'a dead URL must not probe ok');
 }
 
-const after = getMintDetail(victim.host);
+resetStatsCache();
+
+const after = await getMintDetail(victim.host);
 assert.ok(after, 'the mint page must still resolve when the mint is dead');
 assert.equal(after.status, 'offline', 'three failures means offline');
 
@@ -86,17 +106,17 @@ assert.ok(after.last_online !== null, 'last_online must be set so the banner has
 assert.ok(after.last_online <= Math.floor(Date.now() / 1000));
 
 // And it must sink below every online mint without disappearing.
-const { listMints } = await import('./queries.ts');
-const list = listMints();
+const list = await listMints();
 const index = list.findIndex((m) => m.host === victim.host);
 assert.ok(index >= 0, 'an offline mint must stay listed so people can find and review it');
 const lastOnline = list.map((m) => m.status).lastIndexOf('online');
 assert.ok(index > lastOnline, 'offline mints rank below every online mint');
 
-closeDb();
+await closeDb();
 fs.rmSync(scratch, { recursive: true, force: true });
 
 console.log(
-  `ok, offline mint still serves ${after.nuts.length} NUTs, ${after.review_count} reviews, ` +
-    `and full cached metadata (offline since ${new Date(after.last_online * 1000).toISOString()})`,
+  `ok on ${db.dialect}, offline mint still serves ${after.nuts.length} NUTs, ` +
+    `${after.review_count} reviews, and full cached metadata ` +
+    `(offline since ${new Date(after.last_online * 1000).toISOString()})`,
 );