Cargo.toml

@@ -10,9 +10,9 @@ codegen-units = 1
 
 [dependencies]
 actix-cors = "0.7.1"
-actix-web = "4.11"
+actix-web = "4.10"
 argon2 = { version = "0.5.3", features = ["std"] }
-clap = { version = "4.5", features = ["derive"] }
+clap = { version = "4.5.37", features = ["derive"] }
 futures = "0.3"
 getrandom = "0.3"
 hex = "0.4"
@@ -22,7 +22,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 simple_logger = "5.0.0"
 sqlx = { version = "0.8", features = ["runtime-tokio", "tls-native-tls", "postgres"] }
-redis = { version = "0.31.0", features= ["tokio-comp"] }
+redis = { version = "0.30", features= ["tokio-comp"] }
 tokio-tungstenite = { version = "0.26", features = ["native-tls", "url"] }
 toml = "0.8"
 url = { version = "2.5", features = ["serde"] }

src/api/mod.rs

@@ -5,5 +5,7 @@ mod v1;
 mod versions;
 
 pub fn web() -> Scope {
-    web::scope("/api").service(v1::web()).service(versions::res)
+    web::scope("/api")
+        .service(v1::web())
+        .service(versions::res)
 }

src/api/v1/auth/login.rs

@@ -1,14 +1,12 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use actix_web::{Error, HttpResponse, post, web};
+use actix_web::{post, web, Error, HttpResponse};
 use argon2::{PasswordHash, PasswordVerifier};
 use log::error;
 use serde::Deserialize;
 
 use crate::{
-    Data,
+    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
-    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
-    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
 };
 
 use super::Response;
@@ -168,7 +166,7 @@ async fn login(
         return HttpResponse::InternalServerError().finish()
     }
 
-    HttpResponse::Ok()
+    HttpResponse::Ok().cookie(refresh_token_cookie(refresh_token)).json(Response {
-        .cookie(refresh_token_cookie(refresh_token))
+        access_token,
-        .json(Response { access_token })
+    })
 }

src/api/v1/auth/mod.rs

