feat: MovieDto enrichment, movie detail page, PWA, watchlist, watchlist federation

crates/adapters/sqlite/src/watchlist.rs

@@ -0,0 +1,154 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::{WatchlistEntry, WatchlistWithMovie, collections::{PageParams, Paginated}},
+    ports::WatchlistRepository,
+    value_objects::{MovieId, UserId},
+};
+use sqlx::{Row, SqlitePool};
+
+use crate::models::{WatchlistRow, datetime_to_str};
+
+pub struct SqliteWatchlistRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteWatchlistRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+
+    fn map_err(e: sqlx::Error) -> DomainError {
+        tracing::error!("Database error: {:?}", e);
+        DomainError::InfrastructureError("Database operation failed".into())
+    }
+}
+
+#[async_trait]
+impl WatchlistRepository for SqliteWatchlistRepository {
+    async fn add(&self, entry: &WatchlistEntry) -> Result<(), DomainError> {
+        let id = entry.id.value().to_string();
+        let user_id = entry.user_id.value().to_string();
+        let movie_id = entry.movie_id.value().to_string();
+        let added_at = datetime_to_str(&entry.added_at);
+
+        sqlx::query(
+            "INSERT OR IGNORE INTO watchlist_entries (id, user_id, movie_id, added_at) \
+             VALUES (?, ?, ?, ?)",
+        )
+        .bind(&id)
+        .bind(&user_id)
+        .bind(&movie_id)
+        .bind(&added_at)
+        .execute(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        Ok(())
+    }
+
+    async fn remove(&self, user_id: &UserId, movie_id: &MovieId) -> Result<(), DomainError> {
+        let uid = user_id.value().to_string();
+        let mid = movie_id.value().to_string();
+
+        let result = sqlx::query(
+            "DELETE FROM watchlist_entries WHERE user_id = ? AND movie_id = ?",
+        )
+        .bind(&uid)
+        .bind(&mid)
+        .execute(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        if result.rows_affected() == 0 {
+            return Err(DomainError::NotFound(format!(
+                "Watchlist entry for movie {} not found",
+                mid
+            )));
+        }
+        Ok(())
+    }
+
+    async fn remove_if_present(
+        &self,
+        user_id: &UserId,
+        movie_id: &MovieId,
+    ) -> Result<bool, DomainError> {
+        let uid = user_id.value().to_string();
+        let mid = movie_id.value().to_string();
+        let result = sqlx::query(
+            "DELETE FROM watchlist_entries WHERE user_id = ? AND movie_id = ?",
+        )
+        .bind(&uid)
+        .bind(&mid)
+        .execute(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+        Ok(result.rows_affected() > 0)
+    }
+
+    async fn get_for_user(
+        &self,
+        user_id: &UserId,
+        page: &PageParams,
+    ) -> Result<Paginated<WatchlistWithMovie>, DomainError> {
+        let uid = user_id.value().to_string();
+        let limit = page.limit as i64;
+        let offset = page.offset as i64;
+
+        let rows: Vec<WatchlistRow> = sqlx::query_as(
+            "SELECT w.id, w.user_id, w.movie_id, w.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 = ? \
+             ORDER BY w.added_at DESC \
+             LIMIT ? OFFSET ?",
+        )
+        .bind(&uid)
+        .bind(limit)
+        .bind(offset)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Self::map_err)?;
+
+        let total: i64 = sqlx::query(
+            "SELECT COUNT(*) FROM watchlist_entries WHERE user_id = ?",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .try_get(0)
+        .unwrap_or(0);
+
+        let items = rows
+            .into_iter()
+            .map(|r| r.into_domain())
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(Paginated {
+            items,
+            total_count: total as u64,
+            limit: page.limit,
+            offset: page.offset,
+        })
+    }
+
+    async fn contains(&self, user_id: &UserId, movie_id: &MovieId) -> Result<bool, DomainError> {
+        let uid = user_id.value().to_string();
+        let mid = movie_id.value().to_string();
+        let count: i64 = sqlx::query(
+            "SELECT COUNT(*) FROM watchlist_entries WHERE user_id = ? AND movie_id = ?",
+        )
+        .bind(&uid)
+        .bind(&mid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(Self::map_err)?
+        .try_get(0)
+        .unwrap_or(0);
+        Ok(count > 0)
+    }
+}