making it AP complaint

crates/adapters/postgres-federation/Cargo.toml

@@ -12,7 +12,7 @@ sqlx = { version = "0.8.6", features = [
     "chrono",
 ] }
 activitypub = { workspace = true }
-k-ap = { version = "0.4.0", registry = "gitea" }
+k-ap = { version = "0.4.1", registry = "gitea" }
 domain = { workspace = true }
 uuid = { workspace = true }
 chrono = { workspace = true }

crates/adapters/postgres-federation/src/activity.rs

@@ -0,0 +1,29 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::ActivityRepository;
+
+use super::{PostgresFederationRepository, datetime_to_str};
+
+#[async_trait]
+impl ActivityRepository for PostgresFederationRepository {
+    async fn is_activity_processed(&self, activity_id: &str) -> Result<bool> {
+        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM ap_activities WHERE id = $1")
+            .bind(activity_id)
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(count > 0)
+    }
+
+    async fn mark_activity_processed(&self, activity_id: &str) -> Result<()> {
+        let ts = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query(
+            "INSERT INTO ap_activities (id, processed_at) VALUES ($1, $2) ON CONFLICT DO NOTHING",
+        )
+        .bind(activity_id)
+        .bind(&ts)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+}

crates/adapters/postgres-federation/src/actor.rs

@@ -0,0 +1,100 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::{ActorRepository, RemoteActor};
+use sqlx::Row;
+
+use super::{PG_ACTOR_COLS, PostgresFederationRepository, datetime_to_str, pg_remote_actor};
+
+#[async_trait]
+impl ActorRepository for PostgresFederationRepository {
+    async fn get_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Option<(String, String)>> {
+        let uid = user_id.to_string();
+        let row =
+            sqlx::query("SELECT public_key, private_key FROM ap_local_actors WHERE user_id = $1")
+                .bind(&uid)
+                .fetch_optional(&self.pool)
+                .await?;
+        Ok(row.map(|r| (r.get("public_key"), r.get("private_key"))))
+    }
+
+    async fn save_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+        public_key: String,
+        private_key: String,
+    ) -> Result<()> {
+        let uid = user_id.to_string();
+        let now = Utc::now().naive_utc();
+        let created_at = datetime_to_str(&now);
+        sqlx::query(
+            "INSERT INTO ap_local_actors (user_id, public_key, private_key, created_at) VALUES ($1, $2, $3, $4::timestamptz)
+             ON CONFLICT(user_id) DO UPDATE SET public_key = EXCLUDED.public_key, private_key = EXCLUDED.private_key",
+        ).bind(&uid).bind(&public_key).bind(&private_key).bind(&created_at).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()> {
+        let now = Utc::now().naive_utc();
+        let fetched_at = datetime_to_str(&now);
+        let aka_json = serde_json::to_string(&actor.also_known_as).unwrap_or_default();
+        sqlx::query(
+            "INSERT INTO ap_remote_actors (url, handle, inbox_url, shared_inbox_url, display_name, avatar_url, outbox_url, bio, banner_url, followers_url, following_url, also_known_as, fetched_at)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13::timestamptz)
+             ON CONFLICT(url) DO UPDATE SET
+                 handle=EXCLUDED.handle, inbox_url=EXCLUDED.inbox_url, shared_inbox_url=EXCLUDED.shared_inbox_url,
+                 display_name=EXCLUDED.display_name, avatar_url=EXCLUDED.avatar_url,
+                 outbox_url=COALESCE(EXCLUDED.outbox_url, ap_remote_actors.outbox_url),
+                 bio=EXCLUDED.bio, banner_url=EXCLUDED.banner_url, followers_url=EXCLUDED.followers_url,
+                 following_url=EXCLUDED.following_url, also_known_as=EXCLUDED.also_known_as, fetched_at=EXCLUDED.fetched_at",
+        )
+        .bind(&actor.url).bind(&actor.handle).bind(&actor.inbox_url).bind(&actor.shared_inbox_url)
+        .bind(&actor.display_name).bind(&actor.avatar_url).bind(&actor.outbox_url)
+        .bind(&actor.bio).bind(&actor.banner_url).bind(&actor.followers_url).bind(&actor.following_url)
+        .bind(&aka_json).bind(&fetched_at)
+        .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_remote_actor(&self, actor_url: &str) -> Result<Option<RemoteActor>> {
+        let q = format!("SELECT url, {PG_ACTOR_COLS} FROM ap_remote_actors a WHERE url = $1");
+        let row = sqlx::query(&q)
+            .bind(actor_url)
+            .fetch_optional(&self.pool)
+            .await?;
+        Ok(row.as_ref().map(|r| pg_remote_actor(r, "url")))
+    }
+
+    async fn add_announce(
+        &self,
+        activity_id: &str,
+        object_url: &str,
+        actor_url: &str,
+        announced_at: chrono::DateTime<chrono::Utc>,
+    ) -> Result<()> {
+        let ts = announced_at.format("%Y-%m-%d %H:%M:%S").to_string();
+        sqlx::query("INSERT INTO ap_announces (id, object_url, actor_url, announced_at) VALUES ($1, $2, $3, $4) ON CONFLICT (id) DO NOTHING")
+            .bind(activity_id).bind(object_url).bind(actor_url).bind(&ts).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn remove_announce(&self, activity_id: &str, actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM ap_announces WHERE id = $1 AND actor_url = $2")
+            .bind(activity_id)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn count_announces(&self, object_url: &str) -> Result<usize> {
+        let row = sqlx::query("SELECT COUNT(*) as cnt FROM ap_announces WHERE object_url = $1")
+            .bind(object_url)
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(row.get::<i64, _>("cnt") as usize)
+    }
+}

crates/adapters/postgres-federation/src/ap_content.rs

@@ -0,0 +1,486 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::{
+        DiaryEntry, Goal, GoalType, Movie, PersistedReview, Review, ReviewSource, WatchlistEntry,
+        WatchlistWithMovie,
+    },
+    ports::LocalApContentQuery,
+    value_objects::{
+        Comment, ExternalMetadataId, GoalId, MovieId, MovieTitle, PosterPath, Rating, ReleaseYear,
+        ReviewId, UserId, WatchlistEntryId,
+    },
+};
+use sqlx::{PgPool, Row};
+use uuid::Uuid;
+
+pub struct PostgresApContentQuery {
+    pool: PgPool,
+}
+
+impl PostgresApContentQuery {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+
+    fn map_err(e: sqlx::Error) -> DomainError {
+        tracing::error!("Database error: {:?}", e);
+        DomainError::InfrastructureError("Database operation failed".into())
+    }
+}
+
+// ── Local row types ──────────────────────────────────────────────────────────
+
+fn parse_uuid(s: &str) -> Result<Uuid, DomainError> {
+    Uuid::parse_str(s)
+        .map_err(|e| DomainError::InfrastructureError(format!("Invalid UUID '{}': {}", s, e)))
+}
+
+fn parse_datetime(s: &str) -> Result<chrono::NaiveDateTime, DomainError> {
+    chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
+        .map_err(|e| DomainError::InfrastructureError(format!("Invalid datetime '{}': {}", s, e)))
+}
+
+#[derive(sqlx::FromRow)]
+struct MovieRow {
+    id: String,
+    external_metadata_id: Option<String>,
+    title: String,
+    release_year: i64,
+    director: Option<String>,
+    poster_path: Option<String>,
+}
+
+impl MovieRow {
+    fn into_domain(self) -> Result<Movie, DomainError> {
+        let id = MovieId::from_uuid(parse_uuid(&self.id)?);
+        let external_metadata_id = self
+            .external_metadata_id
+            .map(ExternalMetadataId::new)
+            .transpose()?;
+        let title = MovieTitle::new(self.title)?;
+        let release_year = ReleaseYear::new(self.release_year as u16)?;
+        let poster_path = self.poster_path.map(PosterPath::new).transpose()?;
+        Ok(Movie::from_persistence(
+            id,
+            external_metadata_id,
+            title,
+            release_year,
+            self.director,
+            poster_path,
+        ))
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct ReviewRow {
+    id: String,
+    movie_id: String,
+    user_id: String,
+    rating: i64,
+    comment: Option<String>,
+    watched_at: String,
+    created_at: String,
+    remote_actor_url: Option<String>,
+}
+
+impl ReviewRow {
+    fn into_domain(self) -> Result<Review, DomainError> {
+        let id = ReviewId::from_uuid(parse_uuid(&self.id)?);
+        let movie_id = MovieId::from_uuid(parse_uuid(&self.movie_id)?);
+        let user_id = UserId::from_uuid(parse_uuid(&self.user_id)?);
+        let rating = Rating::new(self.rating as u8)?;
+        let comment = self.comment.map(Comment::new).transpose()?;
+        let watched_at = parse_datetime(&self.watched_at)?;
+        let created_at = parse_datetime(&self.created_at)?;
+        let source = match self.remote_actor_url {
+            None => ReviewSource::Local,
+            Some(url) => ReviewSource::Remote { actor_url: url },
+        };
+        Ok(Review::from_persistence(PersistedReview {
+            id,
+            movie_id,
+            user_id,
+            rating,
+            comment,
+            watched_at,
+            created_at,
+            source,
+        }))
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct DiaryRow {
+    id: String,
+    external_metadata_id: Option<String>,
+    title: String,
+    release_year: i64,
+    director: Option<String>,
+    poster_path: Option<String>,
+    review_id: String,
+    movie_id: String,
+    user_id: String,
+    rating: i64,
+    comment: Option<String>,
+    watched_at: String,
+    created_at: String,
+    remote_actor_url: Option<String>,
+}
+
+impl DiaryRow {
+    fn into_domain(self) -> Result<DiaryEntry, DomainError> {
+        let movie = MovieRow {
+            id: self.id,
+            external_metadata_id: self.external_metadata_id,
+            title: self.title,
+            release_year: self.release_year,
+            director: self.director,
+            poster_path: self.poster_path,
+        }
+        .into_domain()?;
+        let review = ReviewRow {
+            id: self.review_id,
+            movie_id: self.movie_id,
+            user_id: self.user_id,
+            rating: self.rating,
+            comment: self.comment,
+            watched_at: self.watched_at,
+            created_at: self.created_at,
+            remote_actor_url: self.remote_actor_url,
+        }
+        .into_domain()?;
+        Ok(DiaryEntry::new(movie, review))
+    }
+}
+
+fn row_to_goal(r: &sqlx::postgres::PgRow) -> Result<Goal, DomainError> {
+    let id_str: String = r
+        .try_get("id")
+        .map_err(|e| DomainError::InfrastructureError(format!("Failed to read goal id: {e}")))?;
+    let user_id_str: String = r
+        .try_get("user_id")
+        .map_err(|e| DomainError::InfrastructureError(format!("Failed to read user_id: {e}")))?;
+    let year: i64 = r
+        .try_get("year")
+        .map_err(|e| DomainError::InfrastructureError(format!("Failed to read year: {e}")))?;
+    let target: i64 = r.try_get("target_count").map_err(|e| {
+        DomainError::InfrastructureError(format!("Failed to read target_count: {e}"))
+    })?;
+    let goal_type_str: String = r
+        .try_get("goal_type")
+        .map_err(|e| DomainError::InfrastructureError(format!("Failed to read goal_type: {e}")))?;
+    let created_at_str: String = r
+        .try_get("created_at")
+        .map_err(|e| DomainError::InfrastructureError(format!("Failed to read created_at: {e}")))?;
+
+    let id = GoalId::from_uuid(parse_uuid(&id_str)?);
+    let user_id = UserId::from_uuid(parse_uuid(&user_id_str)?);
+    let goal_type: GoalType = goal_type_str.parse()?;
+    let created_at = parse_datetime(&created_at_str)?;
+
+    Ok(Goal::from_persistence(
+        id,
+        user_id,
+        year as u16,
+        target as u32,
+        goal_type,
+        created_at,
+    ))
+}
+
+async fn count_reviews_in_year(
+    pool: &PgPool,
+    user_id: &UserId,
+    year: u16,
+) -> Result<u32, DomainError> {
+    let uid = user_id.value().to_string();
+    let start = format!("{year}-01-01 00:00:00");
+    let end = format!("{}-01-01 00:00:00", year + 1);
+
+    let count: i64 = sqlx::query(
+        "SELECT COUNT(*) FROM reviews \
+         WHERE user_id = $1 \
+         AND watched_at >= $2::timestamptz \
+         AND watched_at < $3::timestamptz \
+         AND remote_actor_url IS NULL",
+    )
+    .bind(&uid)
+    .bind(&start)
+    .bind(&end)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| {
+        tracing::error!("Database error: {:?}", e);
+        DomainError::InfrastructureError("Database operation failed".into())
+    })?
+    .try_get(0)
+    .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+
+    Ok(count as u32)
+}
+
+// ── LocalApContentQuery impl ─────────────────────────────────────────────────
+
+#[async_trait]
+impl LocalApContentQuery for PostgresApContentQuery {
+    async fn get_local_reviews_for_user(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<DiaryEntry>, DomainError> {
+        let uid = user_id.value().to_string();
+        let rows = sqlx::query_as::<_, DiaryRow>(
+            "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,
+                    r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment,
+                    to_char(r.watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at,
+                    to_char(r.created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at,
+                    r.remote_actor_url
+             FROM reviews r
+             INNER JOIN movies m ON m.id = r.movie_id
+             WHERE r.user_id = $1 AND r.remote_actor_url IS NULL
+             ORDER BY r.created_at DESC",
+        )
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+        rows.into_iter().map(DiaryRow::into_domain).collect()
+    }
+
+    async fn get_local_watchlist_for_user(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<WatchlistWithMovie>, DomainError> {
+        let uid = user_id.value().to_string();
+        let rows = sqlx::query(
+            "SELECT w.id, w.user_id, w.movie_id,
+                    to_char(w.added_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS added_at,
+                    m.id AS m_id, m.external_metadata_id, m.title, m.release_year,
+                    m.director, m.poster_path
+             FROM watchlist_entries w
+             JOIN movies m ON m.id = w.movie_id
+             WHERE w.user_id = $1
+             ORDER BY w.added_at DESC",
+        )
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        rows.into_iter()
+            .map(|row| {
+                let entry = WatchlistEntry {
+                    id: WatchlistEntryId::from_uuid(parse_uuid(
+                        &row.try_get::<String, _>("id")
+                            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    )?),
+                    user_id: UserId::from_uuid(parse_uuid(
+                        &row.try_get::<String, _>("user_id")
+                            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    )?),
+                    movie_id: MovieId::from_uuid(parse_uuid(
+                        &row.try_get::<String, _>("movie_id")
+                            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    )?),
+                    added_at: parse_datetime(
+                        &row.try_get::<String, _>("added_at")
+                            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    )?,
+                };
+                let movie = MovieRow {
+                    id: row
+                        .try_get("m_id")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    external_metadata_id: row
+                        .try_get("external_metadata_id")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    title: row
+                        .try_get("title")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    release_year: row
+                        .try_get("release_year")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    director: row
+                        .try_get("director")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                    poster_path: row
+                        .try_get("poster_path")
+                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
+                }
+                .into_domain()?;
+                Ok(WatchlistWithMovie { entry, movie })
+            })
+            .collect()
+    }
+
+    async fn get_local_reviews_for_movie(
+        &self,
+        movie_id: &MovieId,
+    ) -> Result<Vec<DiaryEntry>, DomainError> {
+        let mid = movie_id.value().to_string();
+        let rows = sqlx::query_as::<_, DiaryRow>(
+            "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,
+                    r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment,
+                    to_char(r.watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at,
+                    to_char(r.created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at,
+                    r.remote_actor_url
+             FROM reviews r
+             INNER JOIN movies m ON m.id = r.movie_id
+             WHERE r.movie_id = $1 AND r.remote_actor_url IS NULL
+             ORDER BY r.created_at DESC",
+        )
+        .bind(&mid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+        rows.into_iter().map(DiaryRow::into_domain).collect()
+    }
+
+    async fn get_review_by_id(&self, review_id: &ReviewId) -> Result<Option<Review>, DomainError> {
+        let id = review_id.value().to_string();
+        sqlx::query_as::<_, ReviewRow>(
+            "SELECT id, movie_id, user_id, rating, comment,
+                    to_char(watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at,
+                    to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at,
+                    remote_actor_url
+             FROM reviews WHERE id = $1",
+        )
+        .bind(&id)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .map(ReviewRow::into_domain)
+        .transpose()
+    }
+
+    async fn get_movie_by_id(&self, movie_id: &MovieId) -> Result<Option<Movie>, DomainError> {
+        let id = movie_id.value().to_string();
+        sqlx::query_as::<_, MovieRow>(
+            "SELECT id, external_metadata_id, title, release_year, director, poster_path
+             FROM movies WHERE id = $1",
+        )
+        .bind(&id)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .map(MovieRow::into_domain)
+        .transpose()
+    }
+
+    async fn get_movie_by_external_metadata_id(
+        &self,
+        external_id: &str,
+    ) -> Result<Option<Movie>, DomainError> {
+        sqlx::query_as::<_, MovieRow>(
+            "SELECT id, external_metadata_id, title, release_year, director, poster_path
+             FROM movies WHERE external_metadata_id = $1",
+        )
+        .bind(external_id)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .map(MovieRow::into_domain)
+        .transpose()
+    }
+
+    async fn count_local_posts(&self) -> Result<u64, DomainError> {
+        let count: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM reviews WHERE remote_actor_url IS NULL")
+                .fetch_one(&self.pool)
+                .await
+                .map_err(Self::map_err)?;
+        Ok(count as u64)
+    }
+
+    async fn get_local_reviews_page(
+        &self,
+        user_id: &UserId,
+        before: Option<chrono::NaiveDateTime>,
+        limit: usize,
+    ) -> Result<Vec<DiaryEntry>, DomainError> {
+        let uid = user_id.value().to_string();
+        let limit_i64 = limit as i64;
+
+        let rows = if let Some(before_ts) = before {
+            let ts = before_ts.format("%Y-%m-%d %H:%M:%S").to_string();
+            sqlx::query_as::<_, DiaryRow>(
+                "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,
+                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment,
+                        to_char(r.watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at,
+                        to_char(r.created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at,
+                        r.remote_actor_url
+                 FROM reviews r
+                 INNER JOIN movies m ON m.id = r.movie_id
+                 WHERE r.user_id = $1 AND r.remote_actor_url IS NULL AND r.watched_at < $2::timestamptz
+                 ORDER BY r.watched_at DESC
+                 LIMIT $3",
+            )
+            .bind(&uid)
+            .bind(&ts)
+            .bind(limit_i64)
+            .fetch_all(&self.pool)
+            .await
+            .map_err(Self::map_err)?
+        } else {
+            sqlx::query_as::<_, DiaryRow>(
+                "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,
+                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment,
+                        to_char(r.watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at,
+                        to_char(r.created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at,
+                        r.remote_actor_url
+                 FROM reviews r
+                 INNER JOIN movies m ON m.id = r.movie_id
+                 WHERE r.user_id = $1 AND r.remote_actor_url IS NULL
+                 ORDER BY r.watched_at DESC
+                 LIMIT $2",
+            )
+            .bind(&uid)
+            .bind(limit_i64)
+            .fetch_all(&self.pool)
+            .await
+            .map_err(Self::map_err)?
+        };
+        rows.into_iter().map(DiaryRow::into_domain).collect()
+    }
+
+    async fn get_goal_with_progress(
+        &self,
+        user_id: &UserId,
+        year: u16,
+    ) -> Result<Option<(Goal, u32)>, DomainError> {
+        let uid = user_id.value().to_string();
+        let y = year as i64;
+
+        let row = sqlx::query(
+            "SELECT id, user_id, year, target_count, goal_type, \
+             to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at \
+             FROM goals WHERE user_id = $1 AND year = $2",
+        )
+        .bind(&uid)
+        .bind(y)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        let Some(r) = row else { return Ok(None) };
+
+        let goal = row_to_goal(&r)?;
+        let count = count_reviews_in_year(&self.pool, user_id, year).await?;
+
+        Ok(Some((goal, count)))
+    }
+
+    async fn list_goals_for_user(&self, user_id: &UserId) -> Result<Vec<Goal>, DomainError> {
+        let uid = user_id.value().to_string();
+        let rows = sqlx::query(
+            "SELECT id, user_id, year, target_count, goal_type, \
+             to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS created_at \
+             FROM goals WHERE user_id = $1 ORDER BY created_at DESC",
+        )
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+        rows.iter().map(row_to_goal).collect()
+    }
+}

crates/adapters/postgres-federation/src/blocklist.rs

@@ -0,0 +1,87 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::{BlockedDomain, BlocklistRepository};
+use sqlx::Row;
+
+use super::{PostgresFederationRepository, datetime_to_str};
+
+#[async_trait]
+impl BlocklistRepository for PostgresFederationRepository {
+    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()> {
+        let ts = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query("INSERT INTO blocked_domains (domain, reason, blocked_at) VALUES ($1, $2, $3) ON CONFLICT(domain) DO UPDATE SET reason = EXCLUDED.reason")
+            .bind(domain).bind(reason).bind(&ts).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn remove_blocked_domain(&self, domain: &str) -> Result<()> {
+        sqlx::query("DELETE FROM blocked_domains WHERE domain = $1")
+            .bind(domain)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_blocked_domains(&self) -> Result<Vec<BlockedDomain>> {
+        let rows = sqlx::query(
+            "SELECT domain, reason, blocked_at FROM blocked_domains ORDER BY blocked_at DESC",
+        )
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows
+            .iter()
+            .map(|r| BlockedDomain {
+                domain: r.get("domain"),
+                reason: r.get("reason"),
+                blocked_at: r.get("blocked_at"),
+            })
+            .collect())
+    }
+
+    async fn is_domain_blocked(&self, domain: &str) -> Result<bool> {
+        let count: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM blocked_domains WHERE domain = $1")
+                .bind(domain)
+                .fetch_one(&self.pool)
+                .await?;
+        Ok(count > 0)
+    }
+
+    async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let ts = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query("INSERT INTO blocked_actors (local_user_id, remote_actor_url, blocked_at) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING")
+            .bind(&uid).bind(actor_url).bind(&ts).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn remove_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        let uid = local_user_id.to_string();
+        sqlx::query(
+            "DELETE FROM blocked_actors WHERE local_user_id = $1 AND remote_actor_url = $2",
+        )
+        .bind(&uid)
+        .bind(actor_url)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+
+    async fn get_blocked_actors(&self, local_user_id: uuid::Uuid) -> Result<Vec<String>> {
+        let uid = local_user_id.to_string();
+        let rows = sqlx::query("SELECT remote_actor_url FROM blocked_actors WHERE local_user_id = $1 ORDER BY blocked_at DESC")
+            .bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .map(|r| r.get::<String, _>("remote_actor_url"))
+            .collect())
+    }
+
+    async fn is_actor_blocked(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<bool> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM blocked_actors WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid).bind(actor_url).fetch_one(&self.pool).await?;
+        Ok(count > 0)
+    }
+}

crates/adapters/postgres-federation/src/follow.rs

@@ -0,0 +1,321 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::{
+    ActorRepository, FollowRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
+};
+use sqlx::Row;
+
+use super::{
+    PG_ACTOR_COLS, PostgresFederationRepository, datetime_to_str, pg_remote_actor, status_to_str,
+    str_to_status,
+};
+
+#[async_trait]
+impl FollowRepository for PostgresFederationRepository {
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+        follow_activity_id: &str,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = status_to_str(&status);
+        let now = Utc::now().naive_utc();
+        let created_at = datetime_to_str(&now);
+        sqlx::query(
+            "INSERT INTO ap_followers (local_user_id, remote_actor_url, status, created_at, follow_activity_id)
+             VALUES ($1, $2, $3, $4::timestamptz, $5)
+             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET
+                 status = EXCLUDED.status, follow_activity_id = EXCLUDED.follow_activity_id",
+        ).bind(&uid).bind(remote_actor_url).bind(status_str).bind(&created_at).bind(follow_activity_id).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_follower_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        let uid = local_user_id.to_string();
+        let row: Option<String> = sqlx::query_scalar(
+            "SELECT follow_activity_id FROM ap_followers WHERE local_user_id = $1 AND remote_actor_url = $2",
+        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
+        Ok(row)
+    }
+
+    async fn remove_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_followers WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid)
+            .bind(remote_actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT f.remote_actor_url, f.status, {PG_ACTOR_COLS} FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1"
+        );
+        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .map(|row| {
+                let status_str: String = row.get("status");
+                Follower {
+                    actor: pg_remote_actor(row, "remote_actor_url"),
+                    status: str_to_status(&status_str),
+                }
+            })
+            .collect())
+    }
+
+    async fn get_followers_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<Follower>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT f.remote_actor_url, f.status, {PG_ACTOR_COLS} FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted' ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query(&q)
+            .bind(&uid)
+            .bind(limit as i64)
+            .bind(offset as i64)
+            .fetch_all(&self.pool)
+            .await?;
+        Ok(rows
+            .iter()
+            .map(|row| {
+                let status_str: String = row.get("status");
+                Follower {
+                    actor: pg_remote_actor(row, "remote_actor_url"),
+                    status: str_to_status(&status_str),
+                }
+            })
+            .collect())
+    }
+
+    async fn count_followers(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(count as usize)
+    }
+
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = status_to_str(&status);
+        let result = sqlx::query("UPDATE ap_followers SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
+            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
+        }
+        Ok(())
+    }
+
+    async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT f.remote_actor_url, {PG_ACTOR_COLS} FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'pending'"
+        );
+        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .map(|row| pg_remote_actor(row, "remote_actor_url"))
+            .collect())
+    }
+
+    async fn get_accepted_follower_inboxes(
+        &self,
+        local_user_id: uuid::Uuid,
+    ) -> Result<Vec<String>> {
+        let uid = local_user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT DISTINCT COALESCE(a.shared_inbox_url, a.inbox_url) as inbox
+             FROM ap_followers f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = $1 AND f.status = 'accepted'
+               AND f.remote_actor_url NOT IN (SELECT remote_actor_url FROM blocked_actors WHERE local_user_id = $1)",
+        ).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .filter_map(|r| r.try_get::<String, _>("inbox").ok())
+            .collect())
+    }
+
+    async fn count_accepted_followers(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(count as usize)
+    }
+
+    async fn get_accepted_followers_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT f.remote_actor_url, {PG_ACTOR_COLS} FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted' ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query(&q)
+            .bind(&uid)
+            .bind(limit as i64)
+            .bind(offset as i64)
+            .fetch_all(&self.pool)
+            .await?;
+        Ok(rows
+            .iter()
+            .map(|row| pg_remote_actor(row, "remote_actor_url"))
+            .collect())
+    }
+
+    async fn add_following(
+        &self,
+        local_user_id: uuid::Uuid,
+        actor: RemoteActor,
+        follow_activity_id: &str,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let now = Utc::now().naive_utc();
+        let created_at = datetime_to_str(&now);
+        ActorRepository::upsert_remote_actor(self, actor.clone()).await?;
+        sqlx::query("INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at) VALUES ($1, $2, $3, $4::timestamptz) ON CONFLICT DO NOTHING")
+            .bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        let uid = local_user_id.to_string();
+        let row: Option<String> = sqlx::query_scalar("SELECT follow_activity_id FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
+        Ok(row)
+    }
+
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted'"
+        );
+        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
+    }
+
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(count as usize)
+    }
+
+    async fn get_following_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted' ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query(&q)
+            .bind(&uid)
+            .bind(limit as i64)
+            .bind(offset as i64)
+            .fetch_all(&self.pool)
+            .await?;
+        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
+    }
+
+    async fn update_following_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowingStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = match status {
+            FollowingStatus::Pending => "pending",
+            FollowingStatus::Accepted => "accepted",
+        };
+        let result = sqlx::query("UPDATE ap_following SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
+            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
+        }
+        Ok(())
+    }
+
+    async fn get_following_outbox_url(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        let uid = local_user_id.to_string();
+        let row: Option<Option<String>> = sqlx::query_scalar(
+            "SELECT a.outbox_url FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.remote_actor_url = $2",
+        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
+        Ok(row.flatten())
+    }
+
+    async fn migrate_follower_actor(
+        &self,
+        old_actor_url: &str,
+        new_actor_url: &str,
+    ) -> Result<Vec<uuid::Uuid>> {
+        let candidates: Vec<String> = sqlx::query_scalar(
+            "SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $2)",
+        ).bind(old_actor_url).bind(new_actor_url).fetch_all(&self.pool).await?;
+        if candidates.is_empty() {
+            return Ok(vec![]);
+        }
+        sqlx::query("UPDATE ap_following SET remote_actor_url = $1 WHERE remote_actor_url = $2 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1)")
+            .bind(new_actor_url).bind(old_actor_url).execute(&self.pool).await?;
+        candidates
+            .into_iter()
+            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
+            .collect()
+    }
+}

crates/adapters/postgres-federation/src/lib.rs

@@ -1,31 +1,25 @@
-use anyhow::{Result, anyhow};
-use async_trait::async_trait;
-use chrono::{NaiveDateTime, Utc};
+mod activity;
+mod actor;
+pub mod ap_content;
+mod blocklist;
+mod follow;
+pub mod remote_goals;
+mod review;
+mod social;
+mod watchlist;
+
+pub use ap_content::PostgresApContentQuery;
+pub use remote_goals::PostgresRemoteGoalRepository;
+
+use chrono::NaiveDateTime;
+use k_ap::{FollowerStatus, RemoteActor};
 use sqlx::{PgPool, Row};
 
-use activitypub::RemoteReviewRepository;
-use domain::models::{RemoteWatchlistEntry, Review, ReviewSource};
-use domain::ports::RemoteWatchlistRepository;
-use k_ap::{
-    ActivityRepository, ActorRepository, BlockedDomain, BlocklistRepository, FollowRepository,
-    Follower, FollowerStatus, FollowingStatus, RemoteActor,
-};
-
-fn datetime_to_str(dt: &NaiveDateTime) -> String {
+pub(crate) fn datetime_to_str(dt: &NaiveDateTime) -> String {
     dt.format("%Y-%m-%d %H:%M:%S").to_string()
 }
 
-pub struct PostgresFederationRepository {
-    pool: PgPool,
-}
-
-impl PostgresFederationRepository {
-    pub fn new(pool: PgPool) -> Self {
-        Self { pool }
-    }
-}
-
-fn status_to_str(status: &FollowerStatus) -> &'static str {
+pub(crate) fn status_to_str(status: &FollowerStatus) -> &'static str {
     match status {
         FollowerStatus::Pending => "pending",
         FollowerStatus::Accepted => "accepted",
@@ -33,7 +27,7 @@ fn status_to_str(status: &FollowerStatus) -> &'static str {
     }
 }
 
-fn str_to_status(s: &str) -> FollowerStatus {
+pub(crate) fn str_to_status(s: &str) -> FollowerStatus {
     match s {
         "accepted" => FollowerStatus::Accepted,
         "rejected" => FollowerStatus::Rejected,
@@ -41,7 +35,7 @@ fn str_to_status(s: &str) -> FollowerStatus {
     }
 }
 
-fn pg_remote_actor(row: &sqlx::postgres::PgRow, url_col: &str) -> RemoteActor {
+pub(crate) fn pg_remote_actor(row: &sqlx::postgres::PgRow, url_col: &str) -> RemoteActor {
     RemoteActor {
         url: row.get(url_col),
         handle: row.try_get("handle").unwrap_or_default(),
@@ -69,863 +63,19 @@ fn pg_remote_actor(row: &sqlx::postgres::PgRow, url_col: &str) -> RemoteActor {
     }
 }
 
-const PG_ACTOR_COLS: &str = "a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url, a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at";
+pub(crate) const PG_ACTOR_COLS: &str = "a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url, a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at";
 
-#[async_trait]
-impl FollowRepository for PostgresFederationRepository {
-    async fn add_follower(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowerStatus,
-        follow_activity_id: &str,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = status_to_str(&status);
-        let now = Utc::now().naive_utc();
-        let created_at = datetime_to_str(&now);
-        sqlx::query(
-            "INSERT INTO ap_followers (local_user_id, remote_actor_url, status, created_at, follow_activity_id)
-             VALUES ($1, $2, $3, $4::timestamptz, $5)
-             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET
-                 status = EXCLUDED.status,
-                 follow_activity_id = EXCLUDED.follow_activity_id",
-        )
-        .bind(&uid)
-        .bind(remote_actor_url)
-        .bind(status_str)
-        .bind(&created_at)
-        .bind(follow_activity_id)
-        .execute(&self.pool)
-        .await?;
-        Ok(())
-    }
+pub struct PostgresFederationRepository {
+    pub(crate) pool: PgPool,
+}
 
-    async fn get_follower_follow_activity_id(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<String> = sqlx::query_scalar(
-            "SELECT follow_activity_id FROM ap_followers WHERE local_user_id = $1 AND remote_actor_url = $2",
-        )
-        .bind(&uid)
-        .bind(remote_actor_url)
-        .fetch_optional(&self.pool)
-        .await?;
-        Ok(row)
-    }
-
-    async fn remove_follower(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        sqlx::query("DELETE FROM ap_followers WHERE local_user_id = $1 AND remote_actor_url = $2")
-            .bind(&uid)
-            .bind(remote_actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT f.remote_actor_url, f.status, {PG_ACTOR_COLS}
-             FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1"
-        );
-        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows
-            .iter()
-            .map(|row| {
-                let status_str: String = row.get("status");
-                Follower {
-                    actor: pg_remote_actor(row, "remote_actor_url"),
-                    status: str_to_status(&status_str),
-                }
-            })
-            .collect())
-    }
-
-    async fn get_followers_page(
-        &self,
-        local_user_id: uuid::Uuid,
-        offset: u32,
-        limit: usize,
-    ) -> Result<Vec<Follower>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT f.remote_actor_url, f.status, {PG_ACTOR_COLS}
-             FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'accepted'
-             ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
-        );
-        let rows = sqlx::query(&q)
-            .bind(&uid)
-            .bind(limit as i64)
-            .bind(offset as i64)
-            .fetch_all(&self.pool)
-            .await?;
-        Ok(rows
-            .iter()
-            .map(|row| {
-                let status_str: String = row.get("status");
-                Follower {
-                    actor: pg_remote_actor(row, "remote_actor_url"),
-                    status: str_to_status(&status_str),
-                }
-            })
-            .collect())
-    }
-
-    async fn count_followers(&self, local_user_id: uuid::Uuid) -> Result<usize> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await?;
-        Ok(count as usize)
-    }
-
-    async fn update_follower_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowerStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = status_to_str(&status);
-        let result = sqlx::query(
-            "UPDATE ap_followers SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3",
-        ).bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
-        }
-        Ok(())
-    }
-
-    async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT f.remote_actor_url, {PG_ACTOR_COLS}
-             FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'pending'"
-        );
-        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows
-            .iter()
-            .map(|row| pg_remote_actor(row, "remote_actor_url"))
-            .collect())
-    }
-
-    async fn get_accepted_follower_inboxes(
-        &self,
-        local_user_id: uuid::Uuid,
-    ) -> Result<Vec<String>> {
-        let uid = local_user_id.to_string();
-        let rows = sqlx::query(
-            "SELECT DISTINCT COALESCE(a.shared_inbox_url, a.inbox_url) as inbox
-             FROM ap_followers f
-             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'accepted'
-               AND f.remote_actor_url NOT IN (
-                   SELECT remote_actor_url FROM blocked_actors WHERE local_user_id = $1
-               )",
-        )
-        .bind(&uid)
-        .fetch_all(&self.pool)
-        .await?;
-        Ok(rows
-            .iter()
-            .filter_map(|r| r.try_get::<String, _>("inbox").ok())
-            .collect())
-    }
-
-    async fn count_accepted_followers(&self, local_user_id: uuid::Uuid) -> Result<usize> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await?;
-        Ok(count as usize)
-    }
-
-    async fn get_accepted_followers_page(
-        &self,
-        local_user_id: uuid::Uuid,
-        offset: u32,
-        limit: usize,
-    ) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT f.remote_actor_url, {PG_ACTOR_COLS}
-             FROM ap_followers f LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'accepted'
-             ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
-        );
-        let rows = sqlx::query(&q)
-            .bind(&uid)
-            .bind(limit as i64)
-            .bind(offset as i64)
-            .fetch_all(&self.pool)
-            .await?;
-        Ok(rows
-            .iter()
-            .map(|row| pg_remote_actor(row, "remote_actor_url"))
-            .collect())
-    }
-
-    async fn add_following(
-        &self,
-        local_user_id: uuid::Uuid,
-        actor: RemoteActor,
-        follow_activity_id: &str,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let now = Utc::now().naive_utc();
-        let created_at = datetime_to_str(&now);
-        ActorRepository::upsert_remote_actor(self, actor.clone()).await?;
-        sqlx::query(
-            "INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at)
-             VALUES ($1, $2, $3, $4::timestamptz) ON CONFLICT DO NOTHING",
-        ).bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn get_follow_activity_id(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<String> = sqlx::query_scalar(
-            "SELECT follow_activity_id FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2",
-        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
-        Ok(row)
-    }
-
-    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
-        let uid = local_user_id.to_string();
-        sqlx::query("DELETE FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
-            .bind(&uid)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT a.url, {PG_ACTOR_COLS}
-             FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'accepted'"
-        );
-        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
-    }
-
-    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await?;
-        Ok(count as usize)
-    }
-
-    async fn get_following_page(
-        &self,
-        local_user_id: uuid::Uuid,
-        offset: u32,
-        limit: usize,
-    ) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT a.url, {PG_ACTOR_COLS}
-             FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'accepted'
-             ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
-        );
-        let rows = sqlx::query(&q)
-            .bind(&uid)
-            .bind(limit as i64)
-            .bind(offset as i64)
-            .fetch_all(&self.pool)
-            .await?;
-        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
-    }
-
-    async fn update_following_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowingStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = match status {
-            FollowingStatus::Pending => "pending",
-            FollowingStatus::Accepted => "accepted",
-        };
-        let result = sqlx::query(
-            "UPDATE ap_following SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3",
-        ).bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
-        }
-        Ok(())
-    }
-
-    async fn get_following_outbox_url(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<Option<String>> = sqlx::query_scalar(
-            "SELECT a.outbox_url FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.remote_actor_url = $2",
-        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
-        Ok(row.flatten())
-    }
-
-    async fn migrate_follower_actor(
-        &self,
-        old_actor_url: &str,
-        new_actor_url: &str,
-    ) -> Result<Vec<uuid::Uuid>> {
-        let candidates: Vec<String> = sqlx::query_scalar(
-            "SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1
-               AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $2)",
-        ).bind(old_actor_url).bind(new_actor_url).fetch_all(&self.pool).await?;
-
-        if candidates.is_empty() {
-            return Ok(vec![]);
-        }
-
-        sqlx::query(
-            "UPDATE ap_following SET remote_actor_url = $1 WHERE remote_actor_url = $2
-               AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1)",
-        ).bind(new_actor_url).bind(old_actor_url).execute(&self.pool).await?;
-
-        candidates
-            .into_iter()
-            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
-            .collect()
+impl PostgresFederationRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
     }
 }
 
