refactor(quark): port add_friend, block_user, change_username, remove_friend, send_friend_request, unblock_user

#283

crates/core/database/src/models/users/model.rs

@@ -348,19 +348,6 @@ impl User {
         }
     }
 
-    /// Check whether a username is already in use by another user
-    #[allow(dead_code)]
-    async fn is_username_taken(db: &Database, username: &str) -> Result<bool> {
-        match db.fetch_user_by_username(username).await {
-            Ok(_) => Ok(true),
-            Err(Error {
-                error_type: ErrorType::NotFound,
-                ..
-            }) => Ok(false),
-            Err(error) => Err(error),
-        }
-    }
-
     /// Set a relationship to another user
     pub async fn set_relationship(
         &mut self,

crates/core/database/src/models/users/ops.rs

@@ -14,7 +14,7 @@ pub trait AbstractUsers: Sync + Send {
     async fn fetch_user(&self, id: &str) -> Result<User>;
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User>;
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User>;
 
     /// Fetch a user from the database by their session token
     async fn fetch_user_by_token(&self, token: &str) -> Result<User>;

crates/core/database/src/models/users/ops/mongodb.rs

@@ -25,13 +25,14 @@ impl AbstractUsers for MongoDb {
     }
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User> {
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User> {
         query!(
             self,
             find_one_with_options,
             COL,
             doc! {
-                "username": username
+                "username": username,
+                "discriminator": discriminator
             },
             FindOneOptions::builder()
                 .collation(

crates/core/database/src/models/users/ops/reference.rs

@@ -28,12 +28,14 @@ impl AbstractUsers for ReferenceDb {
     }
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User> {
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User> {
         let users = self.users.lock().await;
         let lowercase = username.to_lowercase();
         users
             .values()
-            .find(|user| user.username.to_lowercase() == lowercase)
+            .find(|user| {
+                user.username.to_lowercase() == lowercase && user.discriminator == discriminator
+            })
             .cloned()
             .ok_or_else(|| create_error!(NotFound))
     }

crates/core/models/src/v0/users.rs

@@ -188,6 +188,12 @@ auto_derived!(
         #[cfg_attr(feature = "serde", serde(rename = "owner"))]
         pub owner_id: String,
     }
+
+    /// User lookup information
+    pub struct DataSendFriendRequest {
+        /// Username and discriminator combo separated by #
+        pub username: String,
+    }
 );
 
 pub trait CheckRelationship {

crates/delta/src/routes/users/add_friend.rs

@@ -1,6 +1,7 @@
-use revolt_quark::models::User;
-use revolt_quark::{Database, Error, Ref, Result};
-
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::{create_error, Result};
 use rocket::serde::json::Json;
 use rocket::State;
 
@@ -9,13 +10,17 @@ use rocket::State;
 /// Accept another user's friend request.
 #[openapi(tag = "Relationships")]
 #[put("/<target>/friend")]
-pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<User>> {
+pub async fn add(
+    db: &State<Database>,
+    mut user: User,
+    target: Reference,
+) -> Result<Json<v0::User>> {
     let mut target = target.as_user(db).await?;
 
     if user.bot.is_some() || target.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
     user.add_friend(db, &mut target).await?;
-    Ok(Json(target.with_auto_perspective(db, &user).await))
+    Ok(Json(target.into(db, &user).await))
 }

crates/delta/src/routes/users/block_user.rs

@@ -1,6 +1,7 @@
-use revolt_quark::models::User;
-use revolt_quark::{Database, Result};
-
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::Result;
 use rocket::serde::json::Json;
 use rocket::State;
 
@@ -9,8 +10,13 @@ use rocket::State;
 /// Block another user by their id.
 #[openapi(tag = "Relationships")]
 #[put("/<target>/block")]
-pub async fn req(db: &State<Database>, user: User, target: String) -> Result<Json<User>> {
-    let mut target = db.fetch_user(&target).await?;
+pub async fn block(
+    db: &State<Database>,
+    mut user: User,
+    target: Reference,
+) -> Result<Json<v0::User>> {
+    let mut target = target.as_user(db).await?;
+
     user.block_user(db, &mut target).await?;
-    Ok(Json(target.with_auto_perspective(db, &user).await))
+    Ok(Json(target.into(db, &user).await))
 }

crates/delta/src/routes/users/change_username.rs

@@ -1,6 +1,9 @@
+use authifier::models::Account;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use revolt_quark::{authifier::models::Account, models::User, Database, Error, Result};
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
@@ -32,15 +35,18 @@ pub async fn req(
     account: Account,
     mut user: User,
     data: Json<DataChangeUsername>,
-) -> Result<Json<User>> {
+) -> Result<Json<v0::User>> {
     let data = data.into_inner();
-    data.validate()
-        .map_err(|error| Error::FailedValidation { error })?;
+    data.validate().map_err(|error| {
+        create_error!(FailedValidation {
+            error: error.to_string()
+        })
+    })?;
 
     account
         .verify_password(&data.password)
-        .map_err(|_| Error::InvalidCredentials)?;
+        .map_err(|_| create_error!(InvalidCredentials))?;
 
     user.update_username(db, data.username).await?;
-    Ok(Json(user.foreign()))
+    Ok(Json(user.into(db, None).await))
 }

crates/delta/src/routes/users/mod.rs

@@ -32,10 +32,10 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         open_dm::req,
         // Relationships
         find_mutual::req,
-        add_friend::req,
-        remove_friend::req,
-        block_user::req,
-        unblock_user::req,
-        send_friend_request::req,
+        add_friend::add,
+        remove_friend::remove,
+        block_user::block,
+        unblock_user::unblock,
+        send_friend_request::send_friend_request,
     ]
 }

crates/delta/src/routes/users/remove_friend.rs

@@ -1,6 +1,7 @@
-use revolt_quark::models::User;
-use revolt_quark::{Database, Error, Result};
-
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::{create_error, Result};
 use rocket::serde::json::Json;
 use rocket::State;
 
@@ -9,13 +10,17 @@ use rocket::State;
 /// Denies another user's friend request or removes an existing friend.
 #[openapi(tag = "Relationships")]
 #[delete("/<target>/friend")]
-pub async fn req(db: &State<Database>, user: User, target: String) -> Result<Json<User>> {
-    let mut target = db.fetch_user(&target).await?;
+pub async fn remove(
+    db: &State<Database>,
+    mut user: User,
+    target: Reference,
+) -> Result<Json<v0::User>> {
+    let mut target = target.as_user(db).await?;
 
     if user.bot.is_some() || target.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
     user.remove_friend(db, &mut target).await?;
-    Ok(Json(target.with_auto_perspective(db, &user).await))
+    Ok(Json(target.into(db, &user).await))
 }

crates/delta/src/routes/users/send_friend_request.rs

@@ -1,37 +1,30 @@
-use revolt_quark::models::User;
-use revolt_quark::{Database, Error, Result};
-
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::{create_error, Result};
 use rocket::serde::json::Json;
 use rocket::State;
-use serde::{Deserialize, Serialize};
-
-/// # User Lookup Information
-#[derive(Serialize, Deserialize, JsonSchema)]
-pub struct DataSendFriendRequest {
-    /// Username and discriminator combo separated by #
-    username: String,
-}
 
 /// # Send Friend Request
 ///
 /// Send a friend request to another user.
 #[openapi(tag = "Relationships")]
 #[post("/friend", data = "<data>")]
-pub async fn req(
+pub async fn send_friend_request(
     db: &State<Database>,
-    user: User,
-    data: Json<DataSendFriendRequest>,
-) -> Result<Json<User>> {
+    mut user: User,
+    data: Json<v0::DataSendFriendRequest>,
+) -> Result<Json<v0::User>> {
     if let Some((username, discriminator)) = data.username.split_once('#') {
         let mut target = db.fetch_user_by_username(username, discriminator).await?;
 
         if user.bot.is_some() || target.bot.is_some() {
-            return Err(Error::IsBot);
+            return Err(create_error!(IsBot));
         }
 
         user.add_friend(db, &mut target).await?;
-        Ok(Json(target.with_auto_perspective(db, &user).await))
+        Ok(Json(target.into(db, &user).await))
     } else {
-        Err(Error::InvalidProperty)
+        Err(create_error!(InvalidProperty))
     }
 }

crates/delta/src/routes/users/unblock_user.rs

@@ -1,6 +1,7 @@
-use revolt_quark::models::User;
-use revolt_quark::{Database, Result};
-
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
+use revolt_result::Result;
 use rocket::serde::json::Json;
 use rocket::State;
 
@@ -9,8 +10,13 @@ use rocket::State;
 /// Unblock another user by their id.
 #[openapi(tag = "Relationships")]
 #[delete("/<target>/block")]
-pub async fn req(db: &State<Database>, user: User, target: String) -> Result<Json<User>> {
-    let mut target = db.fetch_user(&target).await?;
+pub async fn unblock(
+    db: &State<Database>,
+    mut user: User,
+    target: Reference,
+) -> Result<Json<v0::User>> {
+    let mut target = target.as_user(db).await?;
+
     user.unblock_user(db, &mut target).await?;
-    Ok(Json(target.with_auto_perspective(db, &user).await))
+    Ok(Json(target.into(db, &user).await))
 }