making it AP complaint

crates/adapters/postgres/Cargo.toml

@@ -12,6 +12,7 @@ sqlx = { version = "0.8.6", features = [
     "chrono",
 ] }
 domain      = { workspace = true }
+postgres-federation = { workspace = true }
 anyhow      = { workspace = true }
 uuid        = { workspace = true }
 chrono      = { workspace = true }

crates/adapters/postgres/src/ap_content.rs

@@ -1,258 +0,0 @@
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    models::{DiaryEntry, Movie, Review, WatchlistEntry, WatchlistWithMovie},
-    ports::LocalApContentQuery,
-    value_objects::{MovieId, ReviewId, UserId, WatchlistEntryId},
-};
-use sqlx::{PgPool, Row};
-
-use crate::models::{DiaryRow, MovieRow, ReviewRow, parse_datetime, parse_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())
-    }
-}
-
-#[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 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<(domain::models::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 = crate::goals::row_to_goal(&r)?;
-        let count = crate::goals::count_reviews_in_year(&self.pool, user_id, year).await?;
-
-        Ok(Some((goal, count)))
-    }
-}

crates/adapters/postgres/src/lib.rs

@@ -1,7 +1,6 @@
 use domain::errors::DomainError;
 use sqlx::PgPool;
 
-mod ap_content;
 mod diary;
 mod goals;
 mod image_ref;
@@ -9,11 +8,11 @@ mod import_profile;
 mod import_session;
 mod models;
 mod movie;
+mod movie_dedup;
 mod persons;
 mod profile;
 mod profile_fields;
 mod refresh_sessions;
-mod remote_goals;
 mod review;
 mod stats;
 mod user_settings;
@@ -22,13 +21,14 @@ mod watch_event;
 mod watchlist;
 mod wrapup;
 
-pub use ap_content::PostgresApContentQuery;
 pub use diary::PostgresDiaryRepository;
 pub use image_ref::{PostgresImageRefAdapter, create_image_ref};
 pub use import_profile::PostgresImportProfileRepository;
 pub use import_session::PostgresImportSessionRepository;
 pub use movie::PostgresMovieRepository;
+pub use movie_dedup::PostgresMovieDeduplicator;
 pub use persons::{PostgresPersonAdapter, create_person_adapter};
+pub use postgres_federation::PostgresApContentQuery;
 pub use profile::PostgresMovieProfileRepository;
 pub use profile_fields::PostgresProfileFieldsRepository;
 pub use refresh_sessions::PostgresRefreshSessionAdapter;
@@ -95,6 +95,7 @@ pub struct PostgresWireOutput {
     pub user_settings: std::sync::Arc<dyn domain::ports::UserSettingsRepository>,
     pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
     pub remote_goal: std::sync::Arc<dyn domain::ports::RemoteGoalRepository>,
+    pub deduplicator: std::sync::Arc<dyn domain::ports::MovieDeduplicator>,
 }
 
 pub async fn wire(database_url: &str) -> anyhow::Result<PostgresWireOutput> {
@@ -132,7 +133,9 @@ pub async fn wire(database_url: &str) -> anyhow::Result<PostgresWireOutput> {
         goal: std::sync::Arc::new(goals::PostgresGoalRepository::new(pool.clone())) as _,
         user_settings: std::sync::Arc::clone(&user_settings_repo) as _,
         federation_settings: user_settings_repo as _,
-        remote_goal: std::sync::Arc::new(remote_goals::PostgresRemoteGoalRepository::new(pool))
-            as _,
+        remote_goal: std::sync::Arc::new(postgres_federation::PostgresRemoteGoalRepository::new(
+            pool.clone(),
+        )) as _,
+        deduplicator: std::sync::Arc::new(PostgresMovieDeduplicator::new(pool)) as _,
     })
 }

crates/adapters/postgres/src/movie.rs

@@ -239,4 +239,17 @@ impl MovieRepository for PostgresMovieRepository {
             offset: page.offset,
         })
     }
+
+    async fn list_movies_with_external_id(&self) -> Result<Vec<Movie>, DomainError> {
+        sqlx::query_as::<_, MovieRow>(
+            "SELECT id, external_metadata_id, title, release_year, director, poster_path
+             FROM movies WHERE external_metadata_id IS NOT NULL",
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .into_iter()
+        .map(|r| r.into_domain())
+        .collect()
+    }
 }

crates/adapters/postgres/src/movie_dedup.rs

