feat: BoostRemoved → Undo(Announce) fan-out via OutboundFederationPort

crates/adapters/activitypub-base/src/service.rs

@@ -200,6 +200,68 @@ impl ActivityPubService {
         Ok(())
     }
 
+    /// Fan out an Undo(Announce) activity to all accepted followers.
+    pub async fn broadcast_undo_announce_to_followers(
+        &self,
+        local_user_id: uuid::Uuid,
+        object_ap_id: url::Url,
+    ) -> anyhow::Result<()> {
+        let data = self.federation_config.to_request_data();
+        let local_actor = get_local_actor(local_user_id, &data)
+            .await
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+
+        let followers = data.federation_repo.get_followers(local_user_id).await?;
+        let blocked = data.federation_repo.get_blocked_actors(local_user_id).await.unwrap_or_default();
+        let blocked_set: std::collections::HashSet<String> = blocked.into_iter().collect();
+        let blocked_domains = data.federation_repo.get_blocked_domains().await.unwrap_or_default();
+        let blocked_domain_set: std::collections::HashSet<String> =
+            blocked_domains.into_iter().map(|d| d.domain).collect();
+
+        let accepted: Vec<_> = followers
+            .into_iter()
+            .filter(|f| f.status == FollowerStatus::Accepted)
+            .filter(|f| !blocked_set.contains(&f.actor.url))
+            .filter(|f| {
+                let domain = url::Url::parse(&f.actor.inbox_url)
+                    .ok()
+                    .and_then(|u| u.host_str().map(|s| s.to_string()))
+                    .unwrap_or_default();
+                !blocked_domain_set.contains(&domain)
+            })
+            .collect();
+
+        if accepted.is_empty() {
+            return Ok(());
+        }
+
+        let undo_id = crate::urls::activity_url(&self.base_url).map_err(|e| anyhow::anyhow!("{e}"))?;
+        let undo = crate::activities::UndoActivity {
+            id: undo_id,
+            kind: Default::default(),
+            actor: activitypub_federation::fetch::object_id::ObjectId::from(local_actor.ap_id.clone()),
+            object: serde_json::json!({
+                "type": "Announce",
+                "actor": local_actor.ap_id.to_string(),
+                "object": object_ap_id.to_string(),
+            }),
+        };
+
+        let inboxes = collect_inboxes(&accepted);
+        let sends = activitypub_federation::activity_sending::SendActivityTask::prepare(
+            &activitypub_federation::protocol::context::WithContext::new_default(undo),
+            &local_actor,
+            inboxes,
+            &data,
+        )
+        .await?;
+        let failures = send_with_retry(sends, &data).await;
+        if !failures.is_empty() {
+            tracing::warn!(count = failures.len(), "some Undo(Announce) deliveries failed");
+        }
+        Ok(())
+    }
+
     pub async fn follow(&self, local_user_id: uuid::Uuid, handle: &str) -> anyhow::Result<()> {
         let data = self.federation_config.to_request_data();
 
@@ -1383,6 +1445,19 @@ impl domain::ports::OutboundFederationPort for ActivityPubService {
             .await
             .map_err(|e| domain::errors::DomainError::Internal(e.to_string()))
     }
+
+    async fn broadcast_undo_announce(
+        &self,
+        booster_user_id: &domain::value_objects::UserId,
+        object_ap_id: &str,
+    ) -> Result<(), domain::errors::DomainError> {
+        let user_uuid = booster_user_id.as_uuid();
+        let ap_id = url::Url::parse(object_ap_id)
+            .map_err(|e| domain::errors::DomainError::Internal(e.to_string()))?;
+        self.broadcast_undo_announce_to_followers(user_uuid, ap_id)
+            .await
+            .map_err(|e| domain::errors::DomainError::Internal(e.to_string()))
+    }
 }
 
 #[cfg(test)]