feat: chat.bsky declarations

closes #3

consumer/src/indexer/db.rs

···
         .execute(conn)
         .await
 }
+
+pub async fn upsert_chat_decl(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    rec: records::ChatBskyActorDeclaration,
+) -> QueryResult<usize> {
+    let data = models::NewChatDecl {
+        did,
+        allow_incoming: rec.allow_incoming.to_string(),
+    };
+
+    diesel::insert_into(schema::chat_decls::table)
+        .values(&data)
+        .on_conflict(schema::chat_decls::did)
+        .do_update()
+        .set(&data)
+        .execute(conn)
+        .await
+}
+
+pub async fn delete_chat_decl(conn: &mut AsyncPgConnection, did: &str) -> QueryResult<usize> {
+    diesel::delete(schema::chat_decls::table)
+        .filter(schema::chat_decls::did.eq(did))
+        .execute(conn)
+        .await
+}

consumer/src/indexer/mod.rs

···
 
             db::insert_list_item(conn, at_uri, record).await?;
         }
+        RecordTypes::ChatBskyActorDeclaration(record) => {
+            if rkey == "self" {
+                db::upsert_chat_decl(conn, repo, record).await?;
+            }
+        }
     }
 
     Ok(())
···
         }
         CollectionType::BskyListBlock => db::delete_list_block(conn, at_uri).await?,
         CollectionType::BskyListItem => db::delete_list_item(conn, at_uri).await?,
+        CollectionType::ChatActorDecl => db::delete_chat_decl(conn, at_uri).await?,
         _ => unreachable!(),
     };
 

consumer/src/indexer/records.rs

···
 use crate::utils;
 use chrono::{DateTime, Utc};
 use ipld_core::cid::Cid;
+use lexica::app_bsky::actor::ChatAllowIncoming;
 use lexica::app_bsky::embed::AspectRatio;
 use lexica::app_bsky::richtext::FacetMain;
 use serde::{Deserialize, Serialize};
···
     pub subject: String,
     pub created_at: DateTime<Utc>,
 }
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChatBskyActorDeclaration {
+    pub allow_incoming: ChatAllowIncoming,
+}

consumer/src/indexer/types.rs

···
     AppBskyGraphListBlock(records::AppBskyGraphListBlock),
     #[serde(rename = "app.bsky.graph.listitem")]
     AppBskyGraphListItem(records::AppBskyGraphListItem),
+    #[serde(rename = "chat.bsky.actor.declaration")]
+    ChatBskyActorDeclaration(records::ChatBskyActorDeclaration),
 }
 
 #[derive(Debug, PartialOrd, PartialEq, Deserialize, Serialize)]
···
     BskyList,
     BskyListBlock,
     BskyListItem,
+    ChatActorDecl,
     Unsupported,
 }
 
···
             "app.bsky.graph.list" => CollectionType::BskyList,
             "app.bsky.graph.listblock" => CollectionType::BskyListBlock,
             "app.bsky.graph.listitem" => CollectionType::BskyListItem,
+            "chat.bsky.actor.declaration" => CollectionType::ChatActorDecl,
             _ => CollectionType::Unsupported,
         }
     }
···
             CollectionType::BskyList => true,
             CollectionType::BskyListBlock => false,
             CollectionType::BskyListItem => false,
+            CollectionType::ChatActorDecl => true,
             CollectionType::Unsupported => false,
         }
     }

lexica/src/app_bsky/actor.rs

···
+use std::str::FromStr;
 use chrono::prelude::*;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Default, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
···
     pub allow_incoming: ChatAllowIncoming,
 }
 
-#[derive(Copy, Clone, Debug, Serialize)]
+#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ChatAllowIncoming {
     All,
     None,
     Following,
+}
+
+impl ToString for ChatAllowIncoming {
+    fn to_string(&self) -> String {
+        match self {
+            ChatAllowIncoming::All => "all".into(),
+            ChatAllowIncoming::None => "none".into(),
+            ChatAllowIncoming::Following => "following".into(),
+        }
+    }
+}
+
+impl FromStr for ChatAllowIncoming {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "all" => Ok(ChatAllowIncoming::All),
+            "none" => Ok(ChatAllowIncoming::None),
+            "following" => Ok(ChatAllowIncoming::Following),
+            x => Err(format!("Unrecognized variant {}", x).into()),
+        }
+    }
 }
 
 #[derive(Clone, Debug, Serialize)]

