beacon: search + graph metrics + network stats (UI items 1,3,4)

melvincarvalho · melvincarvalho · commit 25230df93c20 · 2026-06-15T22:26:19.000+02:00
- Search: /api/search by name/nip05 (content text index), npub (bech32 decode)
  or hex pubkey; results ranked by followers so prominent accounts surface.
- Graph metrics: follower (in-degree, via follows_1 index) + following counts
  on /api/did, /api/profiles and /api/search (batched enrichCounts).
- Network stats: /api/stats (profiles/follows/relays, 60s cache).
- UI: search box + live results, network stats in hero, follower/following
  counts on cards and the profile header.
diff --git a/public/index.html b/public/index.html
@@ -73,6 +73,20 @@
   footer{text-align:center;color:var(--faint);font-size:.8rem;margin-top:3rem}
   footer a{color:var(--accent)}
   .loading{text-align:center;color:var(--faint);padding:3rem;font-size:.9rem}
+
+  /* search */
+  .searchwrap{margin:1.9rem auto .2rem;max-width:31rem}
+  .searchwrap input{width:100%;font-family:var(--sans);font-size:1rem;color:var(--ink);background:#fff;
+    border:1px solid var(--line);border-radius:999px;padding:.82rem 1.25rem;outline:none;
+    box-shadow:0 1px 2px rgba(20,20,30,.04);transition:border-color .15s,box-shadow .15s}
+  .searchwrap input:focus{border-color:var(--accent);box-shadow:0 0 0 4px var(--accent-soft)}
+  .searchwrap input::placeholder{color:var(--faint)}
+  .hero .stat strong{color:var(--muted);font-weight:700}
+  /* counts + section label */
+  .card .counts{font-size:.8rem;color:var(--muted);margin-top:.5rem}
+  .card .counts strong{color:var(--ink);font-weight:600}
+  .seclabel{font-size:.74rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase;color:var(--faint);margin:.4rem 0 1rem}
+  .chip strong{font-weight:700}
 </style>
 </head>
 <body>
@@ -81,6 +95,7 @@
     <span class="mark"><span class="dot"></span> Beacon</span>
     <h1>A directory of <em style="font-style:italic">did:nostr</em> identities</h1>
     <p>Profiles, the follow graph, and a verifiable DID document for every key &mdash; indexed live from Nostr.</p>
+    <div class="searchwrap"><input id="q" type="search" placeholder="Search by name, nip05, npub, or hex pubkey…" autocomplete="off" spellcheck="false"></div>
     <div class="stat" id="stat"></div>
   </div>
   <div id="view"></div>
@@ -108,32 +123,61 @@ <h1>A directory of <em style="font-style:italic">did:nostr</em> identities</h1>
     .replace(/: (&quot;[^&]*?&quot;)/g, ': <span class="s">$1</span>');
 }
 
+const fmt = (n) => {
+  n = Number(n) || 0;
+  if (n >= 1e6) return (n / 1e6).toFixed(n < 1e7 ? 1 : 0) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(n < 1e4 ? 1 : 0) + 'k';
+  return String(n);
+};
+
+function cardHtml(p) {
+  const c = content(p);
+  const ct = p._counts || {};
+  return `<div class="card" data-pk="${p.pubkey}">
+    ${avatar(c, p.pubkey)}
+    <div class="name">${esc(c.name || c.display_name || short(p.pubkey))}</div>
+    ${c.nip05 ? `<div class="nip05">${esc(c.nip05)}</div>` : ''}
+    <div class="counts"><strong>${fmt(ct.followers)}</strong> followers · <strong>${fmt(ct.following)}</strong> following</div>
+    ${c.about ? `<div class="about">${esc(c.about)}</div>` : ''}
+    <div class="did">did:nostr:${short(p.pubkey)}</div>
+  </div>`;
+}
+
+function renderGrid(profiles, label) {
+  view.innerHTML = `${label ? `<div class="seclabel">${label}</div>` : ''}<div class="grid">${profiles.map(cardHtml).join('')}</div>`;
+  view.querySelectorAll('.card').forEach((el) => { el.onclick = () => { location.hash = el.dataset.pk; }; });
+}
+
+async function loadStats() {
+  const s = await fetch('/api/stats').then((r) => r.json()).catch(() => null);
+  if (s) $('#stat').innerHTML = `<strong>${fmt(s.profiles)}</strong> identities · <strong>${fmt(s.follows)}</strong> follow lists · <strong>${fmt(s.relays)}</strong> relays`;
+}
+
 async function home() {
-  location.hash = '';
-  view.innerHTML = '<div class="loading">loading recent identities…</div>';
+  if ($('#q')) $('#q').value = '';
+  view.innerHTML = '<div class="loading">loading identities…</div>';
   const profiles = await fetch('/api/profiles?limit=36').then((r) => r.json()).catch(() => []);
-  $('#stat').textContent = profiles.length ? `${profiles.length} recently active identities` : '';
   if (!profiles.length) { view.innerHTML = '<div class="loading">No profiles indexed yet. Start the indexer and refresh.</div>'; return; }
-  view.innerHTML = `<div class="grid">${profiles.map((p) => {
-    const c = content(p);
-    return `<div class="card" data-pk="${p.pubkey}">
-      ${avatar(c, p.pubkey)}
-      <div class="name">${esc(c.name || c.display_name || short(p.pubkey))}</div>
-      ${c.nip05 ? `<div class="nip05">${esc(c.nip05)}</div>` : ''}
-      ${c.about ? `<div class="about">${esc(c.about)}</div>` : ''}
-      <div class="did">did:nostr:${short(p.pubkey)}</div>
-    </div>`;
-  }).join('')}</div>`;
-  view.querySelectorAll('.card').forEach((el) => el.onclick = () => { location.hash = el.dataset.pk; });
+  renderGrid(profiles, 'Recently active');
 }
 
