refactor: extract inline test modules to separate files

crates/adapters/postgres/src/activitypub/mod.rs

@@ -0,0 +1,337 @@
+use crate::db_error::IntoDbResult;
+use async_trait::async_trait;
+
+const MAX_REMOTE_CONTENT_CHARS: usize = 500;
+const THOUGHTS_PATH_PREFIX: &str = "/thoughts/";
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+
+use activitypub_base::{ActivityPubRepository, ActorApUrls, OutboxEntry};
+use domain::{
+    errors::DomainError,
+    models::thought::{Thought, Visibility},
+    value_objects::{Content, ThoughtId, UserId, Username},
+};
+
+pub struct PgActivityPubRepository {
+    pool: PgPool,
+}
+
+impl PgActivityPubRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl ActivityPubRepository for PgActivityPubRepository {
+    async fn outbox_entries_for_actor(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
+        sqlx::query_as::<_, Row>(
+            "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+             FROM thoughts t JOIN users u ON u.id=t.user_id
+             WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+             ORDER BY t.created_at DESC",
+        )
+        .bind(user_id.as_uuid())
+        .fetch_all(&self.pool)
+        .await
+        .into_domain()
+        .map(|rows| {
+            rows.into_iter()
+                .map(|r| OutboxEntry {
+                    thought: Thought {
+                        id: ThoughtId::from_uuid(r.id),
+                        user_id: UserId::from_uuid(r.user_id),
+                        content: Content::new_remote(r.content),
+                        in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                        visibility: Visibility::Public,
+                        content_warning: r.content_warning,
+                        sensitive: r.sensitive,
+                        local: true,
+                        created_at: r.created_at,
+                        updated_at: r.updated_at,
+                    },
+                    author_username: Username::from_trusted(r.username),
+                })
+                .collect()
+        })
+    }
+
+    async fn outbox_page_for_actor(
+        &self,
+        user_id: &UserId,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
+        let rows = if let Some(before) = before {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public' AND t.created_at < $2
+                 ORDER BY t.created_at DESC LIMIT $3",
+            )
+            .bind(user_id.as_uuid())
+            .bind(before)
+            .bind(limit as i64)
+            .fetch_all(&self.pool)
+            .await
+        } else {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+                 ORDER BY t.created_at DESC LIMIT $2",
+            )
+            .bind(user_id.as_uuid())
+            .bind(limit as i64)
+            .fetch_all(&self.pool)
+            .await
+        }
+        .into_domain()?;
+
+        Ok(rows
+            .into_iter()
+            .map(|r| OutboxEntry {
+                thought: Thought {
+                    id: ThoughtId::from_uuid(r.id),
+                    user_id: UserId::from_uuid(r.user_id),
+                    content: Content::new_remote(r.content),
+                    in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                    visibility: Visibility::Public,
+                    content_warning: r.content_warning,
+                    sensitive: r.sensitive,
+                    local: true,
+                    created_at: r.created_at,
+                    updated_at: r.updated_at,
+                },
+                author_username: Username::from_trusted(r.username),
+            })
+            .collect())
+    }
+
+    async fn find_remote_actor_id(
+        &self,
+        actor_ap_url: &str,
+    ) -> Result<Option<UserId>, DomainError> {
+        sqlx::query_scalar::<_, uuid::Uuid>("SELECT id FROM users WHERE ap_id=$1")
+            .bind(actor_ap_url)
+            .fetch_optional(&self.pool)
+            .await
+            .into_domain()
+            .map(|o| o.map(UserId::from_uuid))
+    }
+
+    async fn intern_remote_actor(&self, actor_ap_url: &str) -> Result<UserId, DomainError> {
+        if let Some(id) = self.find_remote_actor_id(actor_ap_url).await? {
+            return Ok(id);
+        }
+        let new_id = uuid::Uuid::new_v4();
+        // Use the last path segment as username (e.g. /users/alice → "alice").
+        // Falls back to a random short id for long segments (e.g. UUID-based actor URLs).
+        // username column is VARCHAR(32).
+        let last_seg = url::Url::parse(actor_ap_url)
+            .ok()
+            .and_then(|u| {
+                u.path_segments()
+                    .and_then(|mut s| s.next_back().map(|s| s.to_string()))
+            })
+            .unwrap_or_default();
+        let handle = if last_seg.is_empty() {
+            format!("remote_{}", &new_id.to_string()[..13])
+        } else if last_seg.len() <= 32 {
+            last_seg
+        } else {
+            format!("remote_{}", &new_id.to_string()[..13])
+        };
+        sqlx::query(
+            "INSERT INTO users(id,username,email,password_hash,local,ap_id,created_at,updated_at)
+             VALUES($1,$2,$3,'',false,$4,NOW(),NOW()) ON CONFLICT(ap_id) DO NOTHING",
+        )
+        .bind(new_id)
+        .bind(&handle)
+        .bind(format!("{}@remote", new_id))
+        .bind(actor_ap_url)
+        .execute(&self.pool)
+        .await
+        .into_domain()?;
+        // Re-fetch to get whichever id won the race
+        self.find_remote_actor_id(actor_ap_url)
+            .await?
+            .ok_or_else(|| {
+                DomainError::Internal(
+                    "intern_remote_actor: insert succeeded but row not found".into(),
+                )
+            })
+    }
+
+    async fn update_remote_actor_display(
+        &self,
+        user_id: &UserId,
+        display_name: Option<&str>,
+        avatar_url: Option<&str>,
+    ) -> Result<(), DomainError> {
+        sqlx::query(
+            "UPDATE users SET display_name=$1, avatar_url=$2, updated_at=NOW()
+             WHERE id=$3 AND local=false",
+        )
+        .bind(display_name)
+        .bind(avatar_url)
+        .bind(user_id.as_uuid())
+        .execute(&self.pool)
+        .await
+        .into_domain()
+        .map(|_| ())
+    }
+
+    async fn accept_note(
+        &self,
+        ap_id: &str,
+        author_id: &UserId,
+        content: &str,
+        published: DateTime<Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+        visibility: &str,
+        in_reply_to: Option<&str>,
+    ) -> Result<ThoughtId, DomainError> {
+        let capped: String = content.chars().take(MAX_REMOTE_CONTENT_CHARS).collect();
+        let (in_reply_to_id, in_reply_to_url) = match in_reply_to {
+            Some(url) => {
+                // If the parent is a local thought, extract its UUID for in_reply_to_id.
+                let local_uuid = url::Url::parse(url).ok().and_then(|u| {
+                    u.path()
+                        .strip_prefix(THOUGHTS_PATH_PREFIX)
+                        .and_then(|s| s.split('/').next())
+                        .and_then(|s| uuid::Uuid::parse_str(s).ok())
+                });
+                (local_uuid, Some(url.to_string()))
+            }
+            None => (None, None),
+        };
+        sqlx::query(
+            "INSERT INTO thoughts(id,user_id,content,ap_id,visibility,sensitive,local,content_warning,created_at,in_reply_to_id,in_reply_to_url)
+             VALUES($1,$2,$3,$4,$8,$5,false,$6,$7,$9,$10) ON CONFLICT(ap_id) DO NOTHING",
+        )
+        .bind(uuid::Uuid::new_v4())
+        .bind(author_id.as_uuid())
+        .bind(&capped)
+        .bind(ap_id)
+        .bind(sensitive)
+        .bind(content_warning)
+        .bind(published)
+        .bind(visibility)
+        .bind(in_reply_to_id)
+        .bind(&in_reply_to_url)
+        .execute(&self.pool)
+        .await
+        .into_domain()?;
+
+        // SELECT the id — works whether the INSERT was a no-op or not (idempotent).
+        let row: (uuid::Uuid,) =
+            sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
+                .bind(ap_id)
+                .fetch_one(&self.pool)
+                .await
+                .into_domain()?;
+        Ok(ThoughtId::from_uuid(row.0))
+    }
+
+    async fn apply_note_update(&self, ap_id: &str, new_content: &str) -> Result<(), DomainError> {
+        let capped: String = new_content.chars().take(MAX_REMOTE_CONTENT_CHARS).collect();
+        sqlx::query(
+            "UPDATE thoughts SET content=$2,updated_at=NOW() WHERE ap_id=$1 AND local=false",
+        )
+        .bind(ap_id)
+        .bind(&capped)
+        .execute(&self.pool)
+        .await
+        .into_domain()
+        .map(|_| ())
+    }
+
+    async fn retract_note(&self, ap_id: &str) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM thoughts WHERE ap_id=$1 AND local=false")
+            .bind(ap_id)
+            .execute(&self.pool)
+            .await
+            .into_domain()
+            .map(|_| ())
+    }
+
+    async fn retract_actor_notes(&self, actor_ap_url: &str) -> Result<(), DomainError> {
+        sqlx::query(
+            "DELETE FROM thoughts WHERE local=false AND user_id=(SELECT id FROM users WHERE ap_id=$1)",
+        )
+        .bind(actor_ap_url)
+        .execute(&self.pool)
+        .await
+        .into_domain()
+        .map(|_| ())
+    }
+
+    async fn count_local_notes(&self) -> Result<u64, DomainError> {
+        let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM thoughts WHERE local=true")
+            .fetch_one(&self.pool)
+            .await
+            .into_domain()?;
+        Ok(n as u64)
+    }
+
+    async fn get_thought_ap_id(
+        &self,
+        thought_id: &ThoughtId,
+    ) -> Result<Option<String>, DomainError> {
+        sqlx::query_scalar::<_, String>(
+            "SELECT ap_id FROM thoughts WHERE id = $1 AND ap_id IS NOT NULL",
+        )
+        .bind(thought_id.as_uuid())
+        .fetch_optional(&self.pool)
+        .await
+        .into_domain()
+    }
+
+    async fn get_actor_ap_urls(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Option<ActorApUrls>, DomainError> {
+        sqlx::query_as::<_, (String, String)>(
+            "SELECT ap_id, inbox_url FROM users \
+             WHERE id = $1 AND ap_id IS NOT NULL AND inbox_url IS NOT NULL",
+        )
+        .bind(user_id.as_uuid())
+        .fetch_optional(&self.pool)
+        .await
+        .into_domain()
+        .map(|opt| opt.map(|(ap_id, inbox_url)| ActorApUrls { ap_id, inbox_url }))
+    }
+}
+
+#[cfg(test)]
+mod tests;

