Repository method to deactivate a user.

Author: sandhose

crates/storage-pg/.sqlx/query-2f7aba76cd7df75d6a9a6d91d5ddebaedf37437f3bd4f796f5581fab997587d7.json

@@ -330,6 +330,42 @@ impl UserRepository for PgUserRepository<'_> {
         Ok(user)
     }
 
+    #[tracing::instrument(
+        name = "db.user.deactivate",
+        skip_all,
+        fields(
+            db.query.text,
+            %user.id,
+        ),
+        err,
+    )]
+    async fn deactivate(&mut self, clock: &dyn Clock, mut user: User) -> Result<User, Self::Error> {
+        if user.deactivated_at.is_some() {
+            return Ok(user);
+        }
+
+        let deactivated_at = clock.now();
+        let res = sqlx::query!(
+            r#"
+                UPDATE users
+                SET deactivated_at = $2
+                WHERE user_id = $1
+                  AND deactivated_at IS NULL
+            "#,
+            Uuid::from(user.id),
+            deactivated_at,
+        )
+        .traced()
+        .execute(&mut *self.conn)
+        .await?;
+
+        DatabaseError::ensure_affected_rows(&res, 1)?;
+
+        user.deactivated_at = Some(user.created_at);
+
+        Ok(user)
+    }
+
     #[tracing::instrument(
         name = "db.user.set_can_request_admin",
         skip_all,

crates/storage-pg/src/user/mod.rs

@@ -33,6 +33,7 @@ async fn test_user_repo(pool: PgPool) {
     let non_admin = all.cannot_request_admin_only();
     let active = all.active_only();
     let locked = all.locked_only();
+    let deactivated = all.deactivated_only();
 
     // Initially, the user shouldn't exist
     assert!(!repo.user().exists(USERNAME).await.unwrap());
@@ -49,6 +50,7 @@ async fn test_user_repo(pool: PgPool) {
     assert_eq!(repo.user().count(non_admin).await.unwrap(), 0);
     assert_eq!(repo.user().count(active).await.unwrap(), 0);
     assert_eq!(repo.user().count(locked).await.unwrap(), 0);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 0);
 
     // Adding the user should work
     let user = repo
@@ -73,6 +75,7 @@ async fn test_user_repo(pool: PgPool) {
     assert_eq!(repo.user().count(non_admin).await.unwrap(), 1);
     assert_eq!(repo.user().count(active).await.unwrap(), 1);
     assert_eq!(repo.user().count(locked).await.unwrap(), 0);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 0);
 
     // Adding a second time should give a conflict
     // It should not poison the transaction though
@@ -93,6 +96,7 @@ async fn test_user_repo(pool: PgPool) {
     assert_eq!(repo.user().count(non_admin).await.unwrap(), 1);
     assert_eq!(repo.user().count(active).await.unwrap(), 0);
     assert_eq!(repo.user().count(locked).await.unwrap(), 1);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 0);
 
     // Check that the property is retrieved on lookup
     let user = repo.user().lookup(user.id).await.unwrap().unwrap();
@@ -123,6 +127,7 @@ async fn test_user_repo(pool: PgPool) {
     assert_eq!(repo.user().count(non_admin).await.unwrap(), 0);
     assert_eq!(repo.user().count(active).await.unwrap(), 1);
     assert_eq!(repo.user().count(locked).await.unwrap(), 0);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 0);
 
     // Check that the property is retrieved on lookup
     let user = repo.user().lookup(user.id).await.unwrap().unwrap();
@@ -145,6 +150,26 @@ async fn test_user_repo(pool: PgPool) {
     assert_eq!(repo.user().count(non_admin).await.unwrap(), 1);
     assert_eq!(repo.user().count(active).await.unwrap(), 1);
     assert_eq!(repo.user().count(locked).await.unwrap(), 0);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 0);
+
+    // Deactivating the user should work
+    let user = repo.user().deactivate(&clock, user).await.unwrap();
+    assert!(user.deactivated_at.is_some());
+
+    // Check that the property is retrieved on lookup
+    let user = repo.user().lookup(user.id).await.unwrap().unwrap();
+    assert!(user.deactivated_at.is_some());
+
+    // Deactivating a second time should not fail
+    let user = repo.user().deactivate(&clock, user).await.unwrap();
+    assert!(user.deactivated_at.is_some());
+
+    assert_eq!(repo.user().count(all).await.unwrap(), 1);
+    assert_eq!(repo.user().count(admin).await.unwrap(), 0);
+    assert_eq!(repo.user().count(non_admin).await.unwrap(), 1);
+    assert_eq!(repo.user().count(active).await.unwrap(), 0);
+    assert_eq!(repo.user().count(locked).await.unwrap(), 0);
+    assert_eq!(repo.user().count(deactivated).await.unwrap(), 1);
 
     // Check the list method
     let list = repo.user().list(all, Pagination::first(10)).await.unwrap();
@@ -171,8 +196,7 @@ async fn test_user_repo(pool: PgPool) {
         .list(active, Pagination::first(10))
         .await
         .unwrap();
-    assert_eq!(list.edges.len(), 1);
-    assert_eq!(list.edges[0].id, user.id);
+    assert_eq!(list.edges.len(), 0);
 
     let list = repo
         .user()
@@ -181,6 +205,14 @@ async fn test_user_repo(pool: PgPool) {
         .unwrap();
     assert_eq!(list.edges.len(), 0);
 
+    let list = repo
+        .user()
+        .list(deactivated, Pagination::first(10))
+        .await
+        .unwrap();
+    assert_eq!(list.edges.len(), 1);
+    assert_eq!(list.edges[0].id, user.id);
+
     repo.save().await.unwrap();
 }
 

crates/storage-pg/src/user/tests.rs

@@ -228,6 +228,20 @@ pub trait UserRepository: Send + Sync {
     /// Returns [`Self::Error`] if the underlying repository fails
     async fn unlock(&mut self, user: User) -> Result<User, Self::Error>;
 
+    /// Deactivate a [`User`]
+    ///
+    /// Returns the deactivated [`User`]
+    ///
+    /// # Parameters
+    ///
+    /// * `clock`: The clock used to generate timestamps
+    /// * `user`: The [`User`] to deactivate
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Self::Error`] if the underlying repository fails
+    async fn deactivate(&mut self, clock: &dyn Clock, user: User) -> Result<User, Self::Error>;
+
     /// Set whether a [`User`] can request admin
     ///
     /// Returns the [`User`] with the new `can_request_admin` value
@@ -298,6 +312,7 @@ repository_impl!(UserRepository:
     async fn exists(&mut self, username: &str) -> Result<bool, Self::Error>;
     async fn lock(&mut self, clock: &dyn Clock, user: User) -> Result<User, Self::Error>;
     async fn unlock(&mut self, user: User) -> Result<User, Self::Error>;
+    async fn deactivate(&mut self, clock: &dyn Clock, user: User) -> Result<User, Self::Error>;
     async fn set_can_request_admin(
         &mut self,
         user: User,