+async function searchView(q) {
+  view.innerHTML = '<div class="loading">searching…</div>';
+  const results = await fetch(`/api/search?q=${encodeURIComponent(q)}`).then((r) => r.json()).catch(() => []);
+  if (!Array.isArray(results) || !results.length) { view.innerHTML = `<div class="loading">No matches for &ldquo;${esc(q)}&rdquo;.</div>`; return; }
+  renderGrid(results, `${results.length} result${results.length > 1 ? 's' : ''} for &ldquo;${esc(q)}&rdquo;`);
+}
+
+// strip our UI-only count fields so the displayed JSON is the pure DID document
+const didOnly = ({ followersCount, followingCount, ...d }) => d;
+
 async function profile(pk) {
   view.innerHTML = '<div class="loading">resolving DID document…</div>';
-  $('#stat').textContent = '';
   const doc = await fetch(`/api/did/${pk}`).then((r) => r.json()).catch(() => null);
   if (!doc || doc.error) { view.innerHTML = '<div class="loading">Could not resolve this identity.</div>'; return; }
   const c = doc.profile || {};
   const follows = doc.follows || [];
+  const followers = doc.followersCount, following = doc.followingCount ?? follows.length;
   view.innerHTML = `<div class="detail">
     <div class="back" id="back">← all identities</div>
     <div class="phead">
@@ -143,30 +187,41 @@ <h2>${esc(c.name || short(pk))}</h2>
         ${c.nip05 ? `<div class="nip05">${esc(c.nip05)}</div>` : ''}
         ${c.about ? `<div class="about">${esc(c.about)}</div>` : ''}
         <div class="chips">
+          <span class="chip"><strong>${fmt(followers)}</strong> followers</span>
+          <span class="chip"><strong>${fmt(following)}</strong> following</span>
+          ${doc.service?.length ? `<span class="chip">${doc.service.length} relay${doc.service.length > 1 ? 's' : ''}</span>` : ''}
           ${c.website ? `<a class="chip" href="${esc(c.website)}" target="_blank" rel="noopener">${esc(c.website.replace(/^https?:\/\//, ''))}</a>` : ''}
           ${c.lud16 ? `<span class="chip">⚡ ${esc(c.lud16)}</span>` : ''}
-          ${doc.service?.length ? `<span class="chip">${doc.service.length} relay${doc.service.length > 1 ? 's' : ''}</span>` : ''}
-          <span class="chip">${follows.length} following</span>
         </div>
       </div>
     </div>
     <a class="didline" href="/.well-known/did/nostr/${pk}.json" target="_blank" rel="noopener" title="Resolve the DID document (application/did+json)"><span>${esc(doc.id)}</span><span class="resolve">resolve ↗</span></a>
     <div class="sections">
-      <div class="panel"><h3>DID document</h3><pre>${highlight(doc)}</pre></div>
+      <div class="panel"><h3>DID document</h3><pre>${highlight(didOnly(doc))}</pre></div>
       <div class="panel"><h3>Following · ${follows.length}</h3>
         ${follows.length ? `<div class="follows">${follows.slice(0, 96).map((d) => { const fk = d.replace('did:nostr:', ''); return `<a class="fav" style="${gradStyle(fk)}" title="${esc(fk)}" href="#${fk}"></a>`; }).join('')}</div>`
           : '<div style="color:var(--faint);font-size:.9rem">No follow list indexed.</div>'}
       </div>
     </div>
   </div>`;
-  $('#back').onclick = home;
+  $('#back').onclick = () => { location.hash = ''; };
+}
+
+let searchTimer;
+function onSearch() {
+  const q = $('#q').value.trim();
+  clearTimeout(searchTimer);
+  searchTimer = setTimeout(() => { if (!q) route(); else searchView(q); }, 220);
 }
 
 function route() {
   const pk = location.hash.slice(1);
   if (/^[0-9a-f]{64}$/.test(pk)) profile(pk); else home();
 }
+
+$('#q').addEventListener('input', onSearch);
 window.addEventListener('hashchange', route);
+loadStats();
 route();
 </script>
 </body>
diff --git a/src/db.js b/src/db.js
@@ -64,3 +64,70 @@ export const getRelays = (pubkey) => one(10002, pubkey);
 export async function recentProfiles(limit = 10) {
   return (await connect()).collection(COLLECTIONS[0]).find().sort({ created_at: -1 }).limit(limit).toArray();
 }
+
+// ---- search ----------------------------------------------------------------
+
+const HEX64 = /^[0-9a-f]{64}$/;
+const BECH32 = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+
+// Minimal bech32 decode (npub -> 32-byte hex). No checksum check: a bad key
+// simply finds nothing on lookup.
+function npubToHex(str) {
+  const s = String(str).toLowerCase();
+  const pos = s.lastIndexOf('1');
+  if (pos < 1) return null;
+  const words = [];
+  for (const ch of s.slice(pos + 1)) { const v = BECH32.indexOf(ch); if (v === -1) return null; words.push(v); }
+  let acc = 0, bits = 0; const bytes = [];
+  for (const w of words.slice(0, -6)) { acc = (acc << 5) | w; bits += 5; while (bits >= 8) { bits -= 8; bytes.push((acc >> bits) & 0xff); } }
+  return bytes.length === 32 ? bytes.map((b) => b.toString(16).padStart(2, '0')).join('') : null;
+}
+
+/** Resolve a search term to a 64-hex pubkey if it is one (hex or npub), else null. */
+export function toPubkey(q) {
+  const s = String(q || '').trim().toLowerCase();
+  if (HEX64.test(s)) return s;
+  if (s.startsWith('npub1')) return npubToHex(s);
+  return null;
+}
+
+/** Search profiles: exact key (hex/npub) or full-text over profile content. */
+export async function searchProfiles(q, limit = 24) {
+  const query = String(q || '').trim();
+  if (!query) return [];
+  const col = (await connect()).collection(COLLECTIONS[0]);
+  const hex = toPubkey(query);
+  if (hex) { const p = await col.findOne({ pubkey: hex }); return p ? [p] : []; }
+  return col.find({ $text: { $search: query } }, { projection: { score: { $meta: 'textScore' } } })
+    .sort({ score: { $meta: 'textScore' } })
+    .limit(Math.min(limit, 50)).toArray();
+}
+
+// ---- graph metrics ---------------------------------------------------------
+
+export async function stats() {
+  const db = await connect();
+  const [profiles, follows, relays] = await Promise.all([
+    db.collection(COLLECTIONS[0]).estimatedDocumentCount(),
+    db.collection(COLLECTIONS[3]).estimatedDocumentCount(),
+    db.collection(COLLECTIONS[10002]).estimatedDocumentCount(),
+  ]);
+  return { profiles, follows, relays };
+}
+
+/** In-degree: how many follow-lists include this pubkey (uses the follows_1 index). */
+export async function followerCount(pubkey) {
+  return (await connect()).collection(COLLECTIONS[3]).countDocuments({ follows: pubkey });
+}
+
+/** Batched { pk: { followers, following } } for a set of pubkeys (for grids). */
+export async function enrichCounts(pubkeys) {
+  const fc = (await connect()).collection(COLLECTIONS[3]);
+  const ids = [...new Set(pubkeys)].filter(Boolean);
+  const out = Object.fromEntries(ids.map((p) => [p, { followers: 0, following: 0 }]));
+  if (!ids.length) return out;
+  const lists = await fc.find({ pubkey: { $in: ids } }, { projection: { pubkey: 1, count: 1, follows: 1 } }).toArray();
+  for (const l of lists) if (out[l.pubkey]) out[l.pubkey].following = l.count ?? (l.follows?.length || 0);
+  await Promise.all(ids.map(async (pk) => { out[pk].followers = await fc.countDocuments({ follows: pk }); }));
+  return out;
+}
diff --git a/src/server.js b/src/server.js
@@ -2,7 +2,7 @@
 import express from 'express';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { getProfile, getFollows, getRelays, recentProfiles, connect } from './db.js';
+import { getProfile, getFollows, getRelays, recentProfiles, connect, stats, searchProfiles, enrichCounts, followerCount } from './db.js';
 import { buildDidDocument } from './diddoc.js';
 import 'dotenv/config';
 
@@ -11,10 +11,45 @@ const PUBLIC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'pu
 export async function startServer(port = process.env.PORT || 3000) {
   await connect();
   const app = express();
+  // Public read-only resolver: allow cross-origin fetches so browser-based
+  // did:nostr resolvers can read the documents.
+  app.use((_req, res, next) => { res.setHeader('Access-Control-Allow-Origin', '*'); next(); });
   app.use(express.static(PUBLIC));
 
+  // Liveness/readiness: confirms Mongo is reachable (for haproxy httpchk + monitoring).
+  app.get('/healthz', async (_req, res) => {
+    try { await (await connect()).command({ ping: 1 }); res.json({ ok: true }); }
+    catch (e) { res.status(503).json({ ok: false, error: e.message }); }
+  });
+
+  // attach { followers, following } to each profile under `_counts`
+  const withCounts = async (profiles) => {
+    const counts = await enrichCounts(profiles.map((p) => p.pubkey));
+    return profiles.map((p) => ({ ...p, _counts: counts[p.pubkey] }));
+  };
+
+  // network stats, cached 60s (estimatedDocumentCount is cheap but stable)
+  let statsCache = { at: 0, val: null };
+  app.get('/api/stats', async (_req, res, next) => {
+    try {
+      if (!statsCache.val || Date.now() - statsCache.at > 60_000) statsCache = { at: Date.now(), val: await stats() };
+      res.json(statsCache.val);
+    } catch (e) { next(e); }
+  });
+
+  // search by name / nip05 / npub / hex pubkey; rank matches by followers so
+  // prominent accounts surface above same-named namesakes.
+  app.get('/api/search', async (req, res, next) => {
+    try {
+      const limit = Math.min(Number(req.query.limit) || 24, 50);
+      const pool = await withCounts(await searchProfiles(req.query.q, Math.max(limit, 40)));
+      pool.sort((a, b) => (b._counts?.followers || 0) - (a._counts?.followers || 0));
+      res.json(pool.slice(0, limit));
+    } catch (e) { next(e); }
+  });
+
   app.get('/api/profiles', async (req, res, next) => {
-    try { res.json(await recentProfiles(Math.min(Number(req.query.limit) || 30, 100))); } catch (e) { next(e); }
+    try { res.json(await withCounts(await recentProfiles(Math.min(Number(req.query.limit) || 30, 100)))); } catch (e) { next(e); }
   });
   app.get('/api/profile/:pubkey', async (req, res, next) => {
     try { res.json(await getProfile(req.params.pubkey)); } catch (e) { next(e); }
@@ -41,11 +76,14 @@ export async function startServer(port = process.env.PORT || 3000) {
       res.json(doc);
     } catch (e) { next(e); }
   });
+  // UI-facing resolution: the conformant doc + graph counts (followers = in-degree).
+  // The .well-known endpoint above stays the pure conformant document.
   app.get('/api/did/:pubkey', async (req, res, next) => {
     try {
       const doc = await resolve(req.params.pubkey);
       if (!doc) return res.status(400).json({ error: 'invalid did:nostr pubkey (expect 64-hex)' });
-      res.json(doc);
+      const followers = await followerCount(req.params.pubkey.toLowerCase());
+      res.json({ ...doc, followersCount: followers, followingCount: doc.follows?.length || 0 });
     } catch (e) { next(e); }
   });
 