migrations/2025-04-08-171113_chat-decl/down.sql

···
+drop table chat_decls;

migrations/2025-04-08-171113_chat-decl/up.sql

···
+create table chat_decls
+(
+    did            text primary key references actors (did),
+    allow_incoming text      not null,
+    indexed_at     timestamp not null default now()
+);

parakeet-db/src/models.rs

···
     pub post_cid: String,
     pub created_at: NaiveDateTime,
 }
+
+#[derive(Insertable, AsChangeset)]
+#[diesel(table_name = crate::schema::chat_decls)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct NewChatDecl<'a> {
+    pub did: &'a str,
+    pub allow_incoming: String,
+}

parakeet-db/src/schema.rs

···
 }
 
 diesel::table! {
+    chat_decls (did) {
+        did -> Text,
+        allow_incoming -> Text,
+        indexed_at -> Timestamp,
+    }
+}
+
+diesel::table! {
     feedgens (at_uri) {
         at_uri -> Text,
         cid -> Text,
···
 
 diesel::joinable!(backfill -> actors (repo));
 diesel::joinable!(blocks -> actors (did));
+diesel::joinable!(chat_decls -> actors (did));
 diesel::joinable!(feedgens -> actors (owner));
 diesel::joinable!(follows -> actors (did));
 diesel::joinable!(likes -> actors (did));
···
     actors,
     backfill,
     blocks,
+    chat_decls,
     feedgens,
     follow_stats,
     follows,

parakeet/src/hydration/profile.rs

···
 use crate::loaders::Dataloaders;
-use lexica::app_bsky::actor::{ProfileView, ProfileViewBasic, ProfileViewDetailed};
+use lexica::app_bsky::actor::{
+    ChatAllowIncoming, ProfileAssociated, ProfileAssociatedChat, ProfileView, ProfileViewBasic,
+    ProfileViewDetailed,
+};
 use parakeet_db::models;
 use std::collections::HashMap;
 
-fn build_basic(handle: Option<String>, profile: models::Profile) -> ProfileViewBasic {
+fn build_associated(chat: Option<ChatAllowIncoming>) -> Option<ProfileAssociated> {
+    if let Some(allow_incoming) = chat {
+        Some(ProfileAssociated {
+            lists: 0,
+            feedgens: 0,
+            starter_packs: 0,
+            labeler: false,
+            chat: Some(ProfileAssociatedChat { allow_incoming }),
+        })
+    } else {
+        None
+    }
+}
+
+fn build_basic(
+    handle: Option<String>,
+    profile: models::Profile,
+    chat_decl: Option<ChatAllowIncoming>,
+) -> ProfileViewBasic {
+    let associated = build_associated(chat_decl);
+
     ProfileViewBasic {
         did: profile.did,
         handle: handle.unwrap_or("handle.invalid".to_string()),
···
         avatar: profile
             .avatar_cid
             .map(|v| format!("https://localhost/avatar/{v}")),
-        associated: None,
+        associated,
         created_at: profile.created_at.and_utc(),
     }
 }
 
-fn build_profile(handle: Option<String>, profile: models::Profile) -> ProfileView {
+fn build_profile(
+    handle: Option<String>,
+    profile: models::Profile,
+    chat_decl: Option<ChatAllowIncoming>,
+) -> ProfileView {
+    let associated = build_associated(chat_decl);
+
     ProfileView {
         did: profile.did,
         handle: handle.unwrap_or("handle.invalid".to_string()),
···
         avatar: profile
             .avatar_cid
             .map(|v| format!("https://localhost/avatar/{v}")),
-        associated: None,
+        associated,
         created_at: profile.created_at.and_utc(),
         indexed_at: profile.indexed_at,
     }
···
     handle: Option<String>,
     profile: models::Profile,
     follow_stats: Option<models::FollowStats>,
+    chat_decl: Option<ChatAllowIncoming>,
 ) -> ProfileViewDetailed {
+    let associated = build_associated(chat_decl);
+
     ProfileViewDetailed {
         did: profile.did,
         handle: handle.unwrap_or("handle.invalid".to_string()),
···
             .as_ref()
             .map(|v| v.following as i64)
             .unwrap_or_default(),
-        associated: None,
+        associated,
         created_at: profile.created_at.and_utc(),
         indexed_at: profile.indexed_at,
     }
 }
 
 pub async fn hydrate_profile_basic(loaders: &Dataloaders, did: String) -> Option<ProfileViewBasic> {
-    let (handle, profile, _) = loaders.profile.load(did).await?;
+    let (handle, profile, _, chat_decl) = loaders.profile.load(did).await?;
 
-    Some(build_basic(handle, profile))
+    Some(build_basic(handle, profile, chat_decl))
 }
 
 pub async fn hydrate_profiles_basic(
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, _))| (k, build_basic(handle, profile)))
+        .map(|(k, (handle, profile, _, chat_decl))| (k, build_basic(handle, profile, chat_decl)))
         .collect()
 }
 
 pub async fn hydrate_profile(loaders: &Dataloaders, did: String) -> Option<ProfileView> {
-    let (handle, profile, _) = loaders.profile.load(did).await?;
+    let (handle, profile, _, chat_decl) = loaders.profile.load(did).await?;
 
-    Some(build_profile(handle, profile))
+    Some(build_profile(handle, profile, chat_decl))
 }
 
 pub async fn hydrate_profiles(
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, _))| (k, build_profile(handle, profile)))
+        .map(|(k, (handle, profile, _, chat_decl))| (k, build_profile(handle, profile, chat_decl)))
         .collect()
 }
 
