feat: app.bsky.notification.declaration

consumer/src/db/record.rs

···
         .await
 }
 
+pub async fn notif_decl_upsert<C: GenericClient>(
+    conn: &mut C,
+    repo: &str,
+    rec: AppBskyNotificationDeclaration,
+) -> PgExecResult {
+    conn.execute(
+        "INSERT INTO notif_decl (did, allow_subscriptions) VALUES ($1, $2) ON CONFLICT (did) DO UPDATE SET allow_subscriptions=EXCLUDED.allow_subscriptions",
+        &[&repo, &rec.allow_subscriptions.to_string()],
+    ).await
+}
+
+pub async fn notif_decl_delete<C: GenericClient>(conn: &mut C, repo: &str) -> PgExecResult {
+    conn.execute("DELETE FROM notif_decl WHERE did=$1", &[&repo])
+        .await
+}
+
 pub async fn post_insert<C: GenericClient>(
     conn: &mut C,
     at_uri: &str,

consumer/src/indexer/mod.rs

···
                 }
             }
         }
+        RecordTypes::AppBskyNotificationDeclaration(record) => {
+            if rkey == "self" {
+                db::notif_decl_upsert(conn, repo, record).await?;
+            }
+        }
         RecordTypes::ChatBskyActorDeclaration(record) => {
             if rkey == "self" {
                 db::chat_decl_upsert(conn, repo, record).await?;
···
         }
         CollectionType::BskyVerification => db::verification_delete(conn, at_uri).await?,
         CollectionType::BskyLabelerService => db::labeler_delete(conn, at_uri).await?,
+        CollectionType::BskyNotificationDeclaration => db::notif_decl_delete(conn, repo).await?,
         CollectionType::ChatActorDecl => db::chat_decl_delete(conn, repo).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, Status};
+use lexica::app_bsky::actor::{ChatAllowIncoming, ProfileAllowSubscriptions, Status};
 use lexica::app_bsky::embed::AspectRatio;
 use lexica::app_bsky::labeler::LabelerPolicy;
 use lexica::app_bsky::richtext::FacetMain;
···
     pub subject_types: Option<Vec<SubjectType>>,
     pub subject_collections: Option<Vec<String>>,
     pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppBskyNotificationDeclaration {
+    pub allow_subscriptions: ProfileAllowSubscriptions,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

consumer/src/indexer/types.rs

···
     AppBskyGraphVerification(records::AppBskyGraphVerification),
     #[serde(rename = "app.bsky.labeler.service")]
     AppBskyLabelerService(records::AppBskyLabelerService),
+    #[serde(rename = "app.bsky.notification.declaration")]
+    AppBskyNotificationDeclaration(records::AppBskyNotificationDeclaration),
     #[serde(rename = "chat.bsky.actor.declaration")]
     ChatBskyActorDeclaration(records::ChatBskyActorDeclaration),
 }
···
     BskyStarterPack,
     BskyVerification,
     BskyLabelerService,
+    BskyNotificationDeclaration,
     ChatActorDecl,
     Unsupported,
 }
···
             "app.bsky.graph.starterpack" => CollectionType::BskyStarterPack,
             "app.bsky.graph.verification" => CollectionType::BskyVerification,
             "app.bsky.labeler.service" => CollectionType::BskyLabelerService,
+            "app.bsky.notification.declaration" => CollectionType::BskyNotificationDeclaration,
             "chat.bsky.actor.declaration" => CollectionType::ChatActorDecl,
             _ => CollectionType::Unsupported,
         }
···
             CollectionType::BskyStarterPack => true,
             CollectionType::BskyVerification => false,
             CollectionType::BskyLabelerService => true,
+            CollectionType::BskyNotificationDeclaration => true,
             CollectionType::Unsupported => false,
         }
     }

lexica/src/app_bsky/actor.rs

···
     pub labeler: 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)]
···
             "all" => Ok(ChatAllowIncoming::All),
             "none" => Ok(ChatAllowIncoming::None),
             "following" => Ok(ChatAllowIncoming::Following),
+            x => Err(format!("Unrecognized variant {x}")),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProfileAssociatedActivitySubscription {
+    pub allow_subscriptions: ProfileAllowSubscriptions,
+}
+
+#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProfileAllowSubscriptions {
+    Followers,
+    Mutuals,
+    None,
+}
+
+impl Display for ProfileAllowSubscriptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ProfileAllowSubscriptions::Followers => write!(f, "followers"),
+            ProfileAllowSubscriptions::Mutuals => write!(f, "mutuals"),
+            ProfileAllowSubscriptions::None => write!(f, "none"),
+        }
+    }
+}
+
+impl FromStr for ProfileAllowSubscriptions {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "none" => Ok(ProfileAllowSubscriptions::None),
+            "mutuals" => Ok(ProfileAllowSubscriptions::Mutuals),
+            "following" => Ok(ProfileAllowSubscriptions::Followers),
             x => Err(format!("Unrecognized variant {x}")),
         }
     }

migrations/2025-07-21-173906_notif-decl/down.sql

···
+drop table notif_decl;

migrations/2025-07-21-173906_notif-decl/up.sql

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

parakeet-db/src/schema.rs