@@ -42,12 +42,11 @@ pub async fn check_access_token(
     access_token: &str,
     pool: &sqlx::Pool<Postgres>,
 ) -> Result<Uuid, HttpResponse> {
-    let row = sqlx::query_as(
+    let row =
-        "SELECT CAST(uuid as VARCHAR), created_at FROM access_tokens WHERE token = $1",
+        sqlx::query_as("SELECT CAST(uuid as VARCHAR), created_at FROM access_tokens WHERE token = $1")
-    )
+            .bind(&access_token)
-    .bind(access_token)
+            .fetch_one(pool)
-    .fetch_one(pool)
+            .await;
-    .await;
 
     if let Err(error) = row {
         if error.to_string()

src/api/v1/auth/refresh.rs

@@ -1,10 +1,9 @@
-use actix_web::{Error, HttpRequest, HttpResponse, post, web};
+use actix_web::{post, web, Error, HttpRequest, HttpResponse};
 use log::error;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::{
-    Data,
+    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
-    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
 };
 
 use super::Response;
@@ -13,8 +12,8 @@ use super::Response;
 pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
     let recv_refresh_token_cookie = req.cookie("refresh_token");
 
-    if recv_refresh_token_cookie.is_none() {
+    if let None = recv_refresh_token_cookie {
-        return Ok(HttpResponse::Unauthorized().finish());
+        return Ok(HttpResponse::Unauthorized().finish())
     }
 
     let mut refresh_token = String::from(recv_refresh_token_cookie.unwrap().value());
@@ -24,10 +23,11 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
         .unwrap()
         .as_secs() as i64;
 
-    if let Ok(row) = sqlx::query_scalar("SELECT created_at FROM refresh_tokens WHERE token = $1")
+    if let Ok(row) =
-        .bind(&refresh_token)
+        sqlx::query_scalar("SELECT created_at FROM refresh_tokens WHERE token = $1")
-        .fetch_one(&data.pool)
+            .bind(&refresh_token)
-        .await
+            .fetch_one(&data.pool)
+            .await
     {
         let created_at: i64 = row;
 
@@ -46,9 +46,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
 
             refresh_token_cookie.make_removal();
 
-            return Ok(HttpResponse::Unauthorized()
+            return Ok(HttpResponse::Unauthorized().cookie(refresh_token_cookie).finish());
-                .cookie(refresh_token_cookie)
-                .finish());
         }
 
         let current_time = SystemTime::now()
@@ -66,14 +64,12 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
 
             let new_refresh_token = new_refresh_token.unwrap();
 
-            match sqlx::query(
+            match sqlx::query("UPDATE refresh_tokens SET token = $1, created_at = $2 WHERE token = $3")
-                "UPDATE refresh_tokens SET token = $1, created_at = $2 WHERE token = $3",
+                .bind(&new_refresh_token)
-            )
+                .bind(current_time)
-            .bind(&new_refresh_token)
+                .bind(&refresh_token)
-            .bind(current_time)
+                .execute(&data.pool)
-            .bind(&refresh_token)
+                .await
-            .execute(&data.pool)
-            .await
             {
                 Ok(_) => {
                     refresh_token = new_refresh_token;
@@ -93,29 +89,24 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
 
         let access_token = access_token.unwrap();
 
-        if let Err(error) = sqlx::query(
+        if let Err(error) = sqlx::query("UPDATE access_tokens SET token = $1, created_at = $2 WHERE refresh_token = $3")
-            "UPDATE access_tokens SET token = $1, created_at = $2 WHERE refresh_token = $3",
+            .bind(&access_token)
-        )
+            .bind(current_time)
-        .bind(&access_token)
+            .bind(&refresh_token)
-        .bind(current_time)
+            .execute(&data.pool)
-        .bind(&refresh_token)
+            .await {
-        .execute(&data.pool)
-        .await
-        {
             error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
+            return Ok(HttpResponse::InternalServerError().finish())
         }
 
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().cookie(refresh_token_cookie(refresh_token)).json(Response {
-            .cookie(refresh_token_cookie(refresh_token))
+            access_token,
-            .json(Response { access_token }));
+        }));
     }
 
     let mut refresh_token_cookie = refresh_token_cookie(refresh_token);
 
     refresh_token_cookie.make_removal();
 
-    Ok(HttpResponse::Unauthorized()
+    Ok(HttpResponse::Unauthorized().cookie(refresh_token_cookie).finish())
-        .cookie(refresh_token_cookie)
-        .finish())
 }

src/api/v1/auth/register.rs

@@ -11,9 +11,7 @@ use uuid::Uuid;
 
 use super::Response;
 use crate::{
-    Data,
+    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
-    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
-    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
 };
 
 #[derive(Deserialize)]
@@ -56,10 +54,7 @@ impl Default for ResponseError {
 }
 
 #[post("/register")]
-pub async fn res(
+pub async fn res(account_information: web::Json<AccountInformation>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    account_information: web::Json<AccountInformation>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let uuid = Uuid::now_v7();
 
     if !EMAIL_REGEX.is_match(&account_information.email) {
@@ -147,9 +142,9 @@ pub async fn res(
                         return Ok(HttpResponse::InternalServerError().finish())
                     }
 
-                    HttpResponse::Ok()
+                    HttpResponse::Ok().cookie(refresh_token_cookie(refresh_token)).json(Response {
-                        .cookie(refresh_token_cookie(refresh_token))
+                        access_token,
-                        .json(Response { access_token })
+                    })
                 }
                 Err(error) => {
                     let err_msg = error.as_database_error().unwrap().message();

src/api/v1/auth/revoke.rs

@@ -1,6 +1,6 @@
 use actix_web::{Error, HttpRequest, HttpResponse, post, web};
 use argon2::{PasswordHash, PasswordVerifier};
-use futures::future;
+use futures::{future};
 use log::error;
 use serde::{Deserialize, Serialize};
 
@@ -105,7 +105,10 @@ pub async fn res(
     let results = future::join_all(refresh_tokens_delete).await;
 
     let errors: Vec<&Result<sqlx::postgres::PgQueryResult, sqlx::Error>> =
-        results.iter().filter(|r| r.is_err()).collect();
+        results
+            .iter()
+            .filter(|r| r.is_err())
+            .collect();
 
     if !errors.is_empty() {
         error!("{:?}", errors);

src/api/v1/invites/id.rs

@@ -1,24 +1,15 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
 
-use crate::{
+use crate::{api::v1::auth::check_access_token, structs::{Guild, Invite, Member}, utils::get_auth_header, Data};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Guild, Invite, Member},
-    utils::get_auth_header,
-};
 
 #[get("{id}")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(String,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(String,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let invite_id = path.into_inner().0;
@@ -26,7 +17,7 @@ pub async fn get(
     let result = Invite::fetch_one(&data.pool, invite_id).await;
 
     if let Err(error) = result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let invite = result.unwrap();
@@ -43,17 +34,13 @@ pub async fn get(
 }
 
 #[post("{id}")]
-pub async fn join(
+pub async fn join(req: HttpRequest, path: web::Path<(String,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(String,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let invite_id = path.into_inner().0;
@@ -61,7 +48,7 @@ pub async fn join(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -69,7 +56,7 @@ pub async fn join(
     let result = Invite::fetch_one(&data.pool, invite_id).await;
 
     if let Err(error) = result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let invite = result.unwrap();
@@ -83,7 +70,7 @@ pub async fn join(
     let guild = guild_result.unwrap();
 
     let member = Member::new(&data.pool, uuid, guild.uuid).await;
-
+    
     if let Err(error) = member {
         return Ok(error);
     }

src/api/v1/invites/mod.rs

@@ -1,7 +1,9 @@
-use actix_web::{Scope, web};
+use actix_web::{web, Scope};
 
 mod id;
 
 pub fn web() -> Scope {
-    web::scope("/invites").service(id::get).service(id::join)
+    web::scope("/invites")
+        .service(id::get)
+        .service(id::join)
 }

src/api/v1/mod.rs

@@ -1,10 +1,10 @@
 use actix_web::{Scope, web};
 
 mod auth;
-mod invites;
-mod servers;
 mod stats;
 mod users;
+mod servers;
+mod invites;
 
 pub fn web() -> Scope {
     web::scope("/v1")

src/api/v1/servers/mod.rs

@@ -1,9 +1,9 @@
-use actix_web::{get, post, web, Error, HttpRequest, HttpResponse, Scope};
+use actix_web::{post, web, Error, HttpRequest, HttpResponse, Scope};
 use serde::Deserialize;
 
 mod uuid;
 
-use crate::{api::v1::auth::check_access_token, structs::{Guild, StartAmountQuery}, utils::get_auth_header, Data};
+use crate::{api::v1::auth::check_access_token, structs::Guild, utils::get_auth_header, Data};
 
 #[derive(Deserialize)]
 struct GuildInfo {
@@ -13,78 +13,34 @@ struct GuildInfo {
 
 pub fn web() -> Scope {
     web::scope("/servers")
-        .service(create)
+        .service(res)
-        .service(get)
         .service(uuid::web())
 }
 
 #[post("")]
-pub async fn create(
+pub async fn res(req: HttpRequest, guild_info: web::Json<GuildInfo>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    guild_info: web::Json<GuildInfo>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
 
-    let guild = Guild::new(
+    let guild = Guild::new(&data.pool, guild_info.name.clone(), guild_info.description.clone(), uuid).await;
-        &data.pool,
-        guild_info.name.clone(),
-        guild_info.description.clone(),
-        uuid,
-    )
-    .await;
 
     if let Err(error) = guild {
-        return Ok(error);
+        return Ok(error)
     }
 
     Ok(HttpResponse::Ok().json(guild.unwrap()))
 }
 
-#[get("")]
-pub async fn get(
-    req: HttpRequest,
-    request_query: web::Query<StartAmountQuery>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers);
-
-    let start = request_query.start.unwrap_or(0);
-
-    let amount = request_query.amount.unwrap_or(10);
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
-
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    let guilds = Guild::fetch_amount(&data.pool, start, amount).await;
-
-    if let Err(error) = guilds {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guilds.unwrap()))
-}
-

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

@@ -1,34 +1,25 @@
-use crate::{
+use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Channel, Member},
-    utils::get_auth_header,
-};
-use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
-use log::error;
 use serde::Deserialize;
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
+use ::uuid::Uuid;
+use log::error;
 
 pub mod uuid;
 
 #[derive(Deserialize)]
 struct ChannelInfo {
     name: String,
-    description: Option<String>,
+    description: Option<String>
 }
 
 #[get("{uuid}/channels")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -36,7 +27,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -50,22 +41,18 @@ pub async fn get(
     let cache_result = data.get_cache_key(format!("{}_channels", guild_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().content_type("application/json").body(cache_hit))
-            .content_type("application/json")
-            .body(cache_hit));
     }
 
     let channels_result = Channel::fetch_all(&data.pool, guild_uuid).await;
 
     if let Err(error) = channels_result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let channels = channels_result.unwrap();
 
-    let cache_result = data
+    let cache_result = data.set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800).await;
-        .set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800)
-        .await;
 
     if let Err(error) = cache_result {
         error!("{}", error);
@@ -76,18 +63,13 @@ pub async fn get(
 }
 
 #[post("{uuid}/channels")]
-pub async fn create(
+pub async fn create(req: HttpRequest, channel_info: web::Json<ChannelInfo>, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    channel_info: web::Json<ChannelInfo>,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -95,7 +77,7 @@ pub async fn create(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -108,13 +90,7 @@ pub async fn create(
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
-    let channel = Channel::new(
+    let channel = Channel::new(data.clone(), guild_uuid, channel_info.name.clone(), channel_info.description.clone()).await;
-        data.clone(),
-        guild_uuid,
-        channel_info.name.clone(),
-        channel_info.description.clone(),
-    )
-    .await;
 
     if let Err(error) = channel {
         return Ok(error);

src/api/v1/servers/uuid/channels/uuid/messages.rs

@@ -1,13 +1,8 @@
-use crate::{
+use actix_web::{get, web, Error, HttpRequest, HttpResponse};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Channel, Member},
-    utils::get_auth_header,
-};
-use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
-use log::error;
 use serde::Deserialize;
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
+use ::uuid::Uuid;
+use log::error;
 
 #[derive(Deserialize)]
 struct MessageRequest {
@@ -16,18 +11,13 @@ struct MessageRequest {
 }
 
 #[get("{uuid}/channels/{channel_uuid}/messages")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, message_request: web::Query<MessageRequest>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid, Uuid)>,
-    message_request: web::Query<MessageRequest>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
@@ -35,7 +25,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -56,27 +46,23 @@ pub async fn get(
         let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
 
         if let Err(error) = channel_result {
-            return Ok(error);
+            return Ok(error)
         }
-
+    
         channel = channel_result.unwrap();
-
+    
-        let cache_result = data
+        let cache_result = data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60).await;
-            .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
+    
-            .await;
-
         if let Err(error) = cache_result {
             error!("{}", error);
             return Ok(HttpResponse::InternalServerError().finish());
         }
     }
 
-    let messages = channel
+    let messages = channel.fetch_messages(&data.pool, message_request.amount, message_request.offset).await;
-        .fetch_messages(&data.pool, message_request.amount, message_request.offset)
-        .await;
 
     if let Err(error) = messages {
-        return Ok(error);
+        return Ok(error)
     }
 
     Ok(HttpResponse::Ok().json(messages.unwrap()))

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

@@ -1,28 +1,19 @@
 pub mod messages;
 pub mod socket;
 
-use crate::{
+use actix_web::{delete, get, web, Error, HttpRequest, HttpResponse};
-    Data,
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
-    api::v1::auth::check_access_token,
-    structs::{Channel, Member},
-    utils::get_auth_header,
-};
 use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, delete, get, web};
 use log::error;
 
 #[get("{uuid}/channels/{channel_uuid}")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid, Uuid)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
@@ -30,7 +21,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -44,22 +35,18 @@ pub async fn get(
     let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().content_type("application/json").body(cache_hit))
-            .content_type("application/json")
-            .body(cache_hit));
     }
 
     let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
 
     if let Err(error) = channel_result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let channel = channel_result.unwrap();
 
-    let cache_result = data
+    let cache_result = data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60).await;
-        .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-        .await;
 
     if let Err(error) = cache_result {
         error!("{}", error);
@@ -70,17 +57,13 @@ pub async fn get(
 }
 
 #[delete("{uuid}/channels/{channel_uuid}")]
-pub async fn delete(
+pub async fn delete(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid, Uuid)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
@@ -88,7 +71,7 @@ pub async fn delete(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -115,7 +98,7 @@ pub async fn delete(
         let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
 
         if let Err(error) = channel_result {
-            return Ok(error);
+            return Ok(error)
         }
 
         channel = channel_result.unwrap();
@@ -124,8 +107,9 @@ pub async fn delete(
     let delete_result = channel.delete(&data.pool).await;
 
     if let Err(error) = delete_result {
-        return Ok(error);
+        return Ok(error)
     }
 
     Ok(HttpResponse::Ok().finish())
 }
+

src/api/v1/servers/uuid/channels/uuid/socket.rs

@@ -1,23 +1,13 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, rt, web};
+use actix_web::{get, rt, web, Error, HttpRequest, HttpResponse};
 use actix_ws::AggregatedMessage;
 use futures_util::StreamExt as _;
-use log::error;
 use uuid::Uuid;
+use log::error;
 
-use crate::{
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Channel, Member},
-    utils::get_auth_header,
-};
 
 #[get("{uuid}/channels/{channel_uuid}/socket")]
-pub async fn echo(
+pub async fn echo(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, stream: web::Payload, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid, Uuid)>,
-    stream: web::Payload,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     // Get all headers
     let headers = req.headers();
 
@@ -25,7 +15,7 @@ pub async fn echo(
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     // Get uuids from path
@@ -35,7 +25,7 @@ pub async fn echo(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     // Unwrap user uuid from authorization
@@ -60,15 +50,13 @@ pub async fn echo(
         let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
 
         if let Err(error) = channel_result {
-            return Ok(error);
+            return Ok(error)
         }
-
+    
         channel = channel_result.unwrap();
-
+    
-        let cache_result = data
+        let cache_result = data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60).await;
-            .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
+    
-            .await;
-
         if let Err(error) = cache_result {
             error!("{}", error);
             return Ok(HttpResponse::InternalServerError().finish());
@@ -86,7 +74,7 @@ pub async fn echo(
 
     if let Err(error) = pubsub_result {
         error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
+        return Ok(HttpResponse::InternalServerError().finish())
     }
 
     let mut session_2 = session_1.clone();
@@ -102,25 +90,14 @@ pub async fn echo(
 
     // start task but don't wait for it
     rt::spawn(async move {
-        let mut conn = data
+        let mut conn = data.cache_pool.get_multiplexed_tokio_connection().await.unwrap();
-            .cache_pool
-            .get_multiplexed_tokio_connection()
-            .await
-            .unwrap();
         // receive messages from websocket
         while let Some(msg) = stream.next().await {
             match msg {
                 Ok(AggregatedMessage::Text(text)) => {
                     // echo text message
-                    redis::cmd("PUBLISH")
+                    redis::cmd("PUBLISH").arg(&[channel_uuid.to_string(), text.to_string()]).exec_async(&mut conn).await.unwrap();
-                        .arg(&[channel_uuid.to_string(), text.to_string()])
+                    channel.new_message(&data.pool, uuid, text.to_string()).await.unwrap();
-                        .exec_async(&mut conn)
-                        .await
-                        .unwrap();
-                    channel
-                        .new_message(&data.pool, uuid, text.to_string())
-                        .await
-                        .unwrap();
                 }
 
                 Ok(AggregatedMessage::Binary(bin)) => {

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

@@ -1,15 +1,10 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
 use serde::Deserialize;
 use uuid::Uuid;
 
 mod id;
 
-use crate::{
+use crate::{api::v1::auth::check_access_token, structs::{Guild, Member}, utils::get_auth_header, Data};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Guild, Member},
-    utils::get_auth_header,
-};
 
 #[derive(Deserialize)]
 struct InviteRequest {
@@ -17,17 +12,13 @@ struct InviteRequest {
 }
 
 #[get("{uuid}/invites")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -35,7 +26,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -58,24 +49,19 @@ pub async fn get(
 
     if let Err(error) = invites {
         return Ok(error);
-    }
+    }    
 
     Ok(HttpResponse::Ok().json(invites.unwrap()))
 }
 
 #[post("{uuid}/invites")]
-pub async fn create(
+pub async fn create(req: HttpRequest, path: web::Path<(Uuid,)>, invite_request: web::Json<Option<InviteRequest>>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    invite_request: web::Json<Option<InviteRequest>>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -83,7 +69,7 @@ pub async fn create(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -104,7 +90,7 @@ pub async fn create(
 
     let guild = guild_result.unwrap();
 
-    let custom_id = invite_request.as_ref().map(|ir| ir.custom_id.clone());
+    let custom_id =  invite_request.as_ref().and_then(|ir| Some(ir.custom_id.clone()));
 
     let invite = guild.create_invite(&data.pool, &member, custom_id).await;
 

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

@@ -1,16 +1,11 @@
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use actix_web::{get, web, Error, HttpRequest, HttpResponse, Scope};
 use uuid::Uuid;
 
 mod channels;
-mod invites;
 mod roles;
+mod invites;
 
-use crate::{
+use crate::{api::v1::auth::check_access_token, structs::{Guild, Member}, utils::get_auth_header, Data};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Guild, Member},
-    utils::get_auth_header,
-};
 
 pub fn web() -> Scope {
     web::scope("")
@@ -33,17 +28,13 @@ pub fn web() -> Scope {
 }
 
 #[get("/{uuid}")]
-pub async fn res(
+pub async fn res(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -51,7 +42,7 @@ pub async fn res(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -70,3 +61,4 @@ pub async fn res(
 
     Ok(HttpResponse::Ok().json(guild.unwrap()))
 }
+

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

@@ -1,13 +1,8 @@
-use crate::{
+use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
-    Data,
-    api::v1::auth::check_access_token,
-    structs::{Member, Role},
-    utils::get_auth_header,
-};
-use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
-use log::error;
 use serde::Deserialize;
+use crate::{api::v1::auth::check_access_token, structs::{Member, Role}, utils::get_auth_header, Data};
+use ::uuid::Uuid;
+use log::error;
 
 pub mod uuid;
 
@@ -17,17 +12,13 @@ struct RoleInfo {
 }
 
 #[get("{uuid}/roles")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -35,7 +26,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -49,22 +40,18 @@ pub async fn get(
     let cache_result = data.get_cache_key(format!("{}_roles", guild_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().content_type("application/json").body(cache_hit))
-            .content_type("application/json")
-            .body(cache_hit));
     }
 
     let roles_result = Role::fetch_all(&data.pool, guild_uuid).await;
 
     if let Err(error) = roles_result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let roles = roles_result.unwrap();
 
-    let cache_result = data
+    let cache_result = data.set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800).await;
-        .set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800)
-        .await;
 
     if let Err(error) = cache_result {
         error!("{}", error);
@@ -75,18 +62,13 @@ pub async fn get(
 }
 
 #[post("{uuid}/roles")]
-pub async fn create(
+pub async fn create(req: HttpRequest, role_info: web::Json<RoleInfo>, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    role_info: web::Json<RoleInfo>,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let guild_uuid = path.into_inner().0;
@@ -94,7 +76,7 @@ pub async fn create(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();

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

@@ -1,25 +1,16 @@
-use crate::{
+use actix_web::{get, web, Error, HttpRequest, HttpResponse};
-    Data,
+use crate::{api::v1::auth::check_access_token, structs::{Member, Role}, utils::get_auth_header, Data};
-    api::v1::auth::check_access_token,
-    structs::{Member, Role},
-    utils::get_auth_header,
-};
 use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
 use log::error;
 
 #[get("{uuid}/roles/{role_uuid}")]
-pub async fn get(
+pub async fn get(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    req: HttpRequest,
-    path: web::Path<(Uuid, Uuid)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
 
     if let Err(error) = auth_header {
-        return Ok(error);
+        return Ok(error)
     }
 
     let (guild_uuid, role_uuid) = path.into_inner();
@@ -27,7 +18,7 @@ pub async fn get(
     let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
 
     if let Err(error) = authorized {
-        return Ok(error);
+        return Ok(error)
     }
 
     let uuid = authorized.unwrap();
@@ -41,22 +32,18 @@ pub async fn get(
     let cache_result = data.get_cache_key(format!("{}", role_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().content_type("application/json").body(cache_hit))
-            .content_type("application/json")
-            .body(cache_hit));
     }
 
     let role_result = Role::fetch_one(&data.pool, guild_uuid, role_uuid).await;
 
     if let Err(error) = role_result {
-        return Ok(error);
+        return Ok(error)
     }
 
     let role = role_result.unwrap();
 
-    let cache_result = data
+    let cache_result = data.set_cache_key(format!("{}", role_uuid), role.clone(), 60).await;
-        .set_cache_key(format!("{}", role_uuid), role.clone(), 60)
-        .await;
 
     if let Err(error) = cache_result {
         error!("{}", error);

src/api/v1/users/mod.rs

@@ -1,12 +1,18 @@
-use crate::{api::v1::auth::check_access_token, structs::StartAmountQuery, utils::get_auth_header, Data};
+use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use actix_web::{get, web, Error, HttpRequest, HttpResponse, Scope};
 use log::error;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sqlx::prelude::FromRow;
 
 mod me;
 mod uuid;
 
+#[derive(Deserialize)]
+struct RequestQuery {
+    start: Option<i32>,
+    amount: Option<i32>,
+}
+
 #[derive(Serialize, FromRow)]
 struct Response {
     uuid: String,
@@ -25,7 +31,7 @@ pub fn web() -> Scope {
 #[get("")]
 pub async fn res(
     req: HttpRequest,
-    request_query: web::Query<StartAmountQuery>,
+    request_query: web::Query<RequestQuery>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();

src/api/v1/users/uuid.rs

@@ -37,9 +37,7 @@ pub async fn res(
     let cache_result = data.get_cache_key(uuid.to_string()).await;
 
     if let Ok(cache_hit) = cache_result {
-        return Ok(HttpResponse::Ok()
+        return Ok(HttpResponse::Ok().content_type("application/json").body(cache_hit))
-            .content_type("application/json")
-            .body(cache_hit));
     }
 
     let row = sqlx::query_as(&format!(
@@ -62,9 +60,7 @@ pub async fn res(
         display_name: display_name.unwrap_or_default(),
     };
 
-    let cache_result = data
+    let cache_result = data.set_cache_key(uuid.to_string(), user.clone(), 1800).await;
-        .set_cache_key(uuid.to_string(), user.clone(), 1800)
-        .await;
 
     if let Err(error) = cache_result {
         error!("{}", error);

src/main.rs

@@ -1,5 +1,5 @@
 use actix_cors::Cors;
-use actix_web::{App, HttpServer, web};
+use actix_web::{web, App, HttpServer};
 use argon2::Argon2;
 use clap::Parser;
 use simple_logger::SimpleLogger;
@@ -9,8 +9,8 @@ mod config;
 use config::{Config, ConfigBuilder};
 mod api;
 
-pub mod structs;
 pub mod utils;
+pub mod structs;
 
 type Error = Box<dyn std::error::Error>;
 
@@ -169,7 +169,7 @@ async fn main() -> Result<(), Error> {
         argon2: Argon2::default(),
         start_time: SystemTime::now(),
     };
-
+    
     HttpServer::new(move || {
         // Set CORS headers
         let cors = Cors::default()
@@ -179,7 +179,9 @@ async fn main() -> Result<(), Error> {
                 rather than setting it to "*" due to CORS not allowing
                 sending of credentials (cookies) with wildcard origin.
             */
-            .allowed_origin_fn(|_origin, _req_head| true)
+            .allowed_origin_fn(|_origin, _req_head| {
+                true
+            })
             /*
                 Allows any request method in CORS preflight requests.
                 This will be restricted to only ones actually in use later.

src/structs.rs

@@ -1,10 +1,10 @@
 use std::str::FromStr;
 
+use serde::{Deserialize, Serialize};
+use sqlx::{prelude::FromRow, Pool, Postgres};
+use uuid::Uuid;
 use actix_web::HttpResponse;
 use log::error;
-use serde::{Deserialize, Serialize};
-use sqlx::{Pool, Postgres, prelude::FromRow};
-use uuid::Uuid;
 
 use crate::Data;
 
@@ -14,13 +14,13 @@ pub struct Channel {
     pub guild_uuid: Uuid,
     name: String,
     description: Option<String>,
-    pub permissions: Vec<ChannelPermission>,
+    pub permissions: Vec<ChannelPermission>
 }
 
 #[derive(Serialize, Clone, FromRow)]
 struct ChannelPermissionBuilder {
     role_uuid: String,
-    permissions: i32,
+    permissions: i32
 }
 
 impl ChannelPermissionBuilder {
@@ -35,25 +35,19 @@ impl ChannelPermissionBuilder {
 #[derive(Serialize, Deserialize, Clone, FromRow)]
 pub struct ChannelPermission {
     pub role_uuid: Uuid,
-    pub permissions: i32,
+    pub permissions: i32
 }
 
 impl Channel {
-    pub async fn fetch_all(
+    pub async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
-        pool: &Pool<Postgres>,
+        let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), name, description FROM channels WHERE guild_uuid = '{}'", guild_uuid))
-        guild_uuid: Uuid,
+            .fetch_all(pool)
-    ) -> Result<Vec<Self>, HttpResponse> {
+            .await;
-        let row = sqlx::query_as(&format!(
-            "SELECT CAST(uuid AS VARCHAR), name, description FROM channels WHERE guild_uuid = '{}'",
-            guild_uuid
-        ))
-        .fetch_all(pool)
-        .await;
 
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let channels: Vec<(String, String, Option<String>)> = row.unwrap();
@@ -86,25 +80,18 @@ impl Channel {
 
         let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
 
-        channels
+        Ok(channels?)
     }
 
-    pub async fn fetch_one(
+    pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid, channel_uuid: Uuid) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
+        let row = sqlx::query_as(&format!("SELECT name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, channel_uuid))
-        guild_uuid: Uuid,
+            .fetch_one(pool)
-        channel_uuid: Uuid,
+            .await;
-    ) -> Result<Self, HttpResponse> {
-        let row = sqlx::query_as(&format!(
-            "SELECT name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'",
-            guild_uuid, channel_uuid
-        ))
-        .fetch_one(pool)
-        .await;
 
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let (name, description): (String, Option<String>) = row.unwrap();
@@ -116,7 +103,7 @@ impl Channel {
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
@@ -126,19 +113,11 @@ impl Channel {
             guild_uuid,
             name,
             description,
-            permissions: channel_permission_builders
+            permissions: channel_permission_builders.iter().map(|b| b.build()).collect(),
-                .iter()
-                .map(|b| b.build())
-                .collect(),
         })
     }
 
-    pub async fn new(
+    pub async fn new(data: actix_web::web::Data<Data>, guild_uuid: Uuid, name: String, description: Option<String>) -> Result<Self, HttpResponse> {
-        data: actix_web::web::Data<Data>,
-        guild_uuid: Uuid,
-        name: String,
-        description: Option<String>,
-    ) -> Result<Self, HttpResponse> {
         let channel_uuid = Uuid::now_v7();
 
         let row = sqlx::query(&format!("INSERT INTO channels (uuid, guild_uuid, name, description) VALUES ('{}', '{}', $1, $2)", channel_uuid, guild_uuid))
@@ -146,10 +125,10 @@ impl Channel {
             .bind(&description)
             .execute(&data.pool)
             .await;
-
+    
         if let Err(error) = row {
             error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let channel = Self {
@@ -160,9 +139,7 @@ impl Channel {
             permissions: vec![],
         };
 
-        let cache_result = data
+        let cache_result = data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800).await;
-            .set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
-            .await;
 
         if let Err(error) = cache_result {
             error!("{}", error);
@@ -180,28 +157,20 @@ impl Channel {
     }
 
     pub async fn delete(self, pool: &Pool<Postgres>) -> Result<(), HttpResponse> {
-        let result = sqlx::query(&format!(
+        let result = sqlx::query(&format!("DELETE FROM channels WHERE channel_uuid = '{}'", self.uuid))
-            "DELETE FROM channels WHERE channel_uuid = '{}'",
+            .execute(pool)
-            self.uuid
+            .await;
-        ))
-        .execute(pool)
-        .await;
 
         if let Err(error) = result {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(())
     }
 
-    pub async fn fetch_messages(
+    pub async fn fetch_messages(&self, pool: &Pool<Postgres>, amount: i64, offset: i64) -> Result<Vec<Message>, HttpResponse> {
-        &self,
-        pool: &Pool<Postgres>,
-        amount: i64,
-        offset: i64,
-    ) -> Result<Vec<Message>, HttpResponse> {
         let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), CAST(user_uuid AS VARCHAR), CAST(channel_uuid AS VARCHAR), message FROM messages WHERE channel_uuid = '{}' ORDER BY uuid DESC LIMIT $1 OFFSET $2", self.uuid))
             .bind(amount)
             .bind(offset)
@@ -218,19 +187,14 @@ impl Channel {
         Ok(message_builders.iter().map(|b| b.build()).collect())
     }
 
-    pub async fn new_message(
+    pub async fn new_message(&self, pool: &Pool<Postgres>, user_uuid: Uuid, message: String) -> Result<Message, HttpResponse> {
-        &self,
-        pool: &Pool<Postgres>,
-        user_uuid: Uuid,
-        message: String,
-    ) -> Result<Message, HttpResponse> {
         let message_uuid = Uuid::now_v7();
 
         let row = sqlx::query(&format!("INSERT INTO messages (uuid, channel_uuid, user_uuid, message) VALUES ('{}', '{}', '{}', $1)", message_uuid, self.uuid, user_uuid))
             .bind(&message)
             .execute(pool)
             .await;
-
+    
         if let Err(error) = row {
             error!("{}", error);
             return Err(HttpResponse::InternalServerError().finish());
@@ -276,8 +240,7 @@ impl Permissions {
             Self::ManageMember,
         ];
 
-        all_perms
+        all_perms.into_iter()
-            .into_iter()
             .filter(|p| permissions & (*p as i64) != 0)
             .collect()
     }
@@ -296,17 +259,14 @@ pub struct Guild {
 
 impl Guild {
     pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
-        let row = sqlx::query_as(&format!(
+        let row = sqlx::query_as(&format!("SELECT CAST(owner_uuid AS VARCHAR), name, description FROM guilds WHERE uuid = '{}'", guild_uuid))
-            "SELECT CAST(owner_uuid AS VARCHAR), name, description FROM guilds WHERE uuid = '{}'",
+            .fetch_one(pool)
-            guild_uuid
+            .await;
-        ))
-        .fetch_one(pool)
-        .await;
 
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let (owner_uuid_raw, name, description): (String, String, Option<String>) = row.unwrap();
@@ -329,88 +289,24 @@ impl Guild {
         })
     }
 
-    pub async fn fetch_amount(
+    pub async fn new(pool: &Pool<Postgres>, name: String, description: Option<String>, owner_uuid: Uuid) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
-        start: i32,
-        amount: i32,
-    ) -> Result<Vec<Self>, HttpResponse> {
-        // Fetch guild data from database
-        let rows = sqlx::query_as::<_, (String, String, String, Option<String>)>(
-            "SELECT CAST(uuid AS VARCHAR), CAST(owner_uuid AS VARCHAR), name, description 
-            FROM guilds 
-            ORDER BY name 
-            LIMIT $1 OFFSET $2",
-        )
-        .bind(amount)
-        .bind(start)
-        .fetch_all(pool)
-        .await
-        .map_err(|error| {
-            error!("{}", error);
-            HttpResponse::InternalServerError().finish()
-        })?;
-
-        // Process each guild concurrently
-        let guild_futures = rows.into_iter().map(|(guild_uuid_raw, owner_uuid_raw, name, description)| async move {
-            let uuid = Uuid::from_str(&guild_uuid_raw).map_err(|_| {
-                HttpResponse::BadRequest().body("Invalid guild UUID format")
-            })?;
-
-            let owner_uuid = Uuid::from_str(&owner_uuid_raw).map_err(|_| {
-                HttpResponse::BadRequest().body("Invalid owner UUID format")
-            })?;
-
-            let (member_count, roles) = tokio::try_join!(
-                Member::count(pool, uuid),
-                Role::fetch_all(pool, uuid)
-            )?;
-
-            Ok::<Guild, HttpResponse>(Self {
-                uuid,
-                name,
-                description,
-                icon: String::from("bogus"), // FIXME: Replace with actual icon handling
-                owner_uuid,
-                roles,
-                member_count,
-            })
-        });
-
-        // Execute all futures concurrently and collect results
-        futures::future::try_join_all(guild_futures).await
-    }
-
-    pub async fn new(
-        pool: &Pool<Postgres>,
-        name: String,
-        description: Option<String>,
-        owner_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
         let guild_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let row = sqlx::query(&format!("INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)", guild_uuid, owner_uuid))
-            "INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)",
+            .bind(&name)
-            guild_uuid, owner_uuid
+            .bind(&description)
-        ))
+            .execute(pool)
-        .bind(&name)
+            .await;
-        .bind(&description)
+    
-        .execute(pool)
-        .await;
-
         if let Err(error) = row {
             error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
-
+    
-        let row = sqlx::query(&format!(
+        let row = sqlx::query(&format!("INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')", Uuid::now_v7(), guild_uuid, owner_uuid))
-            "INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')",
+            .execute(pool)
-            Uuid::now_v7(),
+            .await;
-            guild_uuid,
+    
-            owner_uuid
-        ))
-        .execute(pool)
-        .await;
-
         if let Err(error) = row {
             error!("{}", error);
 
@@ -422,7 +318,7 @@ impl Guild {
                 error!("{}", error);
             }
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(Guild {
@@ -432,38 +328,26 @@ impl Guild {
             icon: "bogus".to_string(),
             owner_uuid,
             roles: vec![],
-            member_count: 1,
+            member_count: 1
         })
     }
 
     pub async fn get_invites(&self, pool: &Pool<Postgres>) -> Result<Vec<Invite>, HttpResponse> {
-        let invites = sqlx::query_as(&format!(
+        let invites = sqlx::query_as(&format!("SELECT (id, guild_uuid, user_uuid) FROM invites WHERE guild_uuid = '{}'", self.uuid))
-            "SELECT (id, guild_uuid, user_uuid) FROM invites WHERE guild_uuid = '{}'",
+            .fetch_all(pool)
-            self.uuid
+            .await;
-        ))
-        .fetch_all(pool)
-        .await;
 
         if let Err(error) = invites {
             error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
-        Ok(invites
+        Ok(invites.unwrap().iter().map(|b: &InviteBuilder| b.build()).collect())
-            .unwrap()
-            .iter()
-            .map(|b: &InviteBuilder| b.build())
-            .collect())
     }
 
-    pub async fn create_invite(
+    pub async fn create_invite(&self, pool: &Pool<Postgres>, member: &Member, custom_id: Option<String>) -> Result<Invite, HttpResponse> {
-        &self,
-        pool: &Pool<Postgres>,
-        member: &Member,
-        custom_id: Option<String>,
-    ) -> Result<Invite, HttpResponse> {
         let invite_id;
-
+        
         if custom_id.is_none() {
             let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
@@ -471,21 +355,18 @@ impl Guild {
         } else {
             invite_id = custom_id.unwrap();
             if invite_id.len() > 32 {
-                return Err(HttpResponse::BadRequest().finish());
+                return Err(HttpResponse::BadRequest().finish())
             }
         }
 
-        let result = sqlx::query(&format!(
+        let result = sqlx::query(&format!("INSERT INTO invites (id, guild_uuid, user_uuid) VALUES ($1, '{}', '{}'", self.uuid, member.user_uuid))
-            "INSERT INTO invites (id, guild_uuid, user_uuid) VALUES ($1, '{}', '{}'",
+            .bind(&invite_id)
-            self.uuid, member.user_uuid
+            .execute(pool)
-        ))
+            .await;
-        .bind(&invite_id)
-        .execute(pool)
-        .await;
 
         if let Err(error) = result {
             error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(Invite {
@@ -503,7 +384,7 @@ struct RoleBuilder {
     name: String,
     color: i64,
     position: i32,
-    permissions: i64,
+    permissions: i64, 
 }
 
 impl RoleBuilder {
@@ -530,10 +411,7 @@ pub struct Role {
 }
 
 impl Role {
-    pub async fn fetch_all(
+    pub async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
-        pool: &Pool<Postgres>,
-        guild_uuid: Uuid,
-    ) -> Result<Vec<Self>, HttpResponse> {
         let role_builders_result = sqlx::query_as(&format!("SELECT (uuid, guild_uuid, name, color, position, permissions) FROM roles WHERE guild_uuid = '{}'", guild_uuid))
             .fetch_all(pool)
             .await;
@@ -541,7 +419,7 @@ impl Role {
         if let Err(error) = role_builders_result {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let role_builders: Vec<RoleBuilder> = role_builders_result.unwrap();
@@ -549,11 +427,7 @@ impl Role {
         Ok(role_builders.iter().map(|b| b.build()).collect())
     }
 
-    pub async fn fetch_one(
+    pub async fn fetch_one(pool: &Pool<Postgres>, role_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
-        role_uuid: Uuid,
-        guild_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
         let row = sqlx::query_as(&format!("SELECT (name, color, position, permissions) FROM roles WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, role_uuid))
             .fetch_one(pool)
             .await;
@@ -561,7 +435,7 @@ impl Role {
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let (name, color, position, permissions) = row.unwrap();
@@ -576,25 +450,18 @@ impl Role {
         })
     }
 
-    pub async fn new(
+    pub async fn new(pool: &Pool<Postgres>, guild_uuid: Uuid, name: String) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
-        guild_uuid: Uuid,
-        name: String,
-    ) -> Result<Self, HttpResponse> {
         let role_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let row = sqlx::query(&format!("INSERT INTO channels (uuid, guild_uuid, name, position) VALUES ('{}', '{}', $1, $2)", role_uuid, guild_uuid))
-            "INSERT INTO channels (uuid, guild_uuid, name, position) VALUES ('{}', '{}', $1, $2)",
+            .bind(&name)
-            role_uuid, guild_uuid
+            .bind(0)
-        ))
+            .execute(pool)
-        .bind(&name)
+            .await;
-        .bind(0)
+    
-        .execute(pool)
-        .await;
-
         if let Err(error) = row {
             error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let role = Self {
@@ -619,27 +486,20 @@ pub struct Member {
 
 impl Member {
     async fn count(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<i64, HttpResponse> {
-        let member_count = sqlx::query_scalar(&format!(
+        let member_count = sqlx::query_scalar(&format!("SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'", guild_uuid))
-            "SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'",
+            .fetch_one(pool)
-            guild_uuid
+            .await;
-        ))
-        .fetch_one(pool)
-        .await;
 
         if let Err(error) = member_count {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(member_count.unwrap())
     }
 
-    pub async fn fetch_one(
+    pub async fn fetch_one(pool: &Pool<Postgres>, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
-        user_uuid: Uuid,
-        guild_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
         let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), nickname FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, user_uuid))
             .fetch_one(pool)
             .await;
@@ -647,7 +507,7 @@ impl Member {
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         let (uuid, nickname): (String, Option<String>) = row.unwrap();
@@ -660,24 +520,17 @@ impl Member {
         })
     }
 
-    pub async fn new(
+    pub async fn new(pool: &Pool<Postgres>, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
-        pool: &Pool<Postgres>,
-        user_uuid: Uuid,
-        guild_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
         let member_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let row = sqlx::query(&format!("INSERT INTO guild_members uuid, guild_uuid, user_uuid VALUES ('{}', '{}', '{}')", member_uuid, guild_uuid, user_uuid))
-            "INSERT INTO guild_members uuid, guild_uuid, user_uuid VALUES ('{}', '{}', '{}')",
+            .execute(pool)
-            member_uuid, guild_uuid, user_uuid
+            .await;
-        ))
-        .execute(pool)
-        .await;
 
         if let Err(error) = row {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(Self {
@@ -746,16 +599,15 @@ pub struct Invite {
 
 impl Invite {
     pub async fn fetch_one(pool: &Pool<Postgres>, invite_id: String) -> Result<Self, HttpResponse> {
-        let invite: Result<InviteBuilder, sqlx::Error> =
+        let invite: Result<InviteBuilder, sqlx::Error> = sqlx::query_as("SELECT id, user_uuid, guild_uuid FROM invites WHERE id = $1")
-            sqlx::query_as("SELECT id, user_uuid, guild_uuid FROM invites WHERE id = $1")
+            .bind(invite_id)
-                .bind(invite_id)
+            .fetch_one(pool)
-                .fetch_one(pool)
+            .await;
-                .await;
 
         if let Err(error) = invite {
             error!("{}", error);
 
-            return Err(HttpResponse::InternalServerError().finish());
+            return Err(HttpResponse::InternalServerError().finish())
         }
 
         Ok(invite.unwrap().build())
@@ -776,9 +628,3 @@ impl Invite {
         Ok(())    
     }
 }
-
-#[derive(Deserialize)]
-pub struct StartAmountQuery {
-    pub start: Option<i32>,
-    pub amount: Option<i32>,
-}

src/utils.rs

@@ -1,8 +1,4 @@
-use actix_web::{
+use actix_web::{cookie::{time::Duration, Cookie, SameSite}, http::header::HeaderMap, HttpResponse};
-    HttpResponse,
-    cookie::{Cookie, SameSite, time::Duration},
-    http::header::HeaderMap,
-};
 use getrandom::fill;
 use hex::encode;
 use redis::RedisError;
@@ -13,7 +9,7 @@ use crate::Data;
 pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, HttpResponse> {
     let auth_token = headers.get(actix_web::http::header::AUTHORIZATION);
 
-    if auth_token.is_none() {
+    if let None = auth_token {
         return Err(HttpResponse::Unauthorized().finish());
     }
 
@@ -25,7 +21,7 @@ pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, HttpResponse> {
 
     let auth_value = auth.unwrap().split_whitespace().nth(1);
 
-    if auth_value.is_none() {
+    if let None = auth_value {
         return Err(HttpResponse::BadRequest().finish());
     }
 
@@ -55,27 +51,16 @@ pub fn generate_refresh_token() -> Result<String, getrandom::Error> {
 }
 
 impl Data {
-    pub async fn set_cache_key(
+    pub async fn set_cache_key(&self, key: String, value: impl Serialize, expire: u32) -> Result<(), RedisError> {
-        &self,
-        key: String,
-        value: impl Serialize,
-        expire: u32,
-    ) -> Result<(), RedisError> {
         let mut conn = self.cache_pool.get_multiplexed_tokio_connection().await?;
 
         let key_encoded = encode(key);
 
         let value_json = serde_json::to_string(&value).unwrap();
 
-        redis::cmd("SET")
+        redis::cmd("SET",).arg(&[key_encoded.clone(), value_json]).exec_async(&mut conn).await?;
-            .arg(&[key_encoded.clone(), value_json])
-            .exec_async(&mut conn)
-            .await?;
 
-        redis::cmd("EXPIRE")
+        redis::cmd("EXPIRE").arg(&[key_encoded, expire.to_string()]).exec_async(&mut conn).await
-            .arg(&[key_encoded, expire.to_string()])
-            .exec_async(&mut conn)
-            .await
     }
 
     pub async fn get_cache_key(&self, key: String) -> Result<String, RedisError> {
@@ -83,10 +68,7 @@ impl Data {
 
         let key_encoded = encode(key);
 
-        redis::cmd("GET")
+        redis::cmd("GET").arg(key_encoded).query_async(&mut conn).await
-            .arg(key_encoded)
-            .query_async(&mut conn)
-            .await
     }
 
     pub async fn del_cache_key(&self, key: String) -> Result<(), RedisError> {
@@ -94,9 +76,7 @@ impl Data {
 
         let key_encoded = encode(key);
 
-        redis::cmd("DEL")
+        redis::cmd("DEL").arg(key_encoded).query_async(&mut conn).await
-            .arg(key_encoded)
-            .query_async(&mut conn)
-            .await
     }
 }
+