···
     loaders: &Dataloaders,
     did: String,
 ) -> Option<ProfileViewDetailed> {
-    let (handle, profile, follow_stats) = loaders.profile.load(did).await?;
+    let (handle, profile, follow_stats, chat_decl) = loaders.profile.load(did).await?;
 
-    Some(build_detailed(handle, profile, follow_stats))
+    Some(build_detailed(handle, profile, follow_stats, chat_decl))
 }
 
 pub async fn hydrate_profiles_detailed(
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, follow_stats))| {
-            (k, build_detailed(handle, profile, follow_stats))
+        .map(|(k, (handle, profile, follow_stats, chat_decl))| {
+            (k, build_detailed(handle, profile, follow_stats, chat_decl))
         })
         .collect()
 }

parakeet/src/loaders.rs

···
 use itertools::Itertools;
 use parakeet_db::{models, schema};
 use std::collections::HashMap;
+use std::str::FromStr;
+use lexica::app_bsky::actor::ChatAllowIncoming;
 
 pub struct Dataloaders {
     pub embed: Loader<String, EmbedLoaderRet, EmbedLoader>,
···
 }
 
 pub struct ProfileLoader(Pool<AsyncPgConnection>);
-type ProfileLoaderRet = (Option<String>, models::Profile, Option<models::FollowStats>);
+type ProfileLoaderRet = (Option<String>, models::Profile, Option<models::FollowStats>, Option<ChatAllowIncoming>);
 impl BatchFn<String, ProfileLoaderRet> for ProfileLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, ProfileLoaderRet> {
         let mut conn = self.0.get().await.unwrap();
···
             .left_join(
                 schema::follow_stats::table.on(schema::follow_stats::did.eq(schema::actors::did)),
             )
+            .left_join(schema::chat_decls::table.on(schema::chat_decls::did.eq(schema::actors::did)))
             .select((
                 schema::actors::did,
                 schema::actors::handle,
                 models::Profile::as_select(),
                 Option::<models::FollowStats>::as_select(),
+                schema::chat_decls::allow_incoming.nullable(),
             ))
             .filter(schema::actors::did.eq_any(keys))
             .load::<(
···
                 Option<String>,
                 models::Profile,
                 Option<models::FollowStats>,
+                Option<String>,
             )>(&mut conn)
             .await;
 
         match res {
             Ok(res) => {
-                HashMap::from_iter(res.into_iter().map(|(did, handle, profile, follow_stats)| {
-                    (did, (handle, profile, follow_stats))
+                HashMap::from_iter(res.into_iter().map(|(did, handle, profile, follow_stats, chat_decl)| {
+                    let chat_decl = chat_decl.and_then(|v| ChatAllowIncoming::from_str(&v).ok());
+
+                    (did, (handle, profile, follow_stats, chat_decl))
                 }))
             }
             Err(e) => {