-#[async_trait]
-impl ActorRepository for PostgresFederationRepository {
-    async fn get_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<Option<(String, String)>> {
-        let uid = user_id.to_string();
-        let row =
-            sqlx::query("SELECT public_key, private_key FROM ap_local_actors WHERE user_id = $1")
-                .bind(&uid)
-                .fetch_optional(&self.pool)
-                .await?;
-        Ok(row.map(|r| (r.get("public_key"), r.get("private_key"))))
-    }
-
-    async fn save_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-        public_key: String,
-        private_key: String,
-    ) -> Result<()> {
-        let uid = user_id.to_string();
-        let now = Utc::now().naive_utc();
-        let created_at = datetime_to_str(&now);
-        sqlx::query(
-            "INSERT INTO ap_local_actors (user_id, public_key, private_key, created_at)
-             VALUES ($1, $2, $3, $4::timestamptz)
-             ON CONFLICT(user_id) DO UPDATE SET public_key = EXCLUDED.public_key, private_key = EXCLUDED.private_key",
-        ).bind(&uid).bind(&public_key).bind(&private_key).bind(&created_at).execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()> {
-        let now = Utc::now().naive_utc();
-        let fetched_at = datetime_to_str(&now);
-        let aka_json = serde_json::to_string(&actor.also_known_as).unwrap_or_default();
-        sqlx::query(
-            "INSERT INTO ap_remote_actors (url, handle, inbox_url, shared_inbox_url, display_name, avatar_url, outbox_url, bio, banner_url, followers_url, following_url, also_known_as, fetched_at)
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13::timestamptz)
-             ON CONFLICT(url) DO UPDATE SET
-                 handle=EXCLUDED.handle, inbox_url=EXCLUDED.inbox_url, shared_inbox_url=EXCLUDED.shared_inbox_url,
-                 display_name=EXCLUDED.display_name, avatar_url=EXCLUDED.avatar_url,
-                 outbox_url=COALESCE(EXCLUDED.outbox_url, ap_remote_actors.outbox_url),
-                 bio=EXCLUDED.bio, banner_url=EXCLUDED.banner_url, followers_url=EXCLUDED.followers_url,
-                 following_url=EXCLUDED.following_url, also_known_as=EXCLUDED.also_known_as, fetched_at=EXCLUDED.fetched_at",
-        )
-        .bind(&actor.url).bind(&actor.handle).bind(&actor.inbox_url).bind(&actor.shared_inbox_url)
-        .bind(&actor.display_name).bind(&actor.avatar_url).bind(&actor.outbox_url)
-        .bind(&actor.bio).bind(&actor.banner_url).bind(&actor.followers_url).bind(&actor.following_url)
-        .bind(&aka_json).bind(&fetched_at)
-        .execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn get_remote_actor(&self, actor_url: &str) -> Result<Option<RemoteActor>> {
-        let q = format!("SELECT url, {PG_ACTOR_COLS} FROM ap_remote_actors a WHERE url = $1");
-        let row = sqlx::query(&q)
-            .bind(actor_url)
-            .fetch_optional(&self.pool)
-            .await?;
-        Ok(row.as_ref().map(|r| pg_remote_actor(r, "url")))
-    }
-
-    async fn add_announce(
-        &self,
-        activity_id: &str,
-        object_url: &str,
-        actor_url: &str,
-        announced_at: chrono::DateTime<chrono::Utc>,
-    ) -> Result<()> {
-        let ts = announced_at.format("%Y-%m-%d %H:%M:%S").to_string();
-        sqlx::query("INSERT INTO ap_announces (id, object_url, actor_url, announced_at) VALUES ($1, $2, $3, $4) ON CONFLICT (id) DO NOTHING")
-            .bind(activity_id).bind(object_url).bind(actor_url).bind(&ts).execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn remove_announce(&self, activity_id: &str, actor_url: &str) -> Result<()> {
-        sqlx::query("DELETE FROM ap_announces WHERE id = $1 AND actor_url = $2")
-            .bind(activity_id)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn count_announces(&self, object_url: &str) -> Result<usize> {
-        let row = sqlx::query("SELECT COUNT(*) as cnt FROM ap_announces WHERE object_url = $1")
-            .bind(object_url)
-            .fetch_one(&self.pool)
-            .await?;
-        Ok(row.get::<i64, _>("cnt") as usize)
-    }
-}
-
-#[async_trait]
-impl BlocklistRepository for PostgresFederationRepository {
-    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()> {
-        let ts = datetime_to_str(&Utc::now().naive_utc());
-        sqlx::query("INSERT INTO blocked_domains (domain, reason, blocked_at) VALUES ($1, $2, $3) ON CONFLICT(domain) DO UPDATE SET reason = EXCLUDED.reason")
-            .bind(domain).bind(reason).bind(&ts).execute(&self.pool).await?;
-        Ok(())
-    }
-    async fn remove_blocked_domain(&self, domain: &str) -> Result<()> {
-        sqlx::query("DELETE FROM blocked_domains WHERE domain = $1")
-            .bind(domain)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-    async fn get_blocked_domains(&self) -> Result<Vec<BlockedDomain>> {
-        let rows = sqlx::query(
-            "SELECT domain, reason, blocked_at FROM blocked_domains ORDER BY blocked_at DESC",
-        )
-        .fetch_all(&self.pool)
-        .await?;
-        Ok(rows
-            .iter()
-            .map(|r| BlockedDomain {
-                domain: r.get("domain"),
-                reason: r.get("reason"),
-                blocked_at: r.get("blocked_at"),
-            })
-            .collect())
-    }
-    async fn is_domain_blocked(&self, domain: &str) -> Result<bool> {
-        let count: i64 =
-            sqlx::query_scalar("SELECT COUNT(*) FROM blocked_domains WHERE domain = $1")
-                .bind(domain)
-                .fetch_one(&self.pool)
-                .await?;
-        Ok(count > 0)
-    }
-    async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let ts = datetime_to_str(&Utc::now().naive_utc());
-        sqlx::query("INSERT INTO blocked_actors (local_user_id, remote_actor_url, blocked_at) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING")
-            .bind(&uid).bind(actor_url).bind(&ts).execute(&self.pool).await?;
-        Ok(())
-    }
-    async fn remove_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
-        let uid = local_user_id.to_string();
-        sqlx::query(
-            "DELETE FROM blocked_actors WHERE local_user_id = $1 AND remote_actor_url = $2",
-        )
-        .bind(&uid)
-        .bind(actor_url)
-        .execute(&self.pool)
-        .await?;
-        Ok(())
-    }
-    async fn get_blocked_actors(&self, local_user_id: uuid::Uuid) -> Result<Vec<String>> {
-        let uid = local_user_id.to_string();
-        let rows = sqlx::query("SELECT remote_actor_url FROM blocked_actors WHERE local_user_id = $1 ORDER BY blocked_at DESC")
-            .bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows
-            .iter()
-            .map(|r| r.get::<String, _>("remote_actor_url"))
-            .collect())
-    }
-    async fn is_actor_blocked(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<bool> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM blocked_actors WHERE local_user_id = $1 AND remote_actor_url = $2")
-            .bind(&uid).bind(actor_url).fetch_one(&self.pool).await?;
-        Ok(count > 0)
-    }
-}
-
-#[async_trait]
-impl ActivityRepository for PostgresFederationRepository {
-    async fn is_activity_processed(&self, activity_id: &str) -> Result<bool> {
-        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM ap_activities WHERE id = $1")
-            .bind(activity_id)
-            .fetch_one(&self.pool)
-            .await?;
-        Ok(count > 0)
-    }
-    async fn mark_activity_processed(&self, activity_id: &str) -> Result<()> {
-        let ts = datetime_to_str(&Utc::now().naive_utc());
-        sqlx::query(
-            "INSERT INTO ap_activities (id, processed_at) VALUES ($1, $2) ON CONFLICT DO NOTHING",
-        )
-        .bind(activity_id)
-        .bind(&ts)
-        .execute(&self.pool)
-        .await?;
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl RemoteReviewRepository for PostgresFederationRepository {
-    async fn save_remote_review(
-        &self,
-        review: &Review,
-        ap_id: &str,
-        movie_title: &str,
-        release_year: u16,
-        poster_url: Option<&str>,
-    ) -> Result<()> {
-        let actor_url = match review.source() {
-            ReviewSource::Remote { actor_url } => actor_url.clone(),
-            ReviewSource::Local => {
-                return Err(anyhow!("save_remote_review called with a local review"));
-            }
-        };
-        let movie_id = review.movie_id().value().to_string();
-        sqlx::query(
-            "INSERT INTO movies (id, external_metadata_id, title, release_year, director, poster_path)
-             VALUES ($1, NULL, $2, $3, NULL, $4)
-             ON CONFLICT(id) DO UPDATE SET
-                 poster_path = COALESCE(EXCLUDED.poster_path, movies.poster_path)",
-        )
-        .bind(&movie_id)
-        .bind(movie_title)
-        .bind(release_year.max(1888) as i64)
-        .bind(poster_url)
-        .execute(&self.pool)
-        .await?;
-
-        let id = review.id().value().to_string();
-        let user_id = review.user_id().value().to_string();
-        let rating = review.rating().value() as i64;
-        let comment = review.comment().map(|c| c.value().to_string());
-        let watched_at = datetime_to_str(review.watched_at());
-        let created_at = datetime_to_str(review.created_at());
-        sqlx::query(
-            "INSERT INTO reviews (id, movie_id, user_id, rating, comment, watched_at, created_at, remote_actor_url, ap_id)
-             VALUES ($1, $2, $3, $4, $5, $6::timestamptz, $7::timestamptz, $8, $9)
-             ON CONFLICT DO NOTHING",
-        )
-        .bind(&id)
-        .bind(&movie_id)
-        .bind(&user_id)
-        .bind(rating)
-        .bind(&comment)
-        .bind(&watched_at)
-        .bind(&created_at)
-        .bind(&actor_url)
-        .bind(ap_id)
-        .execute(&self.pool)
-        .await?;
-        Ok(())
-    }
-
-    async fn delete_remote_review(&self, ap_id: &str, actor_url: &str) -> Result<()> {
-        sqlx::query("DELETE FROM reviews WHERE ap_id = $1 AND remote_actor_url = $2")
-            .bind(ap_id)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn update_remote_review(
-        &self,
-        ap_id: &str,
-        actor_url: &str,
-        rating: u8,
-        comment: Option<&str>,
-        watched_at: chrono::NaiveDateTime,
-        poster_url: Option<&str>,
-    ) -> Result<()> {
-        let watched_at_str = datetime_to_str(&watched_at);
-        sqlx::query(
-            "UPDATE reviews SET rating = $1, comment = $2, watched_at = $3::timestamptz
-             WHERE ap_id = $4 AND remote_actor_url = $5",
-        )
-        .bind(rating as i64)
-        .bind(comment)
-        .bind(&watched_at_str)
-        .bind(ap_id)
-        .bind(actor_url)
-        .execute(&self.pool)
-        .await?;
-        if let Some(url) = poster_url {
-            sqlx::query(
-                "UPDATE movies SET poster_path = $1
-                 WHERE id = (SELECT movie_id FROM reviews WHERE ap_id = $2 AND remote_actor_url = $3)",
-            )
-            .bind(url)
-            .bind(ap_id)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        }
-        Ok(())
-    }
-
-    async fn delete_by_actor(&self, actor_url: &str) -> Result<()> {
-        sqlx::query("DELETE FROM reviews WHERE remote_actor_url = $1")
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl domain::ports::SocialQueryPort for PostgresFederationRepository {
-    async fn get_accepted_following_urls(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<Vec<String>, domain::errors::DomainError> {
-        let user_id_str = user_id.to_string();
-        sqlx::query_scalar::<_, String>(
-            "SELECT remote_actor_url FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&user_id_str)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))
-    }
-
-    async fn list_all_followed_remote_actors(
-        &self,
-    ) -> Result<Vec<domain::models::RemoteActorInfo>, domain::errors::DomainError> {
-        let rows = sqlx::query_as::<_, (String, String, Option<String>)>(
-            "SELECT DISTINCT ar.url, ar.handle, ar.display_name
-             FROM ap_remote_actors ar
-             JOIN ap_following f ON f.remote_actor_url = ar.url
-             WHERE f.status = 'accepted'",
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(rows
-            .into_iter()
-            .map(
-                |(url, handle, display_name)| domain::models::RemoteActorInfo {
-                    url,
-                    handle,
-                    display_name,
-                },
-            )
-            .collect())
-    }
-
-    async fn count_following(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<usize, domain::errors::DomainError> {
-        let uid = user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn count_accepted_followers(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<usize, domain::errors::DomainError> {
-        let uid = user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn get_pending_followers(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<Vec<domain::models::PendingFollowerInfo>, domain::errors::DomainError> {
-        let uid = user_id.to_string();
-        let rows = sqlx::query_as::<_, (String, String, Option<String>, Option<String>)>(
-            "SELECT ar.url, ar.handle, ar.display_name, ar.avatar_url
-             FROM ap_followers f
-             JOIN ap_remote_actors ar ON ar.url = f.remote_actor_url
-             WHERE f.local_user_id = $1 AND f.status = 'pending'",
-        )
-        .bind(&uid)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(rows
-            .into_iter()
-            .map(
-                |(url, handle, display_name, avatar_url)| domain::models::PendingFollowerInfo {
-                    url,
-                    handle,
-                    display_name,
-                    avatar_url,
-                },
-            )
-            .collect())
-    }
-}
-
-#[async_trait]
-impl RemoteWatchlistRepository for PostgresFederationRepository {
-    async fn save(&self, entry: RemoteWatchlistEntry) -> Result<(), domain::errors::DomainError> {
-        sqlx::query(
-            "INSERT INTO ap_remote_watchlist_entries \
-             (ap_id, actor_url, movie_title, release_year, external_metadata_id, poster_url, added_at) \
-             VALUES ($1, $2, $3, $4, $5, $6, $7) \
-             ON CONFLICT(ap_id) DO UPDATE SET \
-               movie_title=excluded.movie_title, release_year=excluded.release_year, \
-               external_metadata_id=excluded.external_metadata_id, poster_url=excluded.poster_url",
-        )
-        .bind(&entry.ap_id)
-        .bind(&entry.actor_url)
-        .bind(&entry.movie_title)
-        .bind(entry.release_year as i32)
-        .bind(&entry.external_metadata_id)
-        .bind(&entry.poster_url)
-        .bind(entry.added_at)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(())
-    }
-
-    async fn remove_by_ap_id(
-        &self,
-        ap_id: &str,
-        actor_url: &str,
-    ) -> Result<(), domain::errors::DomainError> {
-        sqlx::query("DELETE FROM ap_remote_watchlist_entries WHERE ap_id = $1 AND actor_url = $2")
-            .bind(ap_id)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await
-            .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(())
-    }
-
-    async fn get_by_actor_url(
-        &self,
-        actor_url: &str,
-    ) -> Result<Vec<RemoteWatchlistEntry>, domain::errors::DomainError> {
-        let rows = sqlx::query(
-            "SELECT ap_id, actor_url, movie_title, release_year, external_metadata_id, poster_url, added_at \
-             FROM ap_remote_watchlist_entries WHERE actor_url = $1 ORDER BY added_at DESC",
-        )
-        .bind(actor_url)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-
-        rows.into_iter()
-            .map(|row| {
-                Ok(RemoteWatchlistEntry {
-                    ap_id: row.try_get("ap_id").unwrap_or_default(),
-                    actor_url: row.try_get("actor_url").unwrap_or_default(),
-                    movie_title: row.try_get("movie_title").unwrap_or_default(),
-                    release_year: row.try_get::<i32, _>("release_year").unwrap_or(0) as u16,
-                    external_metadata_id: row.try_get("external_metadata_id").ok().flatten(),
-                    poster_url: row.try_get("poster_url").ok().flatten(),
-                    added_at: row
-                        .try_get::<chrono::DateTime<chrono::Utc>, _>("added_at")
-                        .unwrap_or_else(|_| chrono::Utc::now()),
-                })
-            })
-            .collect()
-    }
-
-    async fn remove_all_by_actor(
-        &self,
-        actor_url: &str,
-    ) -> Result<(), domain::errors::DomainError> {
-        sqlx::query("DELETE FROM ap_remote_watchlist_entries WHERE actor_url = $1")
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await
-            .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?;
-        Ok(())
-    }
-
-    async fn get_by_derived_uuid(
-        &self,
-        uuid: uuid::Uuid,
-    ) -> Result<Vec<RemoteWatchlistEntry>, domain::errors::DomainError> {
-        let actors: Vec<String> =
-            sqlx::query("SELECT DISTINCT actor_url FROM ap_remote_watchlist_entries")
-                .fetch_all(&self.pool)
-                .await
-                .map_err(|e| domain::errors::DomainError::InfrastructureError(e.to_string()))?
-                .into_iter()
-                .filter_map(|row| row.try_get::<String, _>("actor_url").ok())
-                .collect();
-
-        let target = actors
-            .into_iter()
-            .find(|url| uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, url.as_bytes()) == uuid);
-
-        match target {
-            None => Ok(vec![]),
-            Some(actor_url) => self.get_by_actor_url(&actor_url).await,
-        }
-    }
-}
-
-pub fn wire(pool: sqlx::PgPool) -> activitypub::FederationRepos {
+pub fn wire(pool: PgPool) -> activitypub::FederationRepos {
     let fed = std::sync::Arc::new(PostgresFederationRepository::new(pool));
     (
         std::sync::Arc::clone(&fed) as _,

crates/adapters/postgres-federation/src/remote_goals.rs

@@ -0,0 +1,119 @@
+use async_trait::async_trait;
+use chrono::TimeZone;
+use domain::{errors::DomainError, models::RemoteGoalEntry, ports::RemoteGoalRepository};
+use sqlx::{PgPool, Row};
+
+pub struct PostgresRemoteGoalRepository {
+    pool: PgPool,
+}
+
+impl PostgresRemoteGoalRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+
+    fn map_err(e: sqlx::Error) -> DomainError {
+        tracing::error!("Database error: {:?}", e);
+        DomainError::InfrastructureError("Database operation failed".into())
+    }
+}
+
+#[async_trait]
+impl RemoteGoalRepository for PostgresRemoteGoalRepository {
+    async fn save(&self, entry: RemoteGoalEntry) -> Result<(), DomainError> {
+        let received = entry.received_at.format("%Y-%m-%d %H:%M:%S").to_string();
+
+        sqlx::query(
+            "INSERT INTO remote_goals \
+             (ap_id, actor_url, year, target_count, current_count, received_at) \
+             VALUES ($1, $2, $3, $4, $5, $6::timestamptz) \
+             ON CONFLICT (ap_id) DO UPDATE SET \
+             target_count = $4, current_count = $5",
+        )
+        .bind(&entry.ap_id)
+        .bind(&entry.actor_url)
+        .bind(entry.year as i64)
+        .bind(entry.target_count as i64)
+        .bind(entry.current_count as i64)
+        .bind(&received)
+        .execute(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        Ok(())
+    }
+
+    async fn update_by_ap_id(
+        &self,
+        ap_id: &str,
+        target: u32,
+        current: u32,
+    ) -> Result<(), DomainError> {
+        sqlx::query(
+            "UPDATE remote_goals SET target_count = $1, current_count = $2 WHERE ap_id = $3",
+        )
+        .bind(target as i64)
+        .bind(current as i64)
+        .bind(ap_id)
+        .execute(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        Ok(())
+    }
+
+    async fn remove_by_ap_id(&self, ap_id: &str, actor_url: &str) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM remote_goals WHERE ap_id = $1 AND actor_url = $2")
+            .bind(ap_id)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(Self::map_err)?;
+
+        Ok(())
+    }
+
+    async fn remove_all_by_actor(&self, actor_url: &str) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM remote_goals WHERE actor_url = $1")
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(Self::map_err)?;
+
+        Ok(())
+    }
+
+    async fn get_by_actor_url(&self, actor_url: &str) -> Result<Vec<RemoteGoalEntry>, DomainError> {
+        let rows = sqlx::query(
+            "SELECT ap_id, actor_url, year, target_count, current_count, \
+             to_char(received_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS received_at \
+             FROM remote_goals WHERE actor_url = $1 ORDER BY year DESC",
+        )
+        .bind(actor_url)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        rows.iter()
+            .map(|r| {
+                let year: i64 = r.try_get("year").unwrap_or(0);
+                let target: i64 = r.try_get("target_count").unwrap_or(0);
+                let current: i64 = r.try_get("current_count").unwrap_or(0);
+                let received_str: String = r.try_get("received_at").unwrap_or_default();
+                let received_at =
+                    chrono::NaiveDateTime::parse_from_str(&received_str, "%Y-%m-%d %H:%M:%S")
+                        .map(|ndt| chrono::Utc.from_utc_datetime(&ndt))
+                        .unwrap_or_else(|_| chrono::Utc::now());
+
+                Ok(RemoteGoalEntry {
+                    ap_id: r.try_get("ap_id").unwrap_or_default(),
+                    actor_url: r.try_get("actor_url").unwrap_or_default(),
+                    year: year as u16,
+                    target_count: target as u32,
+                    current_count: current as u32,
+                    received_at,
+                })
+            })
+            .collect()
+    }
+}

crates/adapters/postgres-federation/src/review.rs

@@ -0,0 +1,116 @@
+use activitypub::RemoteReviewRepository;
+use anyhow::{Result, anyhow};
+use async_trait::async_trait;
+use domain::models::{Review, ReviewSource};
+
+use super::{PostgresFederationRepository, datetime_to_str};
+
+#[async_trait]
+impl RemoteReviewRepository for PostgresFederationRepository {
+    async fn save_remote_review(
+        &self,
+        review: &Review,
+        ap_id: &str,
+        movie_title: &str,
+        release_year: u16,
+        external_metadata_id: Option<&str>,
+        poster_url: Option<&str>,
+    ) -> Result<()> {
+        let actor_url = match review.source() {
+            ReviewSource::Remote { actor_url } => actor_url.clone(),
+            ReviewSource::Local => {
+                return Err(anyhow!("save_remote_review called with a local review"));
+            }
+        };
+        let movie_id = review.movie_id().value().to_string();
+        sqlx::query(
+            "INSERT INTO movies (id, external_metadata_id, title, release_year, director, poster_path)
+             VALUES ($1, $2, $3, $4, NULL, $5)
+             ON CONFLICT(id) DO UPDATE SET
+                 external_metadata_id = COALESCE(EXCLUDED.external_metadata_id, movies.external_metadata_id),
+                 poster_path = COALESCE(EXCLUDED.poster_path, movies.poster_path)",
+        )
+        .bind(&movie_id)
+        .bind(external_metadata_id)
+        .bind(movie_title)
+        .bind(release_year.max(1888) as i64)
+        .bind(poster_url)
+        .execute(&self.pool)
+        .await?;
+
+        let id = review.id().value().to_string();
+        let user_id = review.user_id().value().to_string();
+        let rating = review.rating().value() as i64;
+        let comment = review.comment().map(|c| c.value().to_string());
+        let watched_at = datetime_to_str(review.watched_at());
+        let created_at = datetime_to_str(review.created_at());
+        sqlx::query(
+            "INSERT INTO reviews (id, movie_id, user_id, rating, comment, watched_at, created_at, remote_actor_url, ap_id)
+             VALUES ($1, $2, $3, $4, $5, $6::timestamptz, $7::timestamptz, $8, $9) ON CONFLICT DO NOTHING",
+        )
+        .bind(&id)
+        .bind(&movie_id)
+        .bind(&user_id)
+        .bind(rating)
+        .bind(&comment)
+        .bind(&watched_at)
+        .bind(&created_at)
+        .bind(&actor_url)
+        .bind(ap_id)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+
+    async fn delete_remote_review(&self, ap_id: &str, actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM reviews WHERE ap_id = $1 AND remote_actor_url = $2")
+            .bind(ap_id)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn update_remote_review(
+        &self,
+        ap_id: &str,
+        actor_url: &str,
+        rating: u8,
+        comment: Option<&str>,
+        watched_at: chrono::NaiveDateTime,
+        poster_url: Option<&str>,
+    ) -> Result<()> {
+        let watched_at_str = datetime_to_str(&watched_at);
+        sqlx::query(
+            "UPDATE reviews SET rating = $1, comment = $2, watched_at = $3::timestamptz
+             WHERE ap_id = $4 AND remote_actor_url = $5",
+        )
+        .bind(rating as i64)
+        .bind(comment)
+        .bind(&watched_at_str)
+        .bind(ap_id)
+        .bind(actor_url)
+        .execute(&self.pool)
+        .await?;
+        if let Some(url) = poster_url {
+            sqlx::query(
+                "UPDATE movies SET poster_path = $1
+                 WHERE id = (SELECT movie_id FROM reviews WHERE ap_id = $2 AND remote_actor_url = $3)",
+            )
+            .bind(url)
+            .bind(ap_id)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        }
+        Ok(())
+    }
+
+    async fn delete_by_actor(&self, actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM reviews WHERE remote_actor_url = $1")
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+}

crates/adapters/postgres-federation/src/social.rs

@@ -0,0 +1,81 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::{PendingFollowerInfo, RemoteActorInfo},
+    ports::SocialQueryPort,
+};
+
+use super::PostgresFederationRepository;
+
+#[async_trait]
+impl SocialQueryPort for PostgresFederationRepository {
+    async fn get_accepted_following_urls(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Vec<String>, DomainError> {
+        let user_id_str = user_id.to_string();
+        sqlx::query_scalar::<_, String>(
+            "SELECT remote_actor_url FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
+        ).bind(&user_id_str).fetch_all(&self.pool).await
+         .map_err(|e| DomainError::InfrastructureError(e.to_string()))
+    }
+
+    async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError> {
+        let rows = sqlx::query_as::<_, (String, String, Option<String>)>(
+            "SELECT DISTINCT ar.url, ar.handle, ar.display_name FROM ap_remote_actors ar JOIN ap_following f ON f.remote_actor_url = ar.url WHERE f.status = 'accepted'",
+        ).fetch_all(&self.pool).await.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(rows
+            .into_iter()
+            .map(|(url, handle, display_name)| RemoteActorInfo {
+                url,
+                handle,
+                display_name,
+            })
+            .collect())
+    }
+
+    async fn count_following(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(count as usize)
+    }
+
+    async fn count_accepted_followers(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(count as usize)
+    }
+
+    async fn get_pending_followers(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Vec<PendingFollowerInfo>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query_as::<_, (String, String, Option<String>, Option<String>)>(
+            "SELECT ar.url, ar.handle, ar.display_name, ar.avatar_url FROM ap_followers f JOIN ap_remote_actors ar ON ar.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'pending'",
+        ).bind(&uid).fetch_all(&self.pool).await.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(rows
+            .into_iter()
+            .map(
+                |(url, handle, display_name, avatar_url)| PendingFollowerInfo {
+                    url,
+                    handle,
+                    display_name,
+                    avatar_url,
+                },
+            )
+            .collect())
+    }
+}

crates/adapters/postgres-federation/src/watchlist.rs

@@ -0,0 +1,91 @@
+use async_trait::async_trait;
+use domain::{errors::DomainError, models::RemoteWatchlistEntry, ports::RemoteWatchlistRepository};
+use sqlx::Row;
+
+use super::PostgresFederationRepository;
+
+#[async_trait]
+impl RemoteWatchlistRepository for PostgresFederationRepository {
+    async fn save(&self, entry: RemoteWatchlistEntry) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO ap_remote_watchlist_entries \
+             (ap_id, actor_url, movie_title, release_year, external_metadata_id, poster_url, added_at) \
+             VALUES ($1, $2, $3, $4, $5, $6, $7) \
+             ON CONFLICT(ap_id) DO UPDATE SET \
+               movie_title=excluded.movie_title, release_year=excluded.release_year, \
+               external_metadata_id=excluded.external_metadata_id, poster_url=excluded.poster_url",
+        )
+        .bind(&entry.ap_id).bind(&entry.actor_url).bind(&entry.movie_title)
+        .bind(entry.release_year as i32).bind(&entry.external_metadata_id).bind(&entry.poster_url)
+        .bind(entry.added_at)
+        .execute(&self.pool).await
+        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn remove_by_ap_id(&self, ap_id: &str, actor_url: &str) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM ap_remote_watchlist_entries WHERE ap_id = $1 AND actor_url = $2")
+            .bind(ap_id)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn get_by_actor_url(
+        &self,
+        actor_url: &str,
+    ) -> Result<Vec<RemoteWatchlistEntry>, DomainError> {
+        let rows = sqlx::query(
+            "SELECT ap_id, actor_url, movie_title, release_year, external_metadata_id, poster_url, added_at \
+             FROM ap_remote_watchlist_entries WHERE actor_url = $1 ORDER BY added_at DESC",
+        ).bind(actor_url).fetch_all(&self.pool).await
+         .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        rows.into_iter()
+            .map(|row| {
+                Ok(RemoteWatchlistEntry {
+                    ap_id: row.try_get("ap_id").unwrap_or_default(),
+                    actor_url: row.try_get("actor_url").unwrap_or_default(),
+                    movie_title: row.try_get("movie_title").unwrap_or_default(),
+                    release_year: row.try_get::<i32, _>("release_year").unwrap_or(0) as u16,
+                    external_metadata_id: row.try_get("external_metadata_id").ok().flatten(),
+                    poster_url: row.try_get("poster_url").ok().flatten(),
+                    added_at: row
+                        .try_get::<chrono::DateTime<chrono::Utc>, _>("added_at")
+                        .unwrap_or_else(|_| chrono::Utc::now()),
+                })
+            })
+            .collect()
+    }
+
+    async fn remove_all_by_actor(&self, actor_url: &str) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM ap_remote_watchlist_entries WHERE actor_url = $1")
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn get_by_derived_uuid(
+        &self,
+        uuid: uuid::Uuid,
+    ) -> Result<Vec<RemoteWatchlistEntry>, DomainError> {
+        let actors: Vec<String> =
+            sqlx::query("SELECT DISTINCT actor_url FROM ap_remote_watchlist_entries")
+                .fetch_all(&self.pool)
+                .await
+                .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
+                .into_iter()
+                .filter_map(|row| row.try_get::<String, _>("actor_url").ok())
+                .collect();
+        let target = actors
+            .into_iter()
+            .find(|url| uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, url.as_bytes()) == uuid);
+        match target {
+            None => Ok(vec![]),
+            Some(actor_url) => self.get_by_actor_url(&actor_url).await,
+        }
+    }
+}