style: cargo clippy & cargo fmt

build.rs

@@ -12,5 +12,5 @@ fn main() {
         .unwrap_or_else(|| "UNKNOWN".to_string());
 
     // Tell Cargo to set `GIT_SHORT_HASH` for the main compilation
-    println!("cargo:rustc-env=GIT_SHORT_HASH={}", git_short_hash);
+    println!("cargo:rustc-env=GIT_SHORT_HASH={git_short_hash}");
 }

src/api/v1/auth/login.rs

@@ -10,10 +10,7 @@ use crate::{
     Data,
     error::Error,
     schema::*,
-    utils::{
+    utils::{PASSWORD_REGEX, generate_token, new_refresh_token_cookie, user_uuid_from_identifier},
-        PASSWORD_REGEX, generate_token, new_refresh_token_cookie,
-        user_uuid_from_identifier,
-    },
 };
 
 use super::Response;

src/api/v1/auth/refresh.rs

@@ -42,7 +42,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
                 .execute(&mut conn)
                 .await
             {
-                error!("{}", error);
+                error!("{error}");
             }
 
             refresh_token_cookie.make_removal();
@@ -70,7 +70,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
                     refresh_token = new_refresh_token;
                 }
                 Err(error) => {
-                    error!("{}", error);
+                    error!("{error}");
                 }
             }
         }

src/api/v1/auth/register.rs

@@ -12,11 +12,17 @@ use uuid::Uuid;
 
 use super::Response;
 use crate::{
-    error::Error, objects::Member, schema::{
+    Data,
-        access_tokens::{self, dsl as adsl}, refresh_tokens::{self, dsl as rdsl}, users::{self, dsl as udsl}
+    error::Error,
-    }, utils::{
+    objects::Member,
-        generate_token, new_refresh_token_cookie, EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX
+    schema::{
-    }, Data
+        access_tokens::{self, dsl as adsl},
+        refresh_tokens::{self, dsl as rdsl},
+        users::{self, dsl as udsl},
+    },
+    utils::{
+        EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX, generate_token, new_refresh_token_cookie,
+    },
 };
 
 #[derive(Deserialize)]

src/api/v1/auth/reset_password.rs

@@ -72,8 +72,7 @@ pub async fn post(
     reset_password: web::Json<ResetPassword>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
-    let password_reset_token =
+    let password_reset_token = PasswordResetToken::get(&data, reset_password.token.clone()).await?;
-        PasswordResetToken::get(&data, reset_password.token.clone()).await?;
 
     password_reset_token
         .set_password(&data, reset_password.password.clone())

src/api/v1/channels/uuid/mod.rs

@@ -4,7 +4,11 @@ pub mod messages;
 pub mod socket;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Channel, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Channel, Member, Permissions},
+    utils::{get_auth_header, global_checks},
 };
 use actix_web::{HttpRequest, HttpResponse, delete, get, patch, web};
 use serde::Deserialize;
@@ -57,7 +61,9 @@ pub async fn delete(
 
     let member = Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::DeleteChannel).await?;
+    member
+        .check_permission(&data, Permissions::DeleteChannel)
+        .await?;
 
     channel.delete(&data).await?;
 
@@ -125,7 +131,9 @@ pub async fn patch(
 
     let member = Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::ManageChannel).await?;
