feat(parakeet): getBlocks and getListBlocks

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

···
         lists: mutes,
     }))
 }
+
+pub async fn get_list_blocks(
+    State(state): State<GlobalState>,
+    AtpAcceptLabelers(labelers): AtpAcceptLabelers,
+    auth: AtpAuth,
+    Query(query): Query<CursorQuery>,
+) -> XrpcResult<Json<GetListMutesRes>> {
+    let mut conn = state.pool.get().await?;
+    let did = auth.0.clone();
+    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, Some(auth));
+
+    let limit = query.limit.unwrap_or(50).clamp(1, 100);
+
+    let mut blocks_query = schema::list_blocks::table
+        .select((schema::list_blocks::created_at, schema::list_blocks::list_uri))
+        .filter(schema::list_blocks::did.eq(did))
+        .into_boxed();
+
+    if let Some(cursor) = datetime_cursor(query.cursor.as_ref()) {
+        blocks_query = blocks_query.filter(schema::list_blocks::created_at.lt(cursor));
+    }
+
+    let results = blocks_query
+        .order(schema::list_blocks::created_at.desc())
+        .limit(limit as i64)
+        .load::<(chrono::DateTime<chrono::Utc>, String)>(&mut conn)
+        .await?;
+
+    let cursor = results
+        .last()
+        .map(|(last, _)| last.timestamp_millis().to_string());
+
+    let uris = results.iter().map(|(_, uri)| uri.clone()).collect();
+
+    let lists = hyd.hydrate_lists(uris).await;
+    let lists = lists.into_values().collect::<Vec<_>>();
+
+    Ok(Json(GetListMutesRes {
+        cursor,
+        lists,
+    }))
+}

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

···
 use crate::hydration::StatefulHydrator;
 use crate::xrpc::error::{Error, XrpcResult};
 use crate::xrpc::extract::{AtpAcceptLabelers, AtpAuth};
-use crate::xrpc::{datetime_cursor, get_actor_did, ActorWithCursorQuery};
+use crate::xrpc::{datetime_cursor, get_actor_did, ActorWithCursorQuery, CursorQuery};
 use crate::GlobalState;
 use axum::extract::{Query, State};
 use axum::Json;
···
 use lexica::app_bsky::actor::ProfileView;
 use parakeet_db::schema;
 use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct GetBlocksRes {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    cursor: Option<String>,
+    blocks: Vec<ProfileView>,
+}
+
+pub async fn get_blocks(
+    State(state): State<GlobalState>,
+    AtpAcceptLabelers(labelers): AtpAcceptLabelers,
+    auth: AtpAuth,
+    Query(query): Query<CursorQuery>,
+) -> XrpcResult<Json<GetBlocksRes>> {
+    let mut conn = state.pool.get().await?;
+    let did = auth.0.clone();
+    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, Some(auth));
+
+    let limit = query.limit.unwrap_or(50).clamp(1, 100);
+
+    let mut blocked_query = schema::blocks::table
+        .select((schema::blocks::created_at, schema::blocks::subject))
+        .filter(schema::blocks::did.eq(did))
+        .into_boxed();
+
+    if let Some(cursor) = datetime_cursor(query.cursor.as_ref()) {
+        blocked_query = blocked_query.filter(schema::blocks::created_at.lt(cursor));
+    }
+
+    let results = blocked_query
+        .order(schema::blocks::created_at.desc())
+        .limit(limit as i64)
+        .load::<(chrono::DateTime<chrono::Utc>, String)>(&mut conn)
+        .await?;
+
+    let cursor = results
+        .last()
+        .map(|(last, _)| last.timestamp_millis().to_string());
+
+    let dids = results.iter().map(|(_, did)| did.clone()).collect();
+    
+    let profiles = hyd.hydrate_profiles(dids).await;
+    let blocks = profiles.into_values().collect::<Vec<_>>();
+
+    Ok(Json(GetBlocksRes { cursor, blocks }))
+}
 
 #[derive(Debug, Serialize)]
 pub struct AppBskyGraphGetFollowersRes {

parakeet/src/xrpc/app_bsky/mod.rs

···
         // TODO: app.bsky.feed.getTimeline (complicated)
         // TODO: app.bsky.feed.searchPosts (search)
         .route("/app.bsky.graph.getActorStarterPacks", get(graph::starter_packs::get_actor_starter_packs))
-        // TODO: app.bsky.graph.getBlocks
+        .route("/app.bsky.graph.getBlocks", get(graph::relations::get_blocks))
         .route("/app.bsky.graph.getFollowers", get(graph::relations::get_followers))
         .route("/app.bsky.graph.getFollows", get(graph::relations::get_follows))
         // TODO: app.bsky.graph.getKnownFollowers
         .route("/app.bsky.graph.getList", get(graph::lists::get_list))
-        // TODO: app.bsky.graph.getListBlocks
+        .route("/app.bsky.graph.getListBlocks", get(graph::lists::get_list_blocks))
         .route("/app.bsky.graph.getListMutes", get(graph::lists::get_list_mutes))
         .route("/app.bsky.graph.getLists", get(graph::lists::get_lists))
         .route("/app.bsky.graph.getMutes", get(graph::mutes::get_mutes))