refactor: sqlite repositories per aggregate

crates/adapters/sqlite/src/repositories/users/mod.rs

@@ -0,0 +1,202 @@
+use async_trait::async_trait;
+use chrono::Utc;
+use sqlx::{Row, SqlitePool};
+
+use rows::UserSummaryRow;
+
+mod rows;
+use domain::{
+    errors::DomainError,
+    models::{ProfileField, User, UserRole},
+    ports::UserRepository,
+    value_objects::{Email, PasswordHash, UserId, Username},
+};
+
+pub struct SqliteUserRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteUserRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+
+    fn parse_role(s: &str) -> UserRole {
+        match s {
+            "admin" => UserRole::Admin,
+            _ => UserRole::Standard,
+        }
+    }
+
+    fn row_to_user(
+        row: &sqlx::sqlite::SqliteRow,
+        profile_fields: Vec<ProfileField>,
+    ) -> Result<User, DomainError> {
+        let id_str: String = row.try_get("id").unwrap_or_default();
+        let id = uuid::Uuid::parse_str(&id_str)
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        let email = Email::new(row.get("email"))
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        let username = Username::new(row.get("username"))
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        let hash = PasswordHash::new(row.get("password_hash"))
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        let role_str: String = row.get("role");
+        Ok(User::from_persistence(
+            UserId::from_uuid(id),
+            email,
+            username,
+            hash,
+            Self::parse_role(&role_str),
+            domain::models::UserProfile {
+                display_name: row.try_get("display_name").ok().flatten(),
+                bio: row.try_get("bio").ok().flatten(),
+                avatar_path: row.try_get("avatar_path").ok().flatten(),
+                banner_path: row.try_get("banner_path").ok().flatten(),
+                also_known_as: row.try_get("also_known_as").ok().flatten(),
+                profile_fields,
+            },
+        ))
+    }
+}
+
+const USER_COLS: &str = "id, email, username, password_hash, role, display_name, bio, avatar_path, banner_path, also_known_as";
+
+#[async_trait]
+impl UserRepository for SqliteUserRepository {
+    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
+        let email_str = email.value();
+        let row = sqlx::query(&format!("SELECT {USER_COLS} FROM users WHERE email = ?"))
+            .bind(email_str)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(crate::shared::map_sqlx_error)?;
+
+        row.as_ref()
+            .map(|r| Self::row_to_user(r, vec![]))
+            .transpose()
+    }
+
+    async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
+        let username_str = username.value();
+        let row = sqlx::query(&format!("SELECT {USER_COLS} FROM users WHERE username = ?"))
+            .bind(username_str)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(crate::shared::map_sqlx_error)?;
+
+        row.as_ref()
+            .map(|r| Self::row_to_user(r, vec![]))
+            .transpose()
+    }
+
+    async fn save(&self, user: &User) -> Result<(), DomainError> {
+        if self.find_by_email(user.email()).await?.is_some() {
+            return Err(DomainError::ValidationError(
+                "Email already registered".into(),
+            ));
+        }
+        if self.find_by_username(user.username()).await?.is_some() {
+            return Err(DomainError::ValidationError(
+                "Username already taken".into(),
+            ));
+        }
+
+        let id = user.id().value().to_string();
+        let email = user.email().value();
+        let username = user.username().value();
+        let hash = user.password_hash().value();
+        let created_at = Utc::now().to_rfc3339();
+        let role = match user.role() {
+            UserRole::Admin => "admin",
+            UserRole::Standard => "standard",
+        };
+
+        sqlx::query(
+            "INSERT INTO users (id, email, username, password_hash, created_at, role) VALUES (?, ?, ?, ?, ?, ?)",
+        )
+        .bind(&id)
+        .bind(email)
+        .bind(username)
+        .bind(hash)
+        .bind(&created_at)
+        .bind(role)
+        .execute(&self.pool)
+        .await
+        .map_err(crate::shared::map_sqlx_error)?;
+
+        Ok(())
+    }
+
+    async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError> {
+        let id_str = id.value().to_string();
+        let row = sqlx::query(&format!("SELECT {USER_COLS} FROM users WHERE id = ?"))
+            .bind(&id_str)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(crate::shared::map_sqlx_error)?;
+
+        let Some(r) = row else { return Ok(None) };
+
+        let field_rows = sqlx::query(
+            "SELECT name, value FROM user_profile_fields WHERE user_id = ? ORDER BY position ASC",
+        )
+        .bind(&id_str)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+
+        let profile_fields = field_rows
+            .iter()
+            .map(|f| ProfileField {
+                name: f.get("name"),
+                value: f.get("value"),
+            })
+            .collect();
+
+        Self::row_to_user(&r, profile_fields).map(Some)
+    }
+
+    async fn update_profile(
+        &self,
+        user_id: &UserId,
+        profile: &domain::models::UserProfile,
+    ) -> Result<(), DomainError> {
+        let id_str = user_id.value().to_string();
+        sqlx::query(
+            "UPDATE users SET display_name = ?, bio = ?, avatar_path = ?, banner_path = ?, also_known_as = ? WHERE id = ?",
+        )
+        .bind(&profile.display_name)
+        .bind(&profile.bio)
+        .bind(&profile.avatar_path)
+        .bind(&profile.banner_path)
+        .bind(&profile.also_known_as)
+        .bind(&id_str)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn list_with_stats(&self) -> Result<Vec<domain::models::UserSummary>, DomainError> {
+        sqlx::query_as::<_, UserSummaryRow>(
+            r#"SELECT u.id, u.email, u.username, u.display_name,
+                      COUNT(DISTINCT r.movie_id) AS total_movies,
+                      AVG(CAST(r.rating AS REAL)) AS avg_rating,
+                      u.avatar_path
+               FROM users u
+               LEFT JOIN reviews r ON r.user_id = u.id AND r.remote_actor_url IS NULL
+               GROUP BY u.id, u.email, u.username, u.display_name, u.avatar_path
+               ORDER BY u.email ASC"#,
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(crate::shared::map_sqlx_error)?
+        .into_iter()
+        .map(UserSummaryRow::into_domain)
+        .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests;

crates/adapters/sqlite/src/repositories/users/rows.rs

@@ -0,0 +1,27 @@
+use crate::shared::user_summary_to_domain;
+use domain::errors::DomainError;
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct UserSummaryRow {
+    pub id: String,
+    pub email: String,
+    pub username: String,
+    pub display_name: Option<String>,
+    pub total_movies: i64,
+    pub avg_rating: Option<f64>,
+    pub avatar_path: Option<String>,
+}
+
+impl UserSummaryRow {
+    pub fn into_domain(self) -> Result<domain::models::UserSummary, DomainError> {
+        user_summary_to_domain(
+            self.id,
+            self.email,
+            self.username,
+            self.display_name,
+            self.total_movies,
+            self.avg_rating,
+            self.avatar_path,
+        )
+    }
+}

crates/adapters/sqlite/src/repositories/users/tests.rs

@@ -0,0 +1,109 @@
+use super::*;
+use domain::models::UserRole;
+use domain::value_objects::{Email, PasswordHash, Username};
+use sqlx::SqlitePool;
+
+async fn setup() -> (SqlitePool, SqliteUserRepository) {
+    let pool = SqlitePool::connect(":memory:").await.unwrap();
+    sqlx::query(
+        "CREATE TABLE users (id TEXT PRIMARY KEY, email TEXT NOT NULL UNIQUE, username TEXT NOT NULL UNIQUE, password_hash TEXT NOT NULL, created_at TEXT NOT NULL, role TEXT NOT NULL DEFAULT 'standard', display_name TEXT, bio TEXT, avatar_path TEXT, banner_path TEXT, also_known_as TEXT)"
+    )
+    .execute(&pool)
+    .await
+    .unwrap();
+    sqlx::query(
+        "CREATE TABLE user_profile_fields (id TEXT PRIMARY KEY, user_id TEXT NOT NULL, name TEXT NOT NULL, value TEXT NOT NULL, position INTEGER NOT NULL DEFAULT 0)"
+    )
+    .execute(&pool)
+    .await
+    .unwrap();
+    let repo = SqliteUserRepository::new(pool.clone());
+    (pool, repo)
+}
+
+#[tokio::test]
+async fn find_by_id_returns_none_when_not_found() {
+    let (_, repo) = setup().await;
+    let result = repo
+        .find_by_id(&UserId::from_uuid(uuid::Uuid::new_v4()))
+        .await
+        .unwrap();
+    assert!(result.is_none());
+}
+
+#[tokio::test]
+async fn find_by_id_returns_user_when_found() {
+    let (pool, repo) = setup().await;
+    let id = uuid::Uuid::new_v4();
+    sqlx::query(
+        "INSERT INTO users (id, email, username, password_hash, created_at) VALUES (?, ?, ?, ?, ?)",
+    )
+    .bind(id.to_string())
+    .bind("test@example.com")
+    .bind("test")
+    .bind("$argon2id$v=19$m=65536,t=2,p=1$fakesalt$fakehash")
+    .bind("2026-01-01T00:00:00Z")
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    let result = repo.find_by_id(&UserId::from_uuid(id)).await.unwrap();
+    assert!(result.is_some());
+    assert_eq!(result.unwrap().email().value(), "test@example.com");
+}
+
+#[tokio::test]
+async fn update_profile_persists_bio_and_avatar() {
+    let (_, repo) = setup().await;
+    let user = domain::models::User::new(
+        Email::new("test@example.com".to_string()).unwrap(),
+        Username::new("testuser".to_string()).unwrap(),
+        PasswordHash::new("hash".to_string()).unwrap(),
+        UserRole::Standard,
+    );
+    repo.save(&user).await.unwrap();
+
+    repo.update_profile(
+        user.id(),
+        &domain::models::UserProfile {
+            bio: Some("My biography".to_string()),
+            avatar_path: Some("avatars/user1".to_string()),
+            ..Default::default()
+        },
+    )
+    .await
+    .unwrap();
+
+    let found = repo.find_by_id(user.id()).await.unwrap().unwrap();
+    assert_eq!(found.bio(), Some("My biography"));
+    assert_eq!(found.avatar_path(), Some("avatars/user1"));
+}
+
+#[tokio::test]
+async fn update_profile_clears_fields_with_none() {
+    let (_, repo) = setup().await;
+    let user = domain::models::User::new(
+        Email::new("test2@example.com".to_string()).unwrap(),
+        Username::new("testuser2".to_string()).unwrap(),
+        PasswordHash::new("hash".to_string()).unwrap(),
+        UserRole::Standard,
+    );
+    repo.save(&user).await.unwrap();
+    repo.update_profile(
+        user.id(),
+        &domain::models::UserProfile {
+            bio: Some("bio".to_string()),
+            avatar_path: Some("path".to_string()),
+            ..Default::default()
+        },
+    )
+    .await
+    .unwrap();
+    repo.update_profile(user.id(), &domain::models::UserProfile::default())
+        .await
+        .unwrap();
+
+    let found = repo.find_by_id(user.id()).await.unwrap().unwrap();
+    assert_eq!(found.bio(), None);
+    assert_eq!(found.avatar_path(), None);
+}