+    member
+        .check_permission(&data, Permissions::ManageChannel)
+        .await?;
 
     if let Some(new_name) = &new_info.name {
         channel.set_name(&data, new_name.to_string()).await?;

src/api/v1/guilds/uuid/channels.rs

@@ -1,5 +1,9 @@
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Channel, Member, Permissions}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Channel, Member, Permissions},
+    utils::{get_auth_header, global_checks, order_by_is_above},
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, post, web};
@@ -31,7 +35,7 @@ pub async fn get(
 
     Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{guild_uuid}_channels")).await {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
@@ -42,7 +46,7 @@ pub async fn get(
     let channels_ordered = order_by_is_above(channels).await?;
 
     data.set_cache_key(
-        format!("{}_channels", guild_uuid),
+        format!("{guild_uuid}_channels"),
         channels_ordered.clone(),
         1800,
     )
@@ -72,7 +76,9 @@ pub async fn create(
 
     let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::CreateChannel).await?;
+    member
+        .check_permission(&data, Permissions::CreateChannel)
+        .await?;
 
     let channel = Channel::new(
         data.clone(),

src/api/v1/guilds/uuid/icon.rs

@@ -5,7 +5,11 @@ use futures_util::StreamExt as _;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Guild, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Guild, Member, Permissions},
+    utils::{get_auth_header, global_checks},
 };
 
 /// `PUT /api/v1/guilds/{uuid}/icon` Icon upload
@@ -34,7 +38,9 @@ pub async fn upload(
 
     let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::ManageServer).await?;
+    member
+        .check_permission(&data, Permissions::ManageServer)
+        .await?;
 
     let mut guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 

src/api/v1/guilds/uuid/invites/mod.rs

@@ -3,7 +3,11 @@ use serde::Deserialize;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Guild, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Guild, Member, Permissions},
+    utils::{get_auth_header, global_checks},
 };
 
 #[derive(Deserialize)]
@@ -59,11 +63,15 @@ pub async fn create(
 
     let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::CreateInvite).await?;
+    member
+        .check_permission(&data, Permissions::CreateInvite)
+        .await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
-    let invite = guild.create_invite(&mut conn, uuid, invite_request.custom_id.clone()).await?;
+    let invite = guild
+        .create_invite(&mut conn, uuid, invite_request.custom_id.clone())
+        .await?;
 
     Ok(HttpResponse::Ok().json(invite))
 }

src/api/v1/guilds/uuid/roles/mod.rs

@@ -3,7 +3,11 @@ use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Member, Permissions, Role}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Member, Permissions, Role},
+    utils::{get_auth_header, global_checks, order_by_is_above},
 };
 
 pub mod uuid;
