fix: use id cache

parakeet/src/db.rs

···
 pub use graph::{
     get_actor_followers, get_actor_followers_by_id, get_actor_follows, get_actor_follows_by_id,
     get_actor_lists, get_followed_by_batch, get_following_batch, get_list_id_by_uri, get_list_items,
-    get_mutual_followers, get_user_blocks, get_user_list_blocks, get_user_list_mutes, get_user_mutes,
+    get_mutual_followers, get_mutual_followers_by_id, get_user_blocks, get_user_list_blocks,
+    get_user_list_mutes, get_user_mutes,
 };
 pub use likes::{get_actor_likes, get_like_state, get_like_states, get_post_likes};
 pub use notification_records::{get_follow_record, get_like_record, get_post_record, get_repost_record};

parakeet/src/db/graph.rs

···
     })
 }
 
+/// Get known followers (mutual follows intersection) - OPTIMIZED VERSION
+///
+/// Returns list of (created_at, follower_actor_id) tuples for followers that viewer also follows.
+/// The caller should resolve follower_actor_ids → DIDs via IdCache.
+///
+/// This version eliminates the 3x actors table JOINs that the non-optimized version has.
+pub async fn get_mutual_followers_by_id(
+    conn: &mut AsyncPgConnection,
+    target_actor_id: i32,
+    viewer_actor_id: i32,
+    cursor_timestamp: Option<&chrono::DateTime<chrono::Utc>>,
+    limit: u8,
+) -> QueryResult<Vec<(chrono::DateTime<chrono::Utc>, i32)>> {
+    #[derive(QueryableByName)]
+    struct MutualFollowerRow {
+        #[diesel(sql_type = Timestamptz)]
+        created_at: chrono::DateTime<chrono::Utc>,
+        #[diesel(sql_type = Integer)]
+        follower_actor_id: i32,
+    }
+
+    // OPTIMIZED: No actors JOINs! Uses actor_ids directly
+    diesel::sql_query(
+        "SELECT DISTINCT ON (f1.actor_id) tid_timestamp(f1.rkey) as created_at, f1.actor_id as follower_actor_id
+         FROM follows f1
+         INNER JOIN follows f2 ON f1.actor_id = f2.subject_actor_id
+         WHERE f1.subject_actor_id = $1
+           AND f2.actor_id = $2
+           AND ($3::timestamptz IS NULL OR tid_timestamp(f1.rkey) < $3)
+         ORDER BY f1.actor_id, f1.rkey DESC
+         LIMIT $4"
+    )
+    .bind::<Integer, _>(target_actor_id)
+    .bind::<Integer, _>(viewer_actor_id)
+    .bind::<Nullable<Timestamptz>, _>(cursor_timestamp)
+    .bind::<BigInt, _>(i64::from(limit))
+    .load::<MutualFollowerRow>(conn)
+    .await
+    .map(|rows| {
+        rows.into_iter()
+            .map(|r| (r.created_at, r.follower_actor_id))
+            .collect()
+    })
+}
+
 /// Get lists owned by an actor with cursor pagination
 ///
 /// Returns list of (created_at, at_uri) tuples

parakeet/src/xrpc/app_bsky/graph/relations.rs

···
     // Parse TID cursor
     let parsed_cursor = crate::xrpc::tid_cursor(query.cursor.as_ref());
 
-    // Parallelize: hydrate subject profile and query followers concurrently
-    let (subject_opt, results) = tokio::join!(
-        hyd.hydrate_profile(subj_did.clone()),
-        crate::db::get_actor_followers(&mut conn, &subj_did, parsed_cursor, limit)
-    );
+    // OPTIMIZATION: Resolve subject DID → actor_id via IdCache to use optimized query
+    let subject_actor_id_opt = state.id_cache.get_actor_id_only(&subj_did).await;
 
+    // Hydrate subject profile first (needed either way)
+    let subject_opt = hyd.hydrate_profile(subj_did.clone()).await;
     let Some(subject) = subject_opt else {
         return Err(Error::not_found());
     };
 