···
 }
 
 diesel::table! {
+    notif_decl (did) {
+        did -> Text,
+        allow_subscriptions -> Nullable<Text>,
+        indexed_at -> Timestamp,
+    }
+}
+
+diesel::table! {
     post_embed_ext (post_uri) {
         post_uri -> Text,
         uri -> Text,
···
 diesel::joinable!(likes -> actors (did));
 diesel::joinable!(list_blocks -> actors (did));
 diesel::joinable!(lists -> actors (owner));
+diesel::joinable!(notif_decl -> actors (did));
 diesel::joinable!(post_embed_ext -> posts (post_uri));
 diesel::joinable!(post_embed_images -> posts (post_uri));
 diesel::joinable!(post_embed_record -> posts (post_uri));
···
     list_blocks,
     list_items,
     lists,
+    notif_decl,
     post_embed_ext,
     post_embed_images,
     post_embed_record,

parakeet/src/hydration/profile.rs

···
     chat: Option<ChatAllowIncoming>,
     labeler: bool,
     stats: Option<ProfileStats>,
+    notif: Option<ProfileAllowSubscriptions>,
 ) -> Option<ProfileAssociated> {
     if chat.is_some() || labeler || stats.is_some() {
         let stats = stats.unwrap_or_default();
···
             starter_packs: stats.starterpacks as i64,
             labeler,
             chat: chat.map(|v| ProfileAssociatedChat { allow_incoming: v }),
+            activity_subscription: notif.map(|v| ProfileAssociatedActivitySubscription {
+                allow_subscriptions: v,
+            }),
         })
     } else {
         None
···
 }
 
 fn build_basic(
-    (handle, profile, chat_decl, is_labeler, stats, status): ProfileLoaderRet,
+    (handle, profile, chat_decl, is_labeler, stats, status, notif_decl): ProfileLoaderRet,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
     cdn: &BskyCdn,
 ) -> ProfileViewBasic {
-    let associated = build_associated(chat_decl, is_labeler, stats);
+    let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
     let verification = build_verification(&profile, &handle, verifications);
     let status = status.and_then(|status| build_status(status, cdn));
     let avatar = profile.avatar_cid.map(|cid| cdn.avatar(&profile.did, &cid));
···
 }
 
 fn build_profile(
-    (handle, profile, chat_decl, is_labeler, stats, status): ProfileLoaderRet,
+    (handle, profile, chat_decl, is_labeler, stats, status, notif_decl): ProfileLoaderRet,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
     cdn: &BskyCdn,
 ) -> ProfileView {
-    let associated = build_associated(chat_decl, is_labeler, stats);
+    let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
     let verification = build_verification(&profile, &handle, verifications);
     let status = status.and_then(|status| build_status(status, cdn));
     let avatar = profile.avatar_cid.map(|cid| cdn.avatar(&profile.did, &cid));
···
 }
 
 fn build_detailed(
-    (handle, profile, chat_decl, is_labeler, stats, status): ProfileLoaderRet,
+    (handle, profile, chat_decl, is_labeler, stats, status, notif_decl): ProfileLoaderRet,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
     cdn: &BskyCdn,
 ) -> ProfileViewDetailed {
-    let associated = build_associated(chat_decl, is_labeler, stats);
+    let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
     let verification = build_verification(&profile, &handle, verifications);
     let status = status.and_then(|status| build_status(status, cdn));
     let avatar = profile.avatar_cid.map(|cid| cdn.avatar(&profile.did, &cid));

parakeet/src/loaders.rs

···
 use diesel_async::pooled_connection::deadpool::Pool;
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use itertools::Itertools;
-use lexica::app_bsky::actor::ChatAllowIncoming;
+use lexica::app_bsky::actor::{ChatAllowIncoming, ProfileAllowSubscriptions};
 use parakeet_db::{models, schema};
 use std::collections::HashMap;
 use std::str::FromStr;
···
     bool,
     Option<parakeet_index::ProfileStats>,
     Option<models::Status>,
+    Option<ProfileAllowSubscriptions>,
 );
 impl BatchFn<String, ProfileLoaderRet> for ProfileLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, ProfileLoaderRet> {
···
             )
             .left_join(schema::labelers::table.on(schema::labelers::did.eq(schema::actors::did)))
             .left_join(schema::statuses::table.on(schema::statuses::did.eq(schema::actors::did)))
+            .left_join(
+                schema::notif_decl::table.on(schema::notif_decl::did.eq(schema::actors::did)),
+            )
             .select((
                 schema::actors::did,
                 schema::actors::handle,
···
                 schema::chat_decls::allow_incoming.nullable(),
                 schema::labelers::cid.nullable(),
                 Option::<models::Status>::as_select(),
+                schema::notif_decl::allow_subscriptions.nullable(),
             ))
             .filter(
                 schema::actors::did
···
                 Option<String>,
                 Option<String>,
                 Option<models::Status>,
+                Option<String>,
             )>(&mut conn)
             .await;
 
···
 
         match res {
             Ok(res) => HashMap::from_iter(res.into_iter().map(
-                |(did, handle, profile, chat_decl, labeler_cid, status)| {
+                |(did, handle, profile, chat_decl, labeler_cid, status, notif_decl)| {
                     let chat_decl = chat_decl.and_then(|v| ChatAllowIncoming::from_str(&v).ok());
+                    let notif_decl =
+                        notif_decl.and_then(|v| ProfileAllowSubscriptions::from_str(&v).ok());
                     let is_labeler = labeler_cid.is_some();
                     let maybe_stats = stats.remove(&did);
 
-                    let val = (handle, profile, chat_decl, is_labeler, maybe_stats, status);
+                    let val = (
+                        handle,
+                        profile,
+                        chat_decl,
+                        is_labeler,
+                        maybe_stats,
+                        status,
+                        notif_decl,
+                    );
 
                     (did, val)
                 },