@@ -31,7 +35,7 @@ pub async fn get(
 
     Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    if let Ok(cache_hit) = data.get_cache_key(format!("{}_roles", guild_uuid)).await {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{guild_uuid}_roles")).await {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
@@ -41,7 +45,7 @@ pub async fn get(
 
     let roles_ordered = order_by_is_above(roles).await?;
 
-    data.set_cache_key(format!("{}_roles", guild_uuid), roles_ordered.clone(), 1800)
+    data.set_cache_key(format!("{guild_uuid}_roles"), roles_ordered.clone(), 1800)
         .await?;
 
     Ok(HttpResponse::Ok().json(roles_ordered))
@@ -68,7 +72,9 @@ pub async fn create(
 
     let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    member.check_permission(&data, Permissions::CreateRole).await?;
+    member
+        .check_permission(&data, Permissions::CreateRole)
+        .await?;
 
     let role = Role::new(&mut conn, guild_uuid, role_info.name.clone()).await?;
 

src/api/v1/guilds/uuid/roles/uuid.rs

@@ -28,7 +28,7 @@ pub async fn get(
 
     Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{role_uuid}")).await {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
@@ -36,7 +36,7 @@ pub async fn get(
 
     let role = Role::fetch_one(&mut conn, role_uuid).await?;
 
-    data.set_cache_key(format!("{}", role_uuid), role.clone(), 60)
+    data.set_cache_key(format!("{role_uuid}"), role.clone(), 60)
         .await?;
 
     Ok(HttpResponse::Ok().json(role))

src/config.rs

@@ -76,7 +76,7 @@ pub struct Smtp {
 
 impl ConfigBuilder {
     pub async fn load(path: String) -> Result<Self, Error> {
-        debug!("loading config from: {}", path);
+        debug!("loading config from: {path}");
         let raw = read_to_string(path).await?;
 
         let config = toml::from_str(&raw)?;

src/error.rs

@@ -79,7 +79,7 @@ pub enum Error {
 
 impl ResponseError for Error {
     fn error_response(&self) -> HttpResponse {
-        debug!("{:?}", self);
+        debug!("{self:?}");
         error!("{}: {}", self.status_code(), self);
 
         HttpResponse::build(self.status_code())

src/main.rs

@@ -67,7 +67,9 @@ async fn main() -> Result<(), Error> {
 
     let bunny = config.bunny.clone();
 
-    let bunny_storage = bunny_api_tokio::EdgeStorageClient::new(bunny.api_key, bunny.endpoint, bunny.storage_zone).await?;
+    let bunny_storage =
+        bunny_api_tokio::EdgeStorageClient::new(bunny.api_key, bunny.endpoint, bunny.storage_zone)
+            .await?;
 
     let mail = config.mail.clone();
 

src/objects/channel.rs

@@ -183,12 +183,11 @@ impl Channel {
             .await?;
 
         if data
-            .get_cache_key(format!("{}_channels", guild_uuid))
+            .get_cache_key(format!("{guild_uuid}_channels"))
             .await
             .is_ok()
         {
-            data.del_cache_key(format!("{}_channels", guild_uuid))
+            data.del_cache_key(format!("{guild_uuid}_channels")).await?;
-                .await?;
         }
 
         Ok(channel)

src/objects/email_token.rs

@@ -16,7 +16,11 @@ pub struct EmailToken {
 
 impl EmailToken {
     pub async fn get(data: &Data, user_uuid: Uuid) -> Result<EmailToken, Error> {
-        let email_token = serde_json::from_str(&data.get_cache_key(format!("{}_email_verify", user_uuid)).await?)?;
+        let email_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_email_verify"))
+                .await?,
+        )?;
 
         Ok(email_token)
     }
@@ -29,14 +33,15 @@ impl EmailToken {
             user_uuid: me.uuid,
             token: token.clone(),
             // TODO: Check if this can be replaced with something built into valkey
-            created_at: Utc::now()
+            created_at: Utc::now(),
         };
 
-        data.set_cache_key(format!("{}_email_verify", me.uuid), email_token,  86400).await?;
+        data.set_cache_key(format!("{}_email_verify", me.uuid), email_token, 86400)
+            .await?;
 
         let mut verify_endpoint = data.config.web.frontend_url.join("verify-email")?;
 
-        verify_endpoint.set_query(Some(&format!("token={}", token)));
+        verify_endpoint.set_query(Some(&format!("token={token}")));
 
         let email = data
             .mail_client
@@ -54,7 +59,8 @@ impl EmailToken {
     }
 
     pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_email_verify", self.user_uuid)).await?;
+        data.del_cache_key(format!("{}_email_verify", self.user_uuid))
+            .await?;
 
         Ok(())
     }

src/objects/member.rs

@@ -5,7 +5,12 @@ use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{error::Error, objects::{Permissions, Role}, schema::guild_members, Conn, Data};
+use crate::{
+    Conn, Data,
+    error::Error,
+    objects::{Permissions, Role},
+    schema::guild_members,
+};
 
 use super::{User, load_or_empty};
 
@@ -34,12 +39,16 @@ impl MemberBuilder {
         })
     }
 
-    pub async fn check_permission(&self, data: &Data, permission: Permissions) -> Result<(), Error> {
+    pub async fn check_permission(
+        &self,
+        data: &Data,
+        permission: Permissions,
+    ) -> Result<(), Error> {
         if !self.is_owner {
-            let roles = Role::fetch_from_member(&data, self.uuid).await?;
+            let roles = Role::fetch_from_member(data, self.uuid).await?;
             let allowed = roles.iter().any(|r| r.permissions & permission as i64 != 0);
             if !allowed {
-                return Err(Error::Forbidden("Not allowed".to_string()))
+                return Err(Error::Forbidden("Not allowed".to_string()));
             }
         }
 

src/objects/mod.rs

@@ -26,8 +26,8 @@ pub use me::Me;
 pub use member::Member;
 pub use message::Message;
 pub use password_reset_token::PasswordResetToken;
-pub use role::Role;
 pub use role::Permissions;
+pub use role::Role;
 pub use user::User;
 
 use crate::error::Error;
@@ -106,7 +106,7 @@ impl MailClient {
 
         let response = mailer.send(email).await?;
 
-        debug!("mail sending response: {:?}", response);
+        debug!("mail sending response: {response:?}");
 
         Ok(())
     }

src/objects/password_reset_token.rs

@@ -3,19 +3,17 @@ use argon2::{
     password_hash::{SaltString, rand_core::OsRng},
 };
 use chrono::Utc;
-use diesel::{
+use diesel::{ExpressionMethods, QueryDsl, update};
-    ExpressionMethods, QueryDsl, update,
-};
 use diesel_async::RunQueryDsl;
 use lettre::message::MultiPart;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
+    Data,
     error::Error,
     schema::users,
-    utils::{generate_token, global_checks, user_uuid_from_identifier, PASSWORD_REGEX},
+    utils::{PASSWORD_REGEX, generate_token, global_checks, user_uuid_from_identifier},
-    Data
 };
 
 #[derive(Serialize, Deserialize)]
@@ -27,8 +25,12 @@ pub struct PasswordResetToken {
 
 impl PasswordResetToken {
     pub async fn get(data: &Data, token: String) -> Result<PasswordResetToken, Error> {
-        let user_uuid: Uuid = serde_json::from_str(&data.get_cache_key(format!("{}", token)).await?)?;
+        let user_uuid: Uuid = serde_json::from_str(&data.get_cache_key(token.to_string()).await?)?;
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
+        let password_reset_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_password_reset"))
+                .await?,
+        )?;
 
         Ok(password_reset_token)
     }
@@ -41,7 +43,11 @@ impl PasswordResetToken {
 
         let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
 
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
+        let password_reset_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_password_reset"))
+                .await?,
+        )?;
 
         Ok(password_reset_token)
     }
@@ -69,12 +75,17 @@ impl PasswordResetToken {
             created_at: Utc::now(),
         };
 
-        data.set_cache_key(format!("{}_password_reset", user_uuid), password_reset_token,  86400).await?;
+        data.set_cache_key(
+            format!("{user_uuid}_password_reset"),
+            password_reset_token,
+            86400,
+        )
+        .await?;
         data.set_cache_key(token.clone(), user_uuid, 86400).await?;
 
         let mut reset_endpoint = data.config.web.frontend_url.join("reset-password")?;
 
-        reset_endpoint.set_query(Some(&format!("token={}", token)));
+        reset_endpoint.set_query(Some(&format!("token={token}")));
 
         let email = data
             .mail_client
@@ -134,12 +145,13 @@ impl PasswordResetToken {
 
         data.mail_client.send_mail(email).await?;
 
-        self.delete(&data).await
+        self.delete(data).await
     }
 
     pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_password_reset", &self.user_uuid)).await?;
+        data.del_cache_key(format!("{}_password_reset", &self.user_uuid))
-        data.del_cache_key(format!("{}", &self.token)).await?;
+            .await?;
+        data.del_cache_key(self.token.to_string()).await?;
 
         Ok(())
     }

src/objects/role.rs

@@ -6,7 +6,12 @@ use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{error::Error, schema::{role_members, roles}, utils::order_by_is_above, Conn, Data};
+use crate::{
+    Conn, Data,
+    error::Error,
+    schema::{role_members, roles},
+    utils::order_by_is_above,
+};
 
 use super::{HasIsAbove, HasUuid, load_or_empty};
 
@@ -70,8 +75,8 @@ impl Role {
     }
 
     pub async fn fetch_from_member(data: &Data, member_uuid: Uuid) -> Result<Vec<Self>, Error> {
-        if let Ok(roles) = data.get_cache_key(format!("{}_roles", member_uuid)).await {
+        if let Ok(roles) = data.get_cache_key(format!("{member_uuid}_roles")).await {
-            return Ok(serde_json::from_str(&roles)?)
+            return Ok(serde_json::from_str(&roles)?);
         }
 
         let mut conn = data.pool.get().await?;
@@ -91,7 +96,8 @@ impl Role {
             roles.push(membership.fetch_role(&mut conn).await?);
         }
 
-        data.set_cache_key(format!("{}_roles", member_uuid), roles.clone(), 300).await?;
+        data.set_cache_key(format!("{member_uuid}_roles"), roles.clone(), 300)
+            .await?;
 
         Ok(roles)
     }
@@ -108,7 +114,7 @@ impl Role {
     }
 
     pub async fn fetch_permissions(&self) -> Vec<Permissions> {
-        Permissions::fetch_permissions(self.permissions.clone())
+        Permissions::fetch_permissions(self.permissions)
     }
 
     pub async fn new(conn: &mut Conn, guild_uuid: Uuid, name: String) -> Result<Self, Error> {