crates/adapters/postgres/src/activitypub/tests.rs

@@ -0,0 +1,68 @@
+    use super::*;
+    use activitypub_base::ActivityPubRepository;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let url = "https://mastodon.social/users/alice";
+        let id1 = repo.intern_remote_actor(url).await.unwrap();
+        let id2 = repo.intern_remote_actor(url).await.unwrap();
+        assert_eq!(id1, id2);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_and_retract_note(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let actor_url = "https://remote.example/users/bob";
+        let ap_id = "https://remote.example/notes/1";
+        let author = repo.intern_remote_actor(actor_url).await.unwrap();
+        repo.accept_note(
+            ap_id,
+            &author,
+            "hello from remote",
+            chrono::Utc::now(),
+            false,
+            None,
+            "public",
+            None,
+        )
+        .await
+        .unwrap();
+        repo.retract_note(ap_id).await.unwrap();
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn count_local_notes_excludes_remote(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        assert_eq!(repo.count_local_notes().await.unwrap(), 0);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_note_returns_thought_id(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool.clone());
+        let actor_user_id = repo
+            .intern_remote_actor("https://remote.example/users/alice")
+            .await
+            .unwrap();
+
+        let thought_id = repo
+            .accept_note(
+                "https://remote.example/notes/1",
+                &actor_user_id,
+                "Hello #rust world",
+                chrono::Utc::now(),
+                false,
+                None,
+                "public",
+                None,
+            )
+            .await
+            .unwrap();
+
+        let row: (uuid::Uuid,) = sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
+            .bind("https://remote.example/notes/1")
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+        assert_eq!(thought_id.as_uuid(), row.0);
+    }