@@ -0,0 +1,154 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError, models::Movie, ports::MovieDeduplicator, value_objects::MovieId,
+};
+use sqlx::PgPool;
+
+pub struct PostgresMovieDeduplicator {
+    pool: PgPool,
+}
+
+impl PostgresMovieDeduplicator {
+    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 MovieDeduplicator for PostgresMovieDeduplicator {
+    async fn merge_into_canonical(
+        &self,
+        old_id: &MovieId,
+        canonical: &Movie,
+    ) -> Result<u64, DomainError> {
+        let old = old_id.value().to_string();
+        let new = canonical.id().value().to_string();
+        let ext_id = canonical
+            .external_metadata_id()
+            .map(|id| id.value().to_string());
+        let title = canonical.title().value().to_string();
+        let year = canonical.release_year().value() as i64;
+        let director = canonical.director().map(str::to_string);
+        let poster = canonical.poster_path().map(|p| p.value().to_string());
+
+        let mut tx = self.pool.begin().await.map_err(Self::map_err)?;
+
+        // 1. Upsert canonical movie record
+        sqlx::query(
+            "INSERT INTO movies (id, external_metadata_id, title, release_year, director, poster_path)
+             VALUES ($1, $2, $3, $4, $5, $6)
+             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(&new).bind(&ext_id).bind(&title).bind(year).bind(&director).bind(&poster)
+        .execute(&mut *tx).await.map_err(Self::map_err)?;
+
+        // 2. Re-point simple FK tables
+        let reviews = sqlx::query("UPDATE reviews SET movie_id = $1 WHERE movie_id = $2")
+            .bind(&new)
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?
+            .rows_affected();
+
+        let watchlist =
+            sqlx::query("UPDATE watchlist_entries SET movie_id = $1 WHERE movie_id = $2")
+                .bind(&new)
+                .bind(&old)
+                .execute(&mut *tx)
+                .await
+                .map_err(Self::map_err)?
+                .rows_affected();
+
+        let watch_events = sqlx::query("UPDATE watch_events SET movie_id = $1 WHERE movie_id = $2")
+            .bind(&new)
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?
+            .rows_affected();
+
+        // 3. Re-point movie_profiles (PK — move only if canonical has none)
+        let profiles = sqlx::query("UPDATE movie_profiles SET movie_id = $1 WHERE movie_id = $2")
+            .bind(&new)
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?
+            .rows_affected();
+
+        // 4. Re-point enrichment tables with composite PKs (INSERT … ON CONFLICT DO NOTHING + DELETE)
+        //    Canonical's existing rows win on conflict — old duplicates are discarded.
+        sqlx::query(
+            "INSERT INTO movie_genres (movie_id, tmdb_id, name)
+             SELECT $1, tmdb_id, name FROM movie_genres WHERE movie_id = $2
+             ON CONFLICT DO NOTHING",
+        )
+        .bind(&new)
+        .bind(&old)
+        .execute(&mut *tx)
+        .await
+        .map_err(Self::map_err)?;
+        sqlx::query("DELETE FROM movie_genres WHERE movie_id = $1")
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?;
+
+        sqlx::query(
+            "INSERT INTO movie_keywords (movie_id, tmdb_id, name)
+             SELECT $1, tmdb_id, name FROM movie_keywords WHERE movie_id = $2
+             ON CONFLICT DO NOTHING",
+        )
+        .bind(&new)
+        .bind(&old)
+        .execute(&mut *tx)
+        .await
+        .map_err(Self::map_err)?;
+        sqlx::query("DELETE FROM movie_keywords WHERE movie_id = $1")
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?;
+
+        sqlx::query(
+            "INSERT INTO movie_cast (movie_id, tmdb_person_id, name, character, billing_order, profile_path)
+             SELECT $1, tmdb_person_id, name, character, billing_order, profile_path FROM movie_cast WHERE movie_id = $2
+             ON CONFLICT DO NOTHING",
+        ).bind(&new).bind(&old).execute(&mut *tx).await.map_err(Self::map_err)?;
+        sqlx::query("DELETE FROM movie_cast WHERE movie_id = $1")
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?;
+
+        sqlx::query(
+            "INSERT INTO movie_crew (movie_id, tmdb_person_id, name, job, department, profile_path)
+             SELECT $1, tmdb_person_id, name, job, department, profile_path FROM movie_crew WHERE movie_id = $2
+             ON CONFLICT DO NOTHING",
+        ).bind(&new).bind(&old).execute(&mut *tx).await.map_err(Self::map_err)?;
+        sqlx::query("DELETE FROM movie_crew WHERE movie_id = $1")
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?;
+
+        // 5. Delete the now-empty old movie record (remaining cascades are safe: all FKs cleared above)
+        sqlx::query("DELETE FROM movies WHERE id = $1")
+            .bind(&old)
+            .execute(&mut *tx)
+            .await
+            .map_err(Self::map_err)?;
+
+        tx.commit().await.map_err(Self::map_err)?;
+
+        Ok(reviews + watchlist + watch_events + profiles)
+    }
+}

crates/adapters/postgres/src/remote_goals.rs

@@ -1,119 +0,0 @@
-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()
-    }
-}