refactor: extract inline test modules to separate files

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

@@ -0,0 +1,162 @@
+use crate::db_error::IntoDbResult;
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+
+use domain::{
+    errors::DomainError,
+    models::{
+        feed::{PageParams, Paginated},
+        notification::{Notification, NotificationKind},
+    },
+    ports::NotificationRepository,
+    value_objects::{NotificationId, ThoughtId, UserId},
+};
+use sqlx::PgPool;
+
+pub struct PgNotificationRepository {
+    pool: PgPool,
+}
+impl PgNotificationRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct NotificationRow {
+    id: uuid::Uuid,
+    user_id: uuid::Uuid,
+    notification_type: String,
+    from_user_id: Option<uuid::Uuid>,
+    thought_id: Option<uuid::Uuid>,
+    read: bool,
+    created_at: DateTime<Utc>,
+}
+
+fn row_to_notification(r: NotificationRow) -> Result<Notification, DomainError> {
+    let from_user_id = r
+        .from_user_id
+        .map(UserId::from_uuid)
+        .ok_or_else(|| DomainError::Internal("notification missing from_user_id".into()))?;
+
+    let kind = match r.notification_type.as_str() {
+        "follow" => NotificationKind::Follow { from_user_id },
+        other => {
+            let thought_id = r.thought_id.map(ThoughtId::from_uuid).ok_or_else(|| {
+                DomainError::Internal(format!("notification type '{other}' missing thought_id"))
+            })?;
+            match other {
+                "like" => NotificationKind::Like {
+                    thought_id,
+                    from_user_id,
+                },
+                "boost" => NotificationKind::Boost {
+                    thought_id,
+                    from_user_id,
+                },
+                "reply" => NotificationKind::Reply {
+                    thought_id,
+                    from_user_id,
+                },
+                "mention" => NotificationKind::Mention {
+                    thought_id,
+                    from_user_id,
+                },
+                _ => {
+                    return Err(DomainError::Internal(format!(
+                        "unknown notification type: {other}"
+                    )))
+                }
+            }
+        }
+    };
+
+    Ok(Notification {
+        id: NotificationId::from_uuid(r.id),
+        user_id: UserId::from_uuid(r.user_id),
+        kind,
+        read: r.read,
+        created_at: r.created_at,
+    })
+}
+
+#[async_trait]
+impl NotificationRepository for PgNotificationRepository {
+    async fn save(&self, n: &Notification) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO notifications(id,user_id,notification_type,from_user_id,thought_id,read,created_at)
+             VALUES($1,$2,$3,$4,$5,$6,$7)
+             ON CONFLICT(id) DO NOTHING"
+        )
+        .bind(n.id.as_uuid())
+        .bind(n.user_id.as_uuid())
+        .bind(n.kind.kind_str())
+        .bind(n.kind.from_user_id().as_uuid())
+        .bind(n.kind.thought_id().map(|t| t.as_uuid()))
+        .bind(n.read)
+        .bind(n.created_at)
+        .execute(&self.pool)
+        .await
+        .into_domain()
+        .map(|_| ())
+    }
+
+    async fn list_for_user(
+        &self,
+        user_id: &UserId,
+        page: &PageParams,
+    ) -> Result<Paginated<Notification>, DomainError> {
+        let total: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM notifications WHERE user_id=$1")
+            .bind(user_id.as_uuid())
+            .fetch_one(&self.pool)
+            .await
+            .into_domain()?;
+        let rows = sqlx::query_as::<_, NotificationRow>(
+            "SELECT id,user_id,notification_type,from_user_id,thought_id,read,created_at FROM notifications WHERE user_id=$1 ORDER BY created_at DESC LIMIT $2 OFFSET $3"
+        ).bind(user_id.as_uuid()).bind(page.limit()).bind(page.offset())
+        .fetch_all(&self.pool).await.into_domain()?;
+        let items = rows
+            .into_iter()
+            .map(row_to_notification)
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Paginated {
+            items,
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
+    }
+
+    async fn count_unread(&self, user_id: &UserId) -> Result<u64, DomainError> {
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM notifications WHERE user_id=$1 AND read=false",
+        )
+        .bind(user_id.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .into_domain()?;
+        Ok(count as u64)
+    }
+
+    async fn mark_read(&self, id: &NotificationId, user_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("UPDATE notifications SET read=true WHERE id=$1 AND user_id=$2")
+            .bind(id.as_uuid())
+            .bind(user_id.as_uuid())
+            .execute(&self.pool)
+            .await
+            .into_domain()
+            .map(|_| ())
+    }
+
+    async fn mark_all_read(&self, user_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("UPDATE notifications SET read=true WHERE user_id=$1")
+            .bind(user_id.as_uuid())
+            .execute(&self.pool)
+            .await
+            .into_domain()
+            .map(|_| ())
+    }
+}
+
+#[cfg(test)]
+mod tests;