feat: strongly type and remaining routes

src/routes/channels/voice_join.rs

@@ -1,11 +1,11 @@
 use revolt_quark::{models::User, Ref, Result};
 
-use rocket::serde::json::Value;
+use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 
-/// # Token Response
-#[derive(Serialize, Deserialize)]
-struct CreateVoiceUserResponse {
+/// # Voice Server Token Response
+#[derive(Serialize, Deserialize, JsonSchema)]
+pub struct CreateVoiceUserResponse {
     /// Token for authenticating with the voice server
     token: String,
 }
@@ -15,6 +15,6 @@ struct CreateVoiceUserResponse {
 /// Asks the voice server for a token to join the call.
 #[openapi(tag = "Voice")]
 #[post("/<_target>/join_call")]
-pub async fn req(_user: User, _target: Ref) -> Result<Value> {
+pub async fn req(_user: User, _target: Ref) -> Result<Json<CreateVoiceUserResponse>> {
     unimplemented!()
 }

src/routes/invites/invite_join.rs

@@ -1,18 +1,31 @@
 use revolt_quark::{
-    models::{server_member::MemberCompositeKey, Invite, Member, User},
+    models::{server_member::MemberCompositeKey, Channel, Invite, Member, Server, User},
     Db, Error, Ref, Result,
 };
 
-use rocket::serde::json::Value;
+use rocket::serde::json::Json;
+use serde::Serialize;
 
 use crate::util::variables::MAX_SERVER_COUNT;
 
+/// # Join Response
+#[derive(Serialize, JsonSchema)]
+#[serde(tag = "type")]
+pub enum InviteJoinResponse {
+    Server {
+        /// Channel we are joining
+        channel: Channel,
+        /// Server we are joining
+        server: Server,
+    },
+}
+
 /// # Join Invite
 ///
 /// Join an invite by its ID.
 #[openapi(tag = "Invites")]
 #[post("/<target>")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<Value> {
+pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<InviteJoinResponse>> {
     if user.bot.is_some() {
         return Err(Error::IsBot);
     }
@@ -40,11 +53,7 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Value> {
 
             member.create(db).await?;
 
-            Ok(json!({
-                "type": "Server",
-                "channel": channel,
-                "server": server
-            }))
+            Ok(Json(InviteJoinResponse::Server { channel, server }))
         }
         _ => unreachable!(),
     }

src/routes/servers/roles_create.rs

@@ -3,12 +3,12 @@ use revolt_quark::{
     perms, Db, Error, Permission, Ref, Result,
 };
 
-use rocket::serde::json::{Json, Value};
+use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 use validator::Validate;
 
 /// # Role Data
-#[derive(Validate, Serialize, Deserialize, JsonSchema)]
+#[derive(Validate, Deserialize, JsonSchema)]
 pub struct DataCreateRole {
     /// Role name
     #[validate(length(min = 1, max = 32))]
@@ -19,12 +19,26 @@ pub struct DataCreateRole {
     rank: Option<i64>,
 }
 
+/// # New Role Response
+#[derive(Serialize, JsonSchema)]
+pub struct NewRoleResponse {
+    /// Id of the role
+    id: String,
+    /// New role
+    role: Role,
+}
+
 /// # Create Role
 ///
 /// Creates a new server role.
 #[openapi(tag = "Server Permissions")]
 #[post("/<target>/roles", data = "<data>")]
-pub async fn req(db: &Db, user: User, target: Ref, data: Json<DataCreateRole>) -> Result<Value> {
+pub async fn req(
+    db: &Db,
+    user: User,
+    target: Ref,
+    data: Json<DataCreateRole>,
+) -> Result<Json<NewRoleResponse>> {
     let data = data.into_inner();
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
@@ -53,8 +67,8 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<DataCreateRole>) -
         ..Default::default()
     };
 
-    Ok(json!({
-        "id": role.create(db, &server.id).await?,
-        "role": role
+    Ok(Json(NewRoleResponse {
+        id: role.create(db, &server.id).await?,
+        role: role,
     }))
 }

src/routes/users/find_mutual.rs

@@ -1,15 +1,25 @@
 use revolt_quark::models::User;
 use revolt_quark::{perms, Database, Error, Ref, Result};
 
-use rocket::serde::json::Value;
+use rocket::serde::json::Json;
 use rocket::State;
+use serde::Serialize;
+
+/// # Mutual Friends and Servers Response
+#[derive(Serialize, JsonSchema)]
+pub struct MutualResponse {
+    /// Array of mutual user IDs that both users are friends with
+    users: Vec<String>,
+    /// Array of mutual server IDs that both users are in
+    servers: Vec<String>,
+}
 
 /// # Fetch Mutual Friends And Servers
 ///
 /// Retrieve a list of mutual friends and servers with another user.
 #[openapi(tag = "Relationships")]
 #[get("/<target>/mutual")]
-pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Value> {
+pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<MutualResponse>> {
     let target = target.as_user(db).await?;
 
     if perms(&user)
@@ -18,9 +28,9 @@ pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Value>
         .await
         .get_view_profile()
     {
-        Ok(json!({
-            "users": db.fetch_mutual_user_ids(&user.id, &target.id).await?,
-            "servers": db.fetch_mutual_server_ids(&user.id, &target.id).await?
+        Ok(Json(MutualResponse {
+            users: db.fetch_mutual_user_ids(&user.id, &target.id).await?,
+            servers: db.fetch_mutual_server_ids(&user.id, &target.id).await?,
         }))
     } else {
         Err(Error::NotFound)