fix(suggestions): only persist profiles for actual Sifa users (#119)

The profile resolver was inserting profile rows for ALL Bluesky
follows (5000+), polluting the profiles table and inflating user
counts on the admin page.

Now only persists profiles for DIDs that have sessions (actual Sifa
users). For "Not on Sifa" suggestion cards, resolves Bluesky
profile data on-the-fly without persisting.

src/routes/suggestions.ts

···
 import { createAuthMiddleware, getAuthContext } from '../middleware/auth.js';
 import { fetchBlueskyFollowsFromPds, importBlueskyFollows } from '../services/bluesky-follows.js';
 import { fetchTangledFollowsFromPds, importTangledFollows } from '../services/tangled-follows.js';
-import { resolveAndUpsertProfiles } from '../services/profile-resolver.js';
+import {
+  resolveAndUpsertProfiles,
+  fetchProfilesFromBluesky,
+} from '../services/profile-resolver.js';
 
 const dismissSchema = z.object({
   subjectDid: z.string().startsWith('did:'),
···
     const hasMore = notOnSifaRows.length > limit;
     const notOnSifaItems = hasMore ? notOnSifaRows.slice(0, limit) : notOnSifaRows;
 
-    const notOnSifa = notOnSifaItems.map((i) => ({
-      did: i.subjectDid,
-      handle: i.handle ?? '',
-      displayName: i.displayName ?? undefined,
-      avatarUrl: i.avatarUrl ?? undefined,
-      source: i.source,
-      dismissed: dismissedSet.has(i.subjectDid),
-    }));
+    // Enrich "Not on Sifa" results with Bluesky profile data (without persisting)
+    const didsNeedingProfiles = notOnSifaItems.filter((i) => !i.handle).map((i) => i.subjectDid);
+    const enriched =
+      didsNeedingProfiles.length > 0
+        ? await fetchProfilesFromBluesky(didsNeedingProfiles, app.log)
+        : [];
+    const enrichedMap = new Map(enriched.map((p) => [p.did, p]));
+
+    const notOnSifa = notOnSifaItems.map((i) => {
+      const bsky = enrichedMap.get(i.subjectDid);
+      return {
+        did: i.subjectDid,
+        handle: i.handle || bsky?.handle || '',
+        displayName: i.displayName ?? bsky?.displayName,
+        avatarUrl: i.avatarUrl ?? bsky?.avatarUrl,
+        source: i.source,
+        dismissed: dismissedSet.has(i.subjectDid),
+      };
+    });
 
     return reply.send({
       onSifa,
···
         app.log.debug({ err, did }, 'Tangled follow sync skipped or failed');
       }
 
-      // Resolve profiles for imported DIDs that don't have profile data yet
-      const allDids = [
-        ...(blueskyCount > 0
-          ? (
-              await db
-                .select({ subjectDid: connections.subjectDid })
-                .from(connections)
-                .where(and(eq(connections.followerDid, did), ne(connections.source, 'sifa')))
-            ).map((r) => r.subjectDid)
-          : []),
-      ];
-      if (allDids.length > 0) {
+      // Only resolve profiles for DIDs that are actual Sifa users (have sessions)
+      // Do NOT insert profiles for random Bluesky follows — that pollutes the DB.
+      const claimedFollowDids = await db
+        .select({ subjectDid: connections.subjectDid })
+        .from(connections)
+        .where(
+          and(
+            eq(connections.followerDid, did),
+            ne(connections.source, 'sifa'),
+            sql`${connections.subjectDid} IN (SELECT DISTINCT did FROM sessions)`,
+          ),
+        );
+      const claimedDids = claimedFollowDids.map((r) => r.subjectDid);
+      if (claimedDids.length > 0) {
         try {
-          const resolved = await resolveAndUpsertProfiles(db, allDids, app.log);
-          app.log.info({ did, resolved }, 'Resolved profiles for suggestions');
+          const resolved = await resolveAndUpsertProfiles(db, claimedDids, app.log);
+          app.log.info({ did, resolved }, 'Resolved profiles for On Sifa suggestions');
         } catch (err) {
           app.log.error({ err, did }, 'Profile resolution for suggestions failed');
         }

src/services/profile-resolver.ts

···
 const PUBLIC_API = 'https://public.api.bsky.app';
 const BATCH_SIZE = 25;
 
+interface ResolvedProfile {
+  did: string;
+  handle: string;
+  displayName?: string;
+  avatarUrl?: string;
+}
+
 /**
  * Resolves profiles from the public Bluesky API for DIDs that don't
  * already have profile data in the local database.
- * Returns the number of profiles resolved.
+ * Only inserts profiles for DIDs that are actual Sifa users (have sessions).
  */
 export async function resolveAndUpsertProfiles(
   db: Database,
···
   const missing = dids.filter((d) => !existingDids.has(d));
   if (missing.length === 0) return 0;
 
+  const resolved = await fetchProfilesFromBluesky(missing, logger);
+  let upserted = 0;
+  const now = new Date();
+
+  for (const profile of resolved) {
+    try {
+      await db
+        .insert(profiles)
+        .values({
+          did: profile.did,
+          handle: profile.handle,
+          displayName: profile.displayName ?? null,
+          avatarUrl: profile.avatarUrl ?? null,
+          createdAt: now,
+        })
+        .onConflictDoNothing();
+      upserted++;
+    } catch (err) {
+      logger.debug({ err, did: profile.did }, 'Profile upsert failed');
+    }
+  }
+
+  return upserted;
+}
+
+/**
+ * Fetches profile data from the public Bluesky API without persisting.
+ * Used to display names/avatars for "Not on Sifa" suggestion cards.
+ */
+export async function fetchProfilesFromBluesky(
+  dids: string[],
+  logger: FastifyBaseLogger,
+): Promise<ResolvedProfile[]> {
+  if (dids.length === 0) return [];
+
   const publicAgent = new Agent(PUBLIC_API);
-  let resolved = 0;
-  const now = new Date();
+  const results: ResolvedProfile[] = [];
 
-  // Resolve in batches using getProfiles (max 25 per request)
-  for (let i = 0; i < missing.length; i += BATCH_SIZE) {
-    const batch = missing.slice(i, i + BATCH_SIZE);
+  for (let i = 0; i < dids.length; i += BATCH_SIZE) {
+    const batch = dids.slice(i, i + BATCH_SIZE);
     try {
       const res = await publicAgent.getProfiles(
         { actors: batch },
         { signal: AbortSignal.timeout(10000) },
       );
       for (const profile of res.data.profiles) {
-        try {
-          await db
-            .insert(profiles)
-            .values({
-              did: profile.did,
-              handle: profile.handle,
-              displayName: profile.displayName ?? null,
-              avatarUrl: profile.avatar ?? null,
-              createdAt: now,
-            })
-            .onConflictDoNothing();
-          resolved++;
-        } catch (err) {
-          logger.debug({ err, did: profile.did }, 'Profile upsert failed');
-        }
+        results.push({
+          did: profile.did,
+          handle: profile.handle,
+          displayName: profile.displayName,
+          avatarUrl: profile.avatar,
+        });
       }
     } catch (err) {
       logger.warn({ err, batchStart: i, batchSize: batch.length }, 'Profile batch resolve failed');
     }
   }
 
-  return resolved;
+  return results;
 }