-    let results = results?;
+    // Query followers using optimized or non-optimized path
+    let (cursor, dids) = if let Some(subject_actor_id) = subject_actor_id_opt {
+        // OPTIMIZED PATH: Use _by_id version (0 JOINs!)
+        let results = crate::db::get_actor_followers_by_id(&mut conn, subject_actor_id, parsed_cursor, limit).await?;
 
-    // Generate cursor from TID (base32-encoded rkey)
-    let cursor = results
-        .last()
-        .map(|row| parakeet_db::tid_util::encode_tid(row.0));
+        // Generate cursor from TID (base32-encoded rkey)
+        let cursor = results
+            .last()
+            .map(|row| parakeet_db::tid_util::encode_tid(row.0));
 
-    let dids = results.iter().map(|row| row.1.clone()).collect();
+        // Batch resolve actor_ids → DIDs via IdCache
+        let actor_ids: Vec<i32> = results.iter().map(|row| row.1).collect();
+        let unique_actor_ids: std::collections::HashSet<i32> = actor_ids.iter().copied().collect();
+        let actor_ids_vec: Vec<i32> = unique_actor_ids.into_iter().collect();
 
-    let mut profiles = hyd.hydrate_profiles(dids).await;
+        // Batch resolve via IdCache
+        let cached = state.id_cache.get_actor_data_many(&actor_ids_vec).await;
+        let mut actor_id_to_did: std::collections::HashMap<i32, String> = cached
+            .into_iter()
+            .map(|(id, data)| (id, data.did))
+            .collect();
 
-    let followers = results
+        // Query DB for cache misses
+        let missing: Vec<i32> = actor_ids_vec
+            .iter()
+            .filter(|id| !actor_id_to_did.contains_key(id))
+            .copied()
+            .collect();
+
+        if !missing.is_empty() {
+            use diesel::sql_types::{Array, Integer, Text};
+            use diesel_async::RunQueryDsl;
+
+            #[derive(diesel::QueryableByName)]
+            struct ActorRow {
+                #[diesel(sql_type = Integer)]
+                id: i32,
+                #[diesel(sql_type = Text)]
+                did: String,
+            }
+
+            let db_results: Vec<ActorRow> = diesel::sql_query(
+                "SELECT id, did FROM actors WHERE id = ANY($1)"
+            )
+            .bind::<Array<Integer>, _>(&missing)
+            .load(&mut conn)
+            .await
+            .map_err(|e| {
+                Error::new(
+                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                    "DatabaseError",
+                    Some(format!("Failed to resolve follower DIDs: {}", e)),
+                )
+            })?;
+
+            for row in db_results {
+                actor_id_to_did.insert(row.id, row.did);
+            }
+        }
+
+        // Map actor_ids to DIDs, preserving order
+        let dids: Vec<String> = actor_ids
+            .into_iter()
+            .filter_map(|id| actor_id_to_did.get(&id).cloned())
+            .collect();
+
+        (cursor, dids)
+    } else {
+        // NON-OPTIMIZED PATH: Use original version with JOINs
+        let results = crate::db::get_actor_followers(&mut conn, &subj_did, parsed_cursor, limit).await?;
+
+        // Generate cursor from TID (base32-encoded rkey)
+        let cursor = results
+            .last()
+            .map(|row| parakeet_db::tid_util::encode_tid(row.0));
+
+        let dids = results.iter().map(|row| row.1.clone()).collect();
+
+        (cursor, dids)
+    };
+
+    let mut profiles = hyd.hydrate_profiles(dids.clone()).await;
+
+    let followers = dids
         .into_iter()
-        .filter_map(|row| profiles.remove(&row.1))
+        .filter_map(|did| profiles.remove(&did))
         .collect();
 
     Ok(Json(AppBskyGraphGetFollowersRes {
···
     // Parse TID cursor
     let parsed_cursor = crate::xrpc::tid_cursor(query.cursor.as_ref());
 
-    // Parallelize: hydrate subject profile and query follows concurrently
-    let (subject_opt, results) = tokio::join!(
-        hyd.hydrate_profile(subj_did.clone()),
-        crate::db::get_actor_follows(&mut conn, &subj_did, parsed_cursor, limit)
-    );
+    // OPTIMIZATION: Resolve subject DID → actor_id via IdCache to use optimized query
+    let subject_actor_id_opt = state.id_cache.get_actor_id_only(&subj_did).await;
 
+    // Hydrate subject profile first (needed either way)
+    let subject_opt = hyd.hydrate_profile(subj_did.clone()).await;
     let Some(subject) = subject_opt else {
         return Err(Error::not_found());
     };
 
-    let results = results?;
+    // Query follows using optimized or non-optimized path
+    let (cursor, dids) = if let Some(subject_actor_id) = subject_actor_id_opt {
+        // OPTIMIZED PATH: Use _by_id version (0 JOINs!)
+        let results = crate::db::get_actor_follows_by_id(&mut conn, subject_actor_id, parsed_cursor, limit).await?;
+
+        // Generate cursor from TID (base32-encoded rkey)
+        let cursor = results
+            .last()
+            .map(|row| parakeet_db::tid_util::encode_tid(row.0));
+
+        // Batch resolve actor_ids → DIDs via IdCache
+        let actor_ids: Vec<i32> = results.iter().map(|row| row.1).collect();
+        let unique_actor_ids: std::collections::HashSet<i32> = actor_ids.iter().copied().collect();
+        let actor_ids_vec: Vec<i32> = unique_actor_ids.into_iter().collect();
+
+        // Batch resolve via IdCache
+        let cached = state.id_cache.get_actor_data_many(&actor_ids_vec).await;
+        let mut actor_id_to_did: std::collections::HashMap<i32, String> = cached
+            .into_iter()
+            .map(|(id, data)| (id, data.did))
+            .collect();
+
+        // Query DB for cache misses
+        let missing: Vec<i32> = actor_ids_vec
+            .iter()
+            .filter(|id| !actor_id_to_did.contains_key(id))
+            .copied()
+            .collect();
+
+        if !missing.is_empty() {
+            use diesel::sql_types::{Array, Integer, Text};
+            use diesel_async::RunQueryDsl;
+
+            #[derive(diesel::QueryableByName)]
+            struct ActorRow {
+                #[diesel(sql_type = Integer)]
+                id: i32,
+                #[diesel(sql_type = Text)]
+                did: String,
+            }
 
-    // Generate cursor from TID (base32-encoded rkey)
-    let cursor = results
-        .last()
-        .map(|row| parakeet_db::tid_util::encode_tid(row.0));
+            let db_results: Vec<ActorRow> = diesel::sql_query(
+                "SELECT id, did FROM actors WHERE id = ANY($1)"
+            )
+            .bind::<Array<Integer>, _>(&missing)
+            .load(&mut conn)
+            .await
+            .map_err(|e| {
+                Error::new(
+                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                    "DatabaseError",
+                    Some(format!("Failed to resolve followed DIDs: {}", e)),
+                )
+            })?;
 
-    let dids = results.iter().map(|row| row.1.clone()).collect();
+            for row in db_results {
+                actor_id_to_did.insert(row.id, row.did);
+            }
+        }
 
-    let mut profiles = hyd.hydrate_profiles(dids).await;
+        // Map actor_ids to DIDs, preserving order
+        let dids: Vec<String> = actor_ids
+            .into_iter()
+            .filter_map(|id| actor_id_to_did.get(&id).cloned())
+            .collect();
 
-    let follows = results
+        (cursor, dids)
+    } else {
+        // NON-OPTIMIZED PATH: Use original version with JOINs
+        let results = crate::db::get_actor_follows(&mut conn, &subj_did, parsed_cursor, limit).await?;
+
+        // Generate cursor from TID (base32-encoded rkey)
+        let cursor = results
+            .last()
+            .map(|row| parakeet_db::tid_util::encode_tid(row.0));
+
+        let dids = results.iter().map(|row| row.1.clone()).collect();
+
+        (cursor, dids)
+    };
+
+    let mut profiles = hyd.hydrate_profiles(dids.clone()).await;
+
+    let follows = dids
         .into_iter()
-        .filter_map(|row| profiles.remove(&row.1))
+        .filter_map(|did| profiles.remove(&did))
         .collect();
 
     Ok(Json(AppBskyGraphGetFollowsRes {
···
     let viewer_did = auth.0.clone();
     let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, Some(auth));
 
-    // Resolve target actor
+    // Resolve target and viewer actors
     let target_did = get_actor_did(&state.dataloaders, query.actor).await?;
 
     let limit = query.limit.unwrap_or(50).clamp(1, 100);
     let parsed_cursor = datetime_cursor(query.cursor.as_ref());
 
-    // Parallelize: hydrate subject profile and query mutual followers concurrently
-    let (subject_opt, results) = tokio::join!(
-        hyd.hydrate_profile(target_did.clone()),
-        crate::db::get_mutual_followers(&mut conn, &target_did, &viewer_did, parsed_cursor.as_ref(), limit)
-    );
+    // OPTIMIZATION: Resolve target and viewer DIDs → actor_ids via IdCache to use optimized query
+    let target_actor_id_opt = state.id_cache.get_actor_id_only(&target_did).await;
+    let viewer_actor_id_opt = state.id_cache.get_actor_id_only(&viewer_did).await;
 
+    // Hydrate subject profile first (needed either way)
+    let subject_opt = hyd.hydrate_profile(target_did.clone()).await;
     let Some(subject) = subject_opt else {
         return Err(Error::not_found());
     };
 
-    let results = results?;
+    // Query known followers using optimized or non-optimized path
+    let (cursor, dids) = if let (Some(target_actor_id), Some(viewer_actor_id)) = (target_actor_id_opt, viewer_actor_id_opt) {
+        // OPTIMIZED PATH: Use _by_id version (eliminates 3 actors JOINs!)
+        let results = crate::db::get_mutual_followers_by_id(&mut conn, target_actor_id, viewer_actor_id, parsed_cursor.as_ref(), limit).await?;
+
+        // Generate cursor
+        let cursor = results.last().map(|row| row.0.to_rfc3339());
+
+        // Batch resolve actor_ids → DIDs via IdCache
+        let actor_ids: Vec<i32> = results.iter().map(|row| row.1).collect();
+        let unique_actor_ids: std::collections::HashSet<i32> = actor_ids.iter().copied().collect();
+        let actor_ids_vec: Vec<i32> = unique_actor_ids.into_iter().collect();
+
+        // Batch resolve via IdCache
+        let cached = state.id_cache.get_actor_data_many(&actor_ids_vec).await;
+        let mut actor_id_to_did: std::collections::HashMap<i32, String> = cached
+            .into_iter()
+            .map(|(id, data)| (id, data.did))
+            .collect();
+
+        // Query DB for cache misses
+        let missing: Vec<i32> = actor_ids_vec
+            .iter()
+            .filter(|id| !actor_id_to_did.contains_key(id))
+            .copied()
+            .collect();
+
+        if !missing.is_empty() {
+            use diesel::sql_types::{Array, Integer, Text};
+            use diesel_async::RunQueryDsl;
+
+            #[derive(diesel::QueryableByName)]
+            struct ActorRow {
+                #[diesel(sql_type = Integer)]
+                id: i32,
+                #[diesel(sql_type = Text)]
+                did: String,
+            }
+
+            let db_results: Vec<ActorRow> = diesel::sql_query(
+                "SELECT id, did FROM actors WHERE id = ANY($1)"
+            )
+            .bind::<Array<Integer>, _>(&missing)
+            .load(&mut conn)
+            .await
+            .map_err(|e| {
+                Error::new(
+                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                    "DatabaseError",
+                    Some(format!("Failed to resolve known follower DIDs: {}", e)),
+                )
+            })?;
 
-    // Generate cursor
-    let cursor = results.last().map(|row| row.0.to_rfc3339());
+            for row in db_results {
+                actor_id_to_did.insert(row.id, row.did);
+            }
+        }
+
+        // Map actor_ids to DIDs, preserving order
+        let dids: Vec<String> = actor_ids
+            .into_iter()
+            .filter_map(|id| actor_id_to_did.get(&id).cloned())
+            .collect();
+
+        (cursor, dids)
+    } else {
+        // NON-OPTIMIZED PATH: Use original version with 3 actors JOINs
+        let results = crate::db::get_mutual_followers(&mut conn, &target_did, &viewer_did, parsed_cursor.as_ref(), limit).await?;
+
+        // Generate cursor
+        let cursor = results.last().map(|row| row.0.to_rfc3339());
+
+        let dids = results.iter().map(|row| row.1.clone()).collect();
+
+        (cursor, dids)
+    };
 
     // Hydrate profiles for known followers
-    let dids = results.iter().map(|row| row.1.clone()).collect();
-    let mut profiles = hyd.hydrate_profiles(dids).await;
+    let mut profiles = hyd.hydrate_profiles(dids.clone()).await;
 
     // Maintain order from query
-    let followers = results
+    let followers = dids
         .into_iter()
-        .filter_map(|row| profiles.remove(&row.1))
+        .filter_map(|did| profiles.remove(&did))
         .collect();
 
     Ok(Json(GetKnownFollowersRes {