feat(hack): failover api; remove preference endpoints

lexica/src/app_bsky/actor.rs

···
 use std::fmt::Display;
 use std::str::FromStr;
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileViewerState {
     pub muted: bool,
···
     // pub activity_subscriptions: Option<()>,
 }
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileAssociated {
-    pub lists: i64,
-    pub feedgens: i64,
-    pub starter_packs: i64,
-    pub labeler: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lists: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub feedgens: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub starter_packs: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub labeler: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub chat: Option<ProfileAssociatedChat>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub activity_subscription: Option<ProfileAssociatedActivitySubscription>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileAssociatedChat {
     pub allow_incoming: ChatAllowIncoming,
···
     }
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileAssociatedActivitySubscription {
     pub allow_subscriptions: ProfileAllowSubscriptions,
···
     }
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileViewBasic {
     pub did: String,
···
     pub created_at: DateTime<Utc>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileView {
     pub did: String,
···
     pub indexed_at: NaiveDateTime,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileViewDetailed {
     pub did: String,
···
     pub indexed_at: NaiveDateTime,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct VerificationView {
     pub issuer: String,
···
     pub created_at: DateTime<Utc>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct VerificationState {
     pub verifications: Vec<VerificationView>,
···
     None,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StatusView {
     pub status: Status,
···
     pub is_active: Option<bool>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "$type")]
 #[serde(rename = "app.bsky.embed.external#view")]
 pub struct StatusViewEmbed {

lexica/src/app_bsky/embed.rs

···
     pub height: i32,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "$type")]
 pub enum Embed {
     #[serde(rename = "app.bsky.embed.images#view")]
···
         media: Box<Embed>,
     },
 }
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ImageView {
     pub thumb: String,
···
     pub aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct VideoView {
     pub cid: String,
···
     pub aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct External {
     pub uri: String,
···
     pub thumb: Option<String>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "$type")]
 pub enum RecordViewInner {
     #[serde(rename = "app.bsky.embed.record#viewRecord")]
···
     // StaterPackView()
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RecordView {
     pub uri: String,
···
     pub indexed_at: DateTime<Utc>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RecordWrapper {
     pub record: RecordViewInner,
 }

lexica/src/app_bsky/feed.rs

···
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PostViewerState {
     #[serde(skip_serializing_if = "Option::is_none")]
···
     pub pinned: bool,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PostView {
     pub uri: String,
···
     pub indexed_at: DateTime<Utc>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FeedViewPost {
     pub post: PostView,
···
     pub feed_context: Option<String>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ReplyRef {
     pub root: ReplyRefPost,
···
     pub grandparent_author: Option<ProfileViewBasic>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "$type")]
 pub enum ReplyRefPost {
     #[serde(rename = "app.bsky.feed.defs#postView")]
···
     },
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "$type")]
 pub enum FeedViewPostReason {
     #[serde(rename = "app.bsky.feed.defs#reasonRepost")]
···
     Pin,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FeedReasonRepost {
     pub by: ProfileViewBasic,
···
     },
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct BlockedAuthor {
     pub did: String,
     pub viewer: Option<ProfileViewerState>,
 }
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GeneratorViewerState {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub like: Option<String>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GeneratorView {
     pub uri: String,
···
     pub indexed_at: DateTime<Utc>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 pub enum GeneratorContentMode {
     #[serde(rename = "app.bsky.feed.defs#contentModeUnspecified")]
     Unspecified,
···
     }
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ThreadgateView {
     pub uri: String,
     pub cid: String,

lexica/src/app_bsky/graph.rs

···
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListViewerState {
     pub muted: bool,
···
     pub blocked: Option<String>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListViewBasic {
     pub uri: String,
···
     pub indexed_at: DateTime<Utc>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListView {
     pub uri: String,

lexica/src/app_bsky/labeler.rs

···
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LabelerViewerState {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub like: Option<String>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LabelerView {
     pub uri: String,

lexica/src/app_bsky/mod.rs

···
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 pub mod actor;
 pub mod bookmark;
···
 pub mod richtext;
 pub mod unspecced;
 
-#[derive(Clone, Default, Debug, Serialize)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RecordStats {
     pub reply_count: i64,

lexica/src/com_atproto/label.rs

···
     pub val: String,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Label {
     pub ver: i32,
     pub src: String,

lexica/src/lib.rs

···
 pub mod community_lexicon;
 mod utils;
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct JsonBytes {
     #[serde(rename = "$bytes")]
     pub bytes: String,

parakeet/src/hydration/posts.rs

···
         let threadgate = threadgate?;
 
         let lists = match threadgate.allowed_lists.as_ref() {
-            Some(allowed_lists) => allowed_lists.iter().cloned().collect(),
+            Some(allowed_lists) => allowed_lists.to_vec(),
             None => Vec::new(),
         };
         let lists = self.hydrate_lists_basic(lists).await;

parakeet/src/hydration/profile.rs

···
         let stats = stats.unwrap_or_default();
 
         Some(ProfileAssociated {
-            lists: stats.lists as i64,
-            feedgens: stats.feeds as i64,
-            starter_packs: stats.starterpacks as i64,
-            labeler,
+            lists: Some(stats.lists as i64),
+            feedgens: Some(stats.feeds as i64),
+            starter_packs: Some(stats.starterpacks as i64),
+            labeler: Some(labeler),
             chat: chat.map(|v| ProfileAssociatedChat { allow_incoming: v }),
             activity_subscription: notif.map(|v| ProfileAssociatedActivitySubscription {
                 allow_subscriptions: v,

parakeet/src/xrpc/app_bsky/actor.rs

···
 use axum::extract::{Query, State};
 use axum::Json;
 use axum_extra::extract::Query as ExtraQuery;
+use chrono::{DateTime, NaiveDateTime, Utc};
 use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
 use lexica::app_bsky::actor::ProfileViewDetailed;
···
     maybe_auth: Option<AtpAuth>,
     Query(query): Query<ActorQuery>,
 ) -> XrpcResult<Json<ProfileViewDetailed>> {
-    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, maybe_auth);
+    let hyd = StatefulHydrator::new(
+        &state.dataloaders,
+        &state.cdn,
+        &labelers,
+        maybe_auth.clone(),
+    );
 
-    let did = get_actor_did(&state.dataloaders, query.actor).await?;
+    // Try to get the profile from our database first
+    match get_actor_did(&state.dataloaders, query.actor.clone()).await {
+        Ok(did) => {
+            // We found the DID, check if it's valid in our system
+            let mut conn = state.pool.get().await?;
 
-    let mut conn = state.pool.get().await?;
-    check_actor_status(&mut conn, &did).await?;
+            if check_actor_status(&mut conn, &did).await.is_err() {
+                tracing::info!(
+                    "Actor status check failed for {}, falling back to public API",
+                    query.actor
+                );
+                return fallback_to_public_api(&query.actor).await;
+            }
 
-    let maybe_profile = hyd.hydrate_profile_detailed(did).await;
+            // Try to hydrate the profile from our data
+            if let Some(profile) = hyd.hydrate_profile_detailed(did).await {
+                return Ok(Json(profile));
+            }
 
-    match maybe_profile {
-        Some(profile) => Ok(Json(profile)),
-        None => Err(Error::not_found()),
+            // Profile hydration failed, fall back to public API
+            tracing::info!(
+                "Failed to hydrate profile for {}, falling back to public API",
+                query.actor
+            );
+            fallback_to_public_api(&query.actor).await
+        }
+        Err(_) => {
+            // Couldn't resolve the DID, fall back to public API
+            tracing::info!(
+                "DID not found for {}, falling back to public API",
+                query.actor
+            );
+            fallback_to_public_api(&query.actor).await
+        }
+    }
+}
+
+// Helper function for falling back to the public API
+async fn fallback_to_public_api(actor: &str) -> XrpcResult<Json<ProfileViewDetailed>> {
+    tracing::info!("Fetching profile for {} from public API", actor);
+
+    // Make the request to the public Bluesky API
+    let client = reqwest::Client::new();
+    let url = format!(
+        "https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor={}",
+        actor
+    );
+
+    match client.get(&url).send().await {
+        Ok(response) => {
+            if response.status().is_success() {
+                match response.text().await {
+                    Ok(json_text) => {
+                        match serde_json::from_str::<ProfileViewDetailed>(&json_text) {
+                            Ok(profile) => {
+                                tracing::info!("Successfully deserialized profile from public API");
+                                return Ok(Json(profile));
+                            }
+                            Err(e) => {
+                                tracing::error!(
+                                    "Failed to deserialize profile from public API: {}",
+                                    e
+                                );
+                                tracing::debug!("Response JSON: {}", json_text);
+
+                                // Try to extract the essential fields manually
+                                match serde_json::from_str::<serde_json::Value>(&json_text) {
+                                    Ok(json_value) => {
+                                        tracing::info!(
+                                            "Attempting to manually construct profile from JSON"
+                                        );
+                                        let profile = manual_construct_profile(json_value);
+                                        return Ok(Json(profile));
+                                    }
+                                    Err(_) => {
+                                        return Err(Error::not_found());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        tracing::error!("Failed to get response text: {}", e);
+                        return Err(Error::not_found());
+                    }
+                }
+            }
+            Err(Error::not_found())
+        }
+        Err(e) => {
+            tracing::error!("Request to public API failed: {}", e);
+            Err(Error::not_found())
+        }
     }
 }
 
···
     profiles: Vec<ProfileViewDetailed>,
 }
 
+// Helper function to manually construct ProfileViewDetailed from JSON
+fn manual_construct_profile(json: serde_json::Value) -> ProfileViewDetailed {
+    use chrono::prelude::*;
+
+    // Extract values with defaults for required fields
+    let did = json
+        .get("did")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let handle = json
+        .get("handle")
+        .and_then(|v| v.as_str())
+        .unwrap_or("handle.invalid")
+        .to_string();
+
+    // Optional fields
+    let display_name = json
+        .get("displayName")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    let description = json
+        .get("description")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    let avatar = json
+        .get("avatar")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    let banner = json
+        .get("banner")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+
+    // Count fields with defaults
+    let followers_count = json
+        .get("followersCount")
+        .and_then(|v| v.as_i64())
+        .unwrap_or(0);
+    let follows_count = json
+        .get("followsCount")
+        .and_then(|v| v.as_i64())
+        .unwrap_or(0);
+    let posts_count = json.get("postsCount").and_then(|v| v.as_i64()).unwrap_or(0);
+
+    // We'll create an empty associated for now
+    let associated = None;
+
+    // Empty vectors for labels
+    let labels = Vec::new();
+
+    // Parse dates
+    let created_at = json
+        .get("createdAt")
+        .and_then(|v| v.as_str())
+        .and_then(|s| DateTime::parse_from_rfc3339(s).ok())
+        .map(|dt| dt.with_timezone(&Utc))
+        .unwrap_or_else(Utc::now);
+
+    let indexed_at_str = json.get("indexedAt").and_then(|v| v.as_str());
+    let indexed_at = match indexed_at_str {
+        Some(s) => match DateTime::parse_from_rfc3339(s) {
+            Ok(dt) => DateTime::from_timestamp(dt.timestamp(), 0)
+                .unwrap_or(Utc::now())
+                .naive_utc(),
+            Err(_) => Utc::now().naive_utc(),
+        },
+        None => Utc::now().naive_utc(),
+    };
+
+    ProfileViewDetailed {
+        did,
+        handle,
+        display_name,
+        description,
+        avatar,
+        banner,
+        followers_count,
+        follows_count,
+        posts_count,
+        associated,
+        viewer: None,
+        labels,
+        verification: None,
+        status: None,
+        pronouns: None,
+        website: None,
+        created_at,
+        indexed_at,
+    }
+}
+
 pub async fn get_profiles(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(labelers): AtpAcceptLabelers,
···
 
     Ok(Json(GetProfilesRes { profiles }))
 }
-
-#[derive(Debug, Serialize)]
-pub struct GetPreferencesRes {
-    preferences: Vec<Value>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct PutPreferencesReq {
-    preferences: Vec<Value>,
-}
-
-pub async fn get_preferences(
-    auth: AtpAuth,
-    State(state): State<GlobalState>,
-) -> XrpcResult<Json<GetPreferencesRes>> {
-    let prefs_str = "{\"$type\":\"app.bsky.actor.defs#savedFeedsPrefV2\",\"items\":[{\"id\":\"3lzwjjbwm4226\",\"type\":\"timeline\",\"value\":\"following\",\"pinned\":true}]}";
-
-    return Ok(Json(GetPreferencesRes {
-        preferences: vec![serde_json::from_str(prefs_str).unwrap()],
-    }));
-
-    let did = &auth.0;
-    let mut conn = state.pool.get().await?;
-
-    // Get preferences from database
-    let profile = schema::profiles::table
-        .filter(schema::profiles::did.eq(did))
-        .select(schema::profiles::preferences)
-        .first::<Option<String>>(&mut conn)
-        .await
-        .optional()?
-        .flatten();
-
-    // If preferences exist and can be parsed, return them
-    if let Some(prefs_str) = profile {
-        if let Ok(prefs) = serde_json::from_str::<Vec<Value>>(&prefs_str) {
-            return Ok(Json(GetPreferencesRes { preferences: prefs }));
-        }
-    }
-
-    // Return empty preferences if none found or parsing failed
-    Ok(Json(GetPreferencesRes {
-        preferences: vec![],
-    }))
-}
-
-pub async fn put_preferences(
-    auth: AtpAuth,
-    State(state): State<GlobalState>,
-    Json(req): Json<PutPreferencesReq>,
-) -> XrpcResult<()> {
-    let did = &auth.0;
-    let mut conn = state.pool.get().await?;
-
-    // Serialize the preferences array to string
-    let prefs_str = serde_json::to_string(&req.preferences)
-        .map_err(|_| Error::invalid_request(Some("Invalid preferences format".to_string())))?;
-
-    // Update the database with new preferences
-    diesel::update(schema::profiles::table)
-        .filter(schema::profiles::did.eq(did))
-        .set(schema::profiles::preferences.eq(prefs_str))
-        .execute(&mut conn)
-        .await
-        .map_err(|e| {
-            eprintln!("Database error: {}", e);
-            Error::server_error(Some("Failed to update preferences"))
-        })?;
-    Ok(())
-}

parakeet/src/xrpc/app_bsky/feed/posts.rs

···
 
 const FEEDGEN_SERVICE_ID: &str = "#bsky_fg";
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct FeedRes {
     #[serde(skip_serializing_if = "Option::is_none")]
     cursor: Option<String>,
···
 ) -> XrpcResult<Json<FeedRes>> {
     let mut conn = state.pool.get().await?;
 
-    let did = get_actor_did(&state.dataloaders, query.actor.clone()).await?;
+    // Try to get the DID from our database
+    match get_actor_did(&state.dataloaders, query.actor.clone()).await {
+        Ok(did) => {
+            // Check if the actor status is valid
+            if check_actor_status(&mut conn, &did).await.is_err() {
+                tracing::info!(
+                    "Actor status check failed for {}, falling back to public API",
+                    query.actor
+                );
+                return fallback_to_public_api(&query).await;
+            }
 
-    check_actor_status(&mut conn, &did).await?;
+            // check if we block the actor or if they block us
+            if let Some(auth) = &maybe_auth {
+                if let Some(psr) = crate::db::get_profile_state(&mut conn, &auth.0, &did).await? {
+                    if psr.blocked.unwrap_or_default() {
+                        // they block us
+                        return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedByActor", None));
+                    } else if psr.blocking.is_some() {
+                        // we block them
+                        return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedActor", None));
+                    }
+                }
+            }
+
+            let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, maybe_auth);
+
+            let pin = match query.include_pins && query.cursor.is_none() {
+                false => None,
+                true => match crate::db::get_pinned_post_uri(&mut conn, &did).await? {
+                    Some(post) => hyd.hydrate_post(post).await,
+                    None => None,
+                },
+            };
+
+            let limit = query.limit.unwrap_or(50).clamp(1, 100);
+
+            let mut posts_query = schema::author_feeds::table
+                .select(models::AuthorFeedItem::as_select())
+                .left_join(
+                    schema::posts::table.on(schema::posts::at_uri.eq(schema::author_feeds::post)),
+                )
+                .filter(schema::author_feeds::did.eq(&did))
+                .into_boxed();
 
-    // check if we block the actor or if they block us
-    if let Some(auth) = &maybe_auth {
-        if let Some(psr) = crate::db::get_profile_state(&mut conn, &auth.0, &did).await? {
-            if psr.blocked.unwrap_or_default() {
-                // they block us
-                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedByActor", None));
-            } else if psr.blocking.is_some() {
-                // we block them
-                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedActor", None));
+            if let Some(cursor) = datetime_cursor(query.cursor.as_ref()) {
+                posts_query = posts_query.filter(schema::author_feeds::sort_at.lt(cursor));
             }
-        }
-    }
 
-    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, maybe_auth);
+            posts_query = match query.filter {
+                GetAuthorFeedFilter::PostsWithReplies => {
+                    posts_query.filter(schema::author_feeds::typ.eq("post"))
+                }
+                GetAuthorFeedFilter::PostsNoReplies => {
+                    posts_query.filter(schema::posts::parent_uri.is_null())
+                }
+                GetAuthorFeedFilter::PostsWithMedia => posts_query.filter(
+                    embed_type_filter(&["app.bsky.embed.video", "app.bsky.embed.images"])
+                        .and(schema::author_feeds::typ.eq("post")),
+                ),
+                GetAuthorFeedFilter::PostsAndAuthorThreads => posts_query.filter(
+                    (schema::posts::parent_uri
+                        .like(format!("at://{did}/%"))
+                        .or(schema::posts::parent_uri.is_null()))
+                    .and(
+                        schema::posts::root_uri
+                            .like(format!("at://{did}/%"))
+                            .or(schema::posts::root_uri.is_null()),
+                    ),
+                ),
+                GetAuthorFeedFilter::PostsWithVideo => posts_query.filter(
+                    embed_type_filter(&["app.bsky.embed.video"])
+                        .and(schema::author_feeds::typ.eq("post")),
+                ),
+            };
 
-    let pin = match query.include_pins && query.cursor.is_none() {
-        false => None,
-        true => match crate::db::get_pinned_post_uri(&mut conn, &did).await? {
-            Some(post) => hyd.hydrate_post(post).await,
-            None => None,
-        },
-    };
+            let results = posts_query
+                .order(schema::author_feeds::sort_at.desc())
+                .limit(limit as i64)
+                .load(&mut conn)
+                .await?;
 
-    let limit = query.limit.unwrap_or(50).clamp(1, 100);
+            let cursor = results
+                .last()
+                .map(|item| item.sort_at.timestamp_millis().to_string());
+
+            let at_uris = results
+                .iter()
+                .map(|item| item.post.clone())
+                .collect::<Vec<_>>();
+
+            // get the actor for if we have reposted
+            let profile = hyd
+                .hydrate_profile_basic(did)
+                .await
+                .ok_or(Error::server_error(None))?;
+
+            let mut posts = hyd.hydrate_feed_posts(at_uris).await;
 
-    let mut posts_query = schema::author_feeds::table
-        .select(models::AuthorFeedItem::as_select())
-        .left_join(schema::posts::table.on(schema::posts::at_uri.eq(schema::author_feeds::post)))
-        .filter(schema::author_feeds::did.eq(&did))
-        .into_boxed();
+            let mut feed: Vec<_> = results
+                .into_iter()
+                .filter_map(|item| {
+                    posts.remove(&item.post).map(|mut fvp| {
+                        if item.typ == "repost" {
+                            fvp.reason = Some(FeedViewPostReason::Repost(FeedReasonRepost {
+                                by: profile.clone(),
+                                uri: Some(item.uri),
+                                cid: Some(item.cid),
+                                indexed_at: Default::default(),
+                            }))
+                        }
+                        fvp
+                    })
+                })
+                .collect();
 
-    if let Some(cursor) = datetime_cursor(query.cursor.as_ref()) {
-        posts_query = posts_query.filter(schema::author_feeds::sort_at.lt(cursor));
-    }
+            if let Some(post) = pin {
+                feed.insert(
+                    0,
+                    FeedViewPost {
+                        post,
+                        reply: None,
+                        reason: Some(FeedViewPostReason::Pin),
+                        feed_context: None,
+                    },
+                );
+            }
 
-    posts_query = match query.filter {
-        GetAuthorFeedFilter::PostsWithReplies => {
-            posts_query.filter(schema::author_feeds::typ.eq("post"))
+            Ok(Json(FeedRes { cursor, feed }))
         }
-        GetAuthorFeedFilter::PostsNoReplies => {
-            posts_query.filter(schema::posts::parent_uri.is_null())
+        Err(_) => {
+            // Couldn't resolve the DID, fall back to public API
+            tracing::info!(
+                "DID not found for {}, falling back to public API",
+                query.actor
+            );
+            fallback_to_public_api(&query).await
         }
-        GetAuthorFeedFilter::PostsWithMedia => posts_query.filter(
-            embed_type_filter(&["app.bsky.embed.video", "app.bsky.embed.images"])
-                .and(schema::author_feeds::typ.eq("post")),
-        ),
-        GetAuthorFeedFilter::PostsAndAuthorThreads => posts_query.filter(
-            (schema::posts::parent_uri
-                .like(format!("at://{did}/%"))
-                .or(schema::posts::parent_uri.is_null()))
-            .and(
-                schema::posts::root_uri
-                    .like(format!("at://{did}/%"))
-                    .or(schema::posts::root_uri.is_null()),
-            ),
-        ),
-        GetAuthorFeedFilter::PostsWithVideo => posts_query.filter(
-            embed_type_filter(&["app.bsky.embed.video"]).and(schema::author_feeds::typ.eq("post")),
-        ),
+    }
+}
+
+// Helper function to fetch author feed from the public API
+async fn fallback_to_public_api(query: &GetAuthorFeedQuery) -> XrpcResult<Json<FeedRes>> {
+    tracing::info!("Fetching author feed for {} from public API", query.actor);
+
+    // Build the URL with the appropriate parameters
+    let client = reqwest::Client::new();
+    let mut url = format!(
+        "https://public.api.bsky.app/xrpc/app.bsky.feed.getAuthorFeed?actor={}",
+        query.actor
+    );
+
+    // Add optional parameters
+    if let Some(limit) = query.limit {
+        url.push_str(&format!("&limit={}", limit));
+    }
+    if let Some(cursor) = &query.cursor {
+        url.push_str(&format!("&cursor={}", cursor));
+    }
+
+    // Add filter parameter
+    let filter = match query.filter {
+        GetAuthorFeedFilter::PostsWithReplies => "posts_with_replies",
+        GetAuthorFeedFilter::PostsNoReplies => "posts_no_replies",
+        GetAuthorFeedFilter::PostsWithMedia => "posts_with_media",
+        GetAuthorFeedFilter::PostsAndAuthorThreads => "posts_and_author_threads",
+        GetAuthorFeedFilter::PostsWithVideo => "posts_with_video",
     };
+    url.push_str(&format!("&filter={}", filter));
 
-    let results = posts_query
-        .order(schema::author_feeds::sort_at.desc())
-        .limit(limit as i64)
-        .load(&mut conn)
-        .await?;
+    // Add includePins parameter
+    url.push_str(&format!("&includePins={}", query.include_pins));
 
-    let cursor = results
-        .last()
-        .map(|item| item.sort_at.timestamp_millis().to_string());
+    // Make the request
+    match client.get(&url).send().await {
+        Ok(response) => {
+            if response.status().is_success() {
+                // Parse the JSON response
+                match response.text().await {
+                    Ok(text) => {
+                        tracing::info!("Successfully fetched author feed from public API");
 
-    let at_uris = results
-        .iter()
-        .map(|item| item.post.clone())
-        .collect::<Vec<_>>();
+                        // First parse as generic JSON to get the cursor
+                        let json_response: serde_json::Value = serde_json::from_str(&text)
+                            .map_err(|e| {
+                                tracing::error!("Failed to parse response as JSON: {}", e);
+                                Error::not_found()
+                            })?;
 
-    // get the actor for if we have reposted
-    let profile = hyd
-        .hydrate_profile_basic(did)
-        .await
-        .ok_or(Error::server_error(None))?;
+                        tracing::debug!("Response: {:?}", json_response);
 
-    let mut posts = hyd.hydrate_feed_posts(at_uris).await;
+                        // Parse the feed field and return it
+                        let response_struct: FeedRes =
+                            serde_json::from_str(&text).map_err(|e| {
+                                tracing::error!("Failed to deserialize feed: {}", e);
+                                Error::not_found()
+                            })?;
 
-    let mut feed: Vec<_> = results
-        .into_iter()
-        .filter_map(|item| {
-            posts.remove(&item.post).map(|mut fvp| {
-                if item.typ == "repost" {
-                    fvp.reason = Some(FeedViewPostReason::Repost(FeedReasonRepost {
-                        by: profile.clone(),
-                        uri: Some(item.uri),
-                        cid: Some(item.cid),
-                        indexed_at: Default::default(),
-                    }))
+                        Ok(Json(response_struct))
+                    }
+                    Err(e) => {
+                        tracing::error!("Failed to parse response from public API: {}", e);
+                        Err(Error::not_found())
+                    }
                 }
-                fvp
-            })
-        })
-        .collect();
-
-    if let Some(post) = pin {
-        feed.insert(
-            0,
-            FeedViewPost {
-                post,
-                reply: None,
-                reason: Some(FeedViewPostReason::Pin),
-                feed_context: None,
-            },
-        );
+            } else {
+                tracing::error!("Public API returned status {}", response.status());
+                Err(Error::not_found())
+            }
+        }
+        Err(e) => {
+            tracing::error!("Request to public API failed: {}", e);
+            Err(Error::not_found())
+        }
     }
-
-    Ok(Json(FeedRes { cursor, feed }))
 }
 
 // While fixing inactive accounts, i noticed that you can still call this endpoint for a list on an
···
                 not_found: true,
             });
 
-        root_parent = Some(parent);
+        root_parent = Some(Box::new(parent));
     }
 
     let replies = tmpbuf.remove(&root.uri).unwrap_or_default();
···
         threadgate,
         thread: ThreadViewPostType::Post(Box::new(ThreadViewPost {
             post: root,
-            parent: root_parent,
+            parent: root_parent.map(|boxed| *boxed),
             replies,
         })),
     }))
···
 
 fn postview_to_tvpt(
     post: PostView,
-    parent: Option<ThreadViewPostType>,
+    parent: Option<Box<ThreadViewPostType>>,
     replies: Vec<ThreadViewPostType>,
 ) -> ThreadViewPostType {
     match &post.author.viewer {
···
         },
         _ => ThreadViewPostType::Post(Box::new(ThreadViewPost {
             post,
-            parent,
+            parent: parent.map(|boxed| *boxed),
             replies,
         })),
     }

parakeet/src/xrpc/app_bsky/mod.rs

···
 #[rustfmt::skip]
 pub fn routes() -> Router<crate::GlobalState> {
     Router::new()
-        .route("/app.bsky.actor.getPreferences", get(actor::get_preferences))
-        .route("/app.bsky.actor.putPreferences", post(actor::put_preferences))
+        // .route("/app.bsky.actor.getPreferences", get(actor::get_preferences))
+        // .route("/app.bsky.actor.putPreferences", post(actor::put_preferences))
         .route("/app.bsky.actor.getProfile", get(actor::get_profile))
         .route("/app.bsky.actor.getProfiles", get(actor::get_profiles))
         // TODO: app.bsky.actor.getSuggestions (recs)