feat: migrate to diesel and new error type in stats

Lets us change the schema and not worry about instance admins having to manually update their DB!

Cargo.toml

@@ -30,8 +30,10 @@ random-string = "1.1"
 actix-ws = "0.3.0"
 futures-util = "0.3.31"
 deadpool = "0.12"
-diesel = "2.2"
+diesel = { version = "2.2", features = ["uuid"] }
-diesel-async = { version = "0.5", features = ["deadpool", "postgres"] }
+diesel-async = { version = "0.5", features = ["deadpool", "postgres", "async-connection-wrapper"] }
+diesel_migrations = { version = "2.2.0", features = ["postgres"] }
+thiserror = "2.0.12"
 
 [dependencies.tokio]
 version = "1.44"

build.rs

@@ -0,0 +1,3 @@
+fn main() {
+   println!("cargo:rerun-if-changed=migrations");
+}

migrations/2025-05-21-203022_channel_description_nullable/down.sql

@@ -0,0 +1,4 @@
+-- This file should undo anything in `up.sql`
+UPDATE channels SET description = '' WHERE description IS NULL;
+ALTER TABLE ONLY channels ALTER COLUMN description SET NOT NULL;
+ALTER TABLE ONLY channels ALTER COLUMN description DROP DEFAULT;

migrations/2025-05-21-203022_channel_description_nullable/up.sql

@@ -0,0 +1,3 @@
+-- Your SQL goes here
+ALTER TABLE ONLY channels ALTER COLUMN description DROP NOT NULL;
+ALTER TABLE ONLY channels ALTER COLUMN description SET DEFAULT NULL;

src/api/v1/auth/login.rs

@@ -1,14 +1,14 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use actix_web::{Error, HttpResponse, post, web};
+use actix_web::{HttpResponse, post, web};
 use argon2::{PasswordHash, PasswordVerifier};
-use log::error;
+use diesel::{dsl::insert_into, ExpressionMethods, QueryDsl};
+use diesel_async::RunQueryDsl;
 use serde::Deserialize;
+use uuid::Uuid;
 
 use crate::{
-    Data,
+    error::Error, api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, schema::*, 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;
@@ -29,66 +29,42 @@ pub async fn response(
         return Ok(HttpResponse::Forbidden().json(r#"{ "password_hashed": false }"#));
     }
 
+    use users::dsl;
+
+    let mut conn = data.pool.get().await?;
+
     if EMAIL_REGEX.is_match(&login_information.username) {
-        let row =
+        // FIXME: error handling, right now i just want this to work
-            sqlx::query_as("SELECT CAST(uuid as VARCHAR), password FROM users WHERE email = $1")
+        let (uuid, password): (Uuid, String) = dsl::users
-                .bind(&login_information.username)
+            .filter(dsl::email.eq(&login_information.username))
-                .fetch_one(&data.pool)
+            .select((dsl::uuid, dsl::password))
-                .await;
+            .get_result(&mut conn)
+            .await?;
 
-        if let Err(error) = row {
+        return login(
-            if error.to_string()
-                == "no rows returned by a query that expected to return at least one row"
-            {
-                return Ok(HttpResponse::Unauthorized().finish());
-            }
-
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().json(
-                r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
-            ));
-        }
-
-        let (uuid, password): (String, String) = row.unwrap();
-
-        return Ok(login(
             data.clone(),
             uuid,
             login_information.password.clone(),
             password,
             login_information.device_name.clone(),
         )
-        .await);
+        .await;
     } else if USERNAME_REGEX.is_match(&login_information.username) {
-        let row =
+        // FIXME: error handling, right now i just want this to work
-            sqlx::query_as("SELECT CAST(uuid as VARCHAR), password FROM users WHERE username = $1")
+        let (uuid, password): (Uuid, String) = dsl::users
-                .bind(&login_information.username)
+            .filter(dsl::username.eq(&login_information.username))
-                .fetch_one(&data.pool)
+            .select((dsl::uuid, dsl::password))
-                .await;
+            .get_result(&mut conn)
+            .await?;
 
-        if let Err(error) = row {
+        return login(
-            if error.to_string()
-                == "no rows returned by a query that expected to return at least one row"
-            {
-                return Ok(HttpResponse::Unauthorized().finish());
-            }
-
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().json(
-                r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
-            ));
-        }
-
-        let (uuid, password): (String, String) = row.unwrap();
-
-        return Ok(login(
             data.clone(),
             uuid,
             login_information.password.clone(),
             password,
             login_information.device_name.clone(),
         )
-        .await);
+        .await;
     }
 
     Ok(HttpResponse::Unauthorized().finish())
@@ -96,79 +72,45 @@ pub async fn response(
 
 async fn login(
     data: actix_web::web::Data<Data>,
-    uuid: String,
+    uuid: Uuid,
     request_password: String,
     database_password: String,
     device_name: String,
-) -> HttpResponse {
+) -> Result<HttpResponse, Error> {
-    let parsed_hash_raw = PasswordHash::new(&database_password);
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = parsed_hash_raw {
+    let parsed_hash = PasswordHash::new(&database_password).map_err(|e| Error::PasswordHashError(e.to_string()))?;
-        error!("{}", error);
-        return HttpResponse::InternalServerError().finish();
-    }
-
-    let parsed_hash = parsed_hash_raw.unwrap();
 
     if data
         .argon2
         .verify_password(request_password.as_bytes(), &parsed_hash)
         .is_err()
     {
-        return HttpResponse::Unauthorized().finish();
+        return Err(Error::Unauthorized("Wrong username or password".to_string()));
     }
 
-    let refresh_token_raw = generate_refresh_token();
+    let refresh_token = generate_refresh_token()?;
-    let access_token_raw = generate_access_token();
+    let access_token = generate_access_token()?;
-
-    if let Err(error) = refresh_token_raw {
-        error!("{}", error);
-        return HttpResponse::InternalServerError().finish();
-    }
-
-    let refresh_token = refresh_token_raw.unwrap();
-
-    if let Err(error) = access_token_raw {
-        error!("{}", error);
-        return HttpResponse::InternalServerError().finish();
-    }
-
-    let access_token = access_token_raw.unwrap();
 
     let current_time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
+        .duration_since(UNIX_EPOCH)?
-        .unwrap()
         .as_secs() as i64;
 
-    if let Err(error) = sqlx::query(&format!(
+    use refresh_tokens::dsl as rdsl;
-        "INSERT INTO refresh_tokens (token, uuid, created_at, device_name) VALUES ($1, '{}', $2, $3 )",
-        uuid
-    ))
-    .bind(&refresh_token)
-    .bind(current_time)
-    .bind(device_name)
-    .execute(&data.pool)
-    .await
-    {
-        error!("{}", error);
-        return HttpResponse::InternalServerError().finish();
-    }
 
-    if let Err(error) = sqlx::query(&format!(
+    insert_into(refresh_tokens::table)
-        "INSERT INTO access_tokens (token, refresh_token, uuid, created_at) VALUES ($1, $2, '{}', $3 )",
+        .values((rdsl::token.eq(&refresh_token), rdsl::uuid.eq(uuid), rdsl::created_at.eq(current_time), rdsl::device_name.eq(device_name)))
-        uuid
+        .execute(&mut conn)
-    ))
+        .await?;
-    .bind(&access_token)
-    .bind(&refresh_token)
-    .bind(current_time)
-    .execute(&data.pool)
-    .await
-    {
-        error!("{}", error);
-        return HttpResponse::InternalServerError().finish()
-    }
 
-    HttpResponse::Ok()
+    use access_tokens::dsl as adsl;
+
+    insert_into(access_tokens::table)
+        .values((adsl::token.eq(&access_token), adsl::refresh_token.eq(&refresh_token), adsl::uuid.eq(uuid), adsl::created_at.eq(current_time)))
+        .execute(&mut conn)
+        .await?;
+
+    Ok(HttpResponse::Ok()
         .cookie(refresh_token_cookie(refresh_token))
-        .json(Response { access_token })
+        .json(Response { access_token }))
 }

src/api/v1/auth/mod.rs

@@ -1,16 +1,17 @@
 use std::{
-    str::FromStr,
     sync::LazyLock,
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use actix_web::{HttpResponse, Scope, web};
+use actix_web::{Scope, web};
-use log::error;
+use diesel::{ExpressionMethods, QueryDsl};
+use diesel_async::RunQueryDsl;
 use regex::Regex;
 use serde::Serialize;
-use sqlx::Postgres;
 use uuid::Uuid;
 
+use crate::{error::Error, Conn, schema::access_tokens::dsl};
+
 mod login;
 mod refresh;
 mod register;
@@ -40,40 +41,30 @@ pub fn web() -> Scope {
 
 pub async fn check_access_token(
     access_token: &str,
-    pool: &sqlx::Pool<Postgres>,
+    conn: &mut Conn,
-) -> Result<Uuid, HttpResponse> {
+) -> Result<Uuid, Error> {
-    let row = sqlx::query_as(
+    let (uuid, created_at): (Uuid, i64) = dsl::access_tokens
-        "SELECT CAST(uuid as VARCHAR), created_at FROM access_tokens WHERE token = $1",
+        .filter(dsl::token.eq(access_token))
-    )
+        .select((dsl::uuid, dsl::created_at))
-    .bind(access_token)
+        .get_result(conn)
-    .fetch_one(pool)
+        .await
-    .await;
+        .map_err(|error| {
-
+            if error == diesel::result::Error::NotFound {
-    if let Err(error) = row {
+                Error::Unauthorized("Invalid access token".to_string())
-        if error.to_string()
+            } else {
-            == "no rows returned by a query that expected to return at least one row"
+                Error::from(error)
-        {
-            return Err(HttpResponse::Unauthorized().finish());
             }
-
+        })?;
-        error!("{}", error);
-        return Err(HttpResponse::InternalServerError().json(
-            r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
-        ));
-    }
-
-    let (uuid, created_at): (String, i64) = row.unwrap();
 
     let current_time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
+        .duration_since(UNIX_EPOCH)?
-        .unwrap()
         .as_secs() as i64;
 
     let lifetime = current_time - created_at;
 
     if lifetime > 3600 {
-        return Err(HttpResponse::Unauthorized().finish());
+        return Err(Error::Unauthorized("Invalid access token".to_string()));
     }
 
-    Ok(Uuid::from_str(&uuid).unwrap())
+    Ok(uuid)
 }

src/api/v1/auth/refresh.rs

@@ -1,10 +1,11 @@
-use actix_web::{Error, HttpRequest, HttpResponse, post, web};
+use actix_web::{HttpRequest, HttpResponse, post, web};
+use diesel::{delete, update, ExpressionMethods, QueryDsl};
+use diesel_async::RunQueryDsl;
 use log::error;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::{
-    Data,
+    error::Error, schema::{access_tokens::{self, dsl}, refresh_tokens::{self, dsl as rdsl}}, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
-    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
 };
 
 use super::Response;
@@ -20,23 +21,23 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
     let mut refresh_token = String::from(recv_refresh_token_cookie.unwrap().value());
 
     let current_time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
+        .duration_since(UNIX_EPOCH)?
-        .unwrap()
         .as_secs() as i64;
 
-    if let Ok(row) = sqlx::query_scalar("SELECT created_at FROM refresh_tokens WHERE token = $1")
+    let mut conn = data.pool.get().await?;
-        .bind(&refresh_token)
+
-        .fetch_one(&data.pool)
+    if let Ok(created_at) = rdsl::refresh_tokens
+        .filter(rdsl::token.eq(&refresh_token))
+        .select(rdsl::created_at)
+        .get_result::<i64>(&mut conn)
         .await
     {
-        let created_at: i64 = row;
-
         let lifetime = current_time - created_at;
 
         if lifetime > 2592000 {
-            if let Err(error) = sqlx::query("DELETE FROM refresh_tokens WHERE token = $1")
+            if let Err(error) = delete(refresh_tokens::table)
-                .bind(&refresh_token)
+                .filter(rdsl::token.eq(&refresh_token))
-                .execute(&data.pool)
+                .execute(&mut conn)
                 .await
             {
                 error!("{}", error);
@@ -52,8 +53,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
         }
 
         let current_time = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
+            .duration_since(UNIX_EPOCH)?
-            .unwrap()
             .as_secs() as i64;
 
         if lifetime > 1987200 {
@@ -66,13 +66,13 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
 
             let new_refresh_token = new_refresh_token.unwrap();
 
-            match sqlx::query(
+            match update(refresh_tokens::table)
-                "UPDATE refresh_tokens SET token = $1, created_at = $2 WHERE token = $3",
+                .filter(rdsl::token.eq(&refresh_token))
-            )
+                .set((
-            .bind(&new_refresh_token)
+                    rdsl::token.eq(&new_refresh_token),
-            .bind(current_time)
+                    rdsl::created_at.eq(current_time),
-            .bind(&refresh_token)
+                ))
-            .execute(&data.pool)
+                .execute(&mut conn)
                 .await
             {
                 Ok(_) => {
@@ -84,27 +84,16 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
             }
         }
 
-        let access_token = generate_access_token();
+        let access_token = generate_access_token()?;
 
-        if access_token.is_err() {
+        update(access_tokens::table)
-            error!("{}", access_token.unwrap_err());
+            .filter(dsl::refresh_token.eq(&refresh_token))
-            return Ok(HttpResponse::InternalServerError().finish());
+            .set((
-        }
+                dsl::token.eq(&access_token),
-
+                dsl::created_at.eq(current_time),
-        let access_token = access_token.unwrap();
+            ))
-
+            .execute(&mut conn)
-        if let Err(error) = sqlx::query(
+            .await?;
-            "UPDATE access_tokens SET token = $1, created_at = $2 WHERE refresh_token = $3",
-        )
-        .bind(&access_token)
-        .bind(current_time)
-        .bind(&refresh_token)
-        .execute(&data.pool)
-        .await
-        {
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
 
         return Ok(HttpResponse::Ok()
             .cookie(refresh_token_cookie(refresh_token))

src/api/v1/auth/register.rs

@@ -1,19 +1,18 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use actix_web::{Error, HttpResponse, post, web};
+use actix_web::{HttpResponse, post, web};
 use argon2::{
     PasswordHasher,
     password_hash::{SaltString, rand_core::OsRng},
 };
-use log::error;
+use diesel::{dsl::insert_into, ExpressionMethods};
+use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use super::Response;
 use crate::{
-    Data,
+    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, error::Error, schema::{access_tokens::{self, dsl as adsl}, refresh_tokens::{self, dsl as rdsl}, users::{self, dsl as udsl}}, 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)]
@@ -92,91 +91,49 @@ pub async fn res(
         .argon2
         .hash_password(account_information.password.as_bytes(), &salt)
     {
+        let mut conn = data.pool.get().await?;
+
         // TODO: Check security of this implementation
-        return Ok(
+        insert_into(users::table)
-            match sqlx::query(&format!(
+            .values((
-                "INSERT INTO users (uuid, username, password, email) VALUES ( '{}', $1, $2, $3 )",
+                udsl::uuid.eq(uuid),
-                uuid
+                udsl::username.eq(&account_information.identifier),
+                udsl::password.eq(hashed_password.to_string()),
+                udsl::email.eq(&account_information.email),
             ))
-            .bind(&account_information.identifier)
+            .execute(&mut conn)
-            .bind(hashed_password.to_string())
+            .await?;
-            .bind(&account_information.email)
-            .execute(&data.pool)
-            .await
-            {
-                Ok(_out) => {
-                    let refresh_token = generate_refresh_token();
-                    let access_token = generate_access_token();
 
-                    if refresh_token.is_err() {
+        let refresh_token = generate_refresh_token()?;
-                        error!("{}", refresh_token.unwrap_err());
+        let access_token = generate_access_token()?;
-                        return Ok(HttpResponse::InternalServerError().finish());
-                    }
-
-                    let refresh_token = refresh_token.unwrap();
-
-                    if access_token.is_err() {
-                        error!("{}", access_token.unwrap_err());
-                        return Ok(HttpResponse::InternalServerError().finish());
-                    }
-
-                    let access_token = access_token.unwrap();
 
         let current_time = SystemTime::now()
-                        .duration_since(UNIX_EPOCH)
+            .duration_since(UNIX_EPOCH)?
-                        .unwrap()
             .as_secs() as i64;
 
-                    if let Err(error) = sqlx::query(&format!("INSERT INTO refresh_tokens (token, uuid, created_at, device_name) VALUES ($1, '{}', $2, $3 )", uuid))
+        insert_into(refresh_tokens::table)
-                        .bind(&refresh_token)
+            .values((
-                        .bind(current_time)
+                rdsl::token.eq(&refresh_token),
-                        .bind(&account_information.device_name)
+                rdsl::uuid.eq(uuid),
-                        .execute(&data.pool)
+                rdsl::created_at.eq(current_time),
-                        .await {
+                rdsl::device_name.eq(&account_information.device_name),
-                        error!("{}", error);
+            ))
-                        return Ok(HttpResponse::InternalServerError().finish())
+            .execute(&mut conn)
-                    }
+            .await?;
 
-                    if let Err(error) = sqlx::query(&format!("INSERT INTO access_tokens (token, refresh_token, uuid, created_at) VALUES ($1, $2, '{}', $3 )", uuid))
+        insert_into(access_tokens::table)
-                        .bind(&access_token)
+            .values((
-                        .bind(&refresh_token)
+                adsl::token.eq(&access_token),
-                        .bind(current_time)
+                adsl::refresh_token.eq(&refresh_token),
-                        .execute(&data.pool)
+                adsl::uuid.eq(uuid),
-                        .await {
+                adsl::created_at.eq(current_time),
-                        error!("{}", error);
+            ))
-                        return Ok(HttpResponse::InternalServerError().finish())
+            .execute(&mut conn)
-                    }
+            .await?;
 
-                    HttpResponse::Ok()
+        return Ok(HttpResponse::Ok()
             .cookie(refresh_token_cookie(refresh_token))
-                        .json(Response { access_token })
+            .json(Response { access_token }))
-                }
-                Err(error) => {
-                    let err_msg = error.as_database_error().unwrap().message();
-
-                    match err_msg {
-                        err_msg
-                            if err_msg.contains("unique") && err_msg.contains("username_key") =>
-                        {
-                            HttpResponse::Forbidden().json(ResponseError {
-                                gorb_id_available: false,
-                                ..Default::default()
-                            })
-                        }
-                        err_msg if err_msg.contains("unique") && err_msg.contains("email_key") => {
-                            HttpResponse::Forbidden().json(ResponseError {
-                                email_available: false,
-                                ..Default::default()
-                            })
-                        }
-                        _ => {
-                            error!("{}", err_msg);
-                            HttpResponse::InternalServerError().finish()
-                        }
-                    }
-                }
-            },
-        );
     }
 
     Ok(HttpResponse::InternalServerError().finish())

src/api/v1/auth/revoke.rs

@@ -1,10 +1,10 @@
-use actix_web::{Error, HttpRequest, HttpResponse, post, web};
+use actix_web::{HttpRequest, HttpResponse, post, web};
 use argon2::{PasswordHash, PasswordVerifier};
-use futures::future;
+use diesel::{delete, ExpressionMethods, QueryDsl};
-use log::error;
+use diesel_async::RunQueryDsl;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
-use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
+use crate::{api::v1::auth::check_access_token, error::Error, schema::users::dsl as udsl, schema::refresh_tokens::{self, dsl as rdsl}, utils::get_auth_header, Data};
 
 #[derive(Deserialize)]
 struct RevokeRequest {
@@ -12,17 +12,6 @@ struct RevokeRequest {
     device_name: String,
 }
 
-#[derive(Serialize)]
-struct Response {
-    deleted: bool,
-}
-
-impl Response {
-    fn new(deleted: bool) -> Self {
-        Self { deleted }
-    }
-}
-
 // TODO: Should maybe be a delete request?
 #[post("/revoke")]
 pub async fn res(
@@ -32,85 +21,33 @@ pub async fn res(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    if let Err(error) = authorized {
+    let database_password: String = udsl::users
-        return Ok(error);
+        .filter(udsl::uuid.eq(uuid))
-    }
+        .select(udsl::password)
+        .get_result(&mut conn)
+        .await?;
 
-    let uuid = authorized.unwrap();
+    let hashed_password = PasswordHash::new(&database_password).map_err(|e| Error::PasswordHashError(e.to_string()))?;
-
-    let database_password_raw = sqlx::query_scalar(&format!(
-        "SELECT password FROM users WHERE uuid = '{}'",
-        uuid
-    ))
-    .fetch_one(&data.pool)
-    .await;
-
-    if let Err(error) = database_password_raw {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
-    }
-
-    let database_password: String = database_password_raw.unwrap();
-
-    let hashed_password_raw = PasswordHash::new(&database_password);
-
-    if let Err(error) = hashed_password_raw {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
-    }
-
-    let hashed_password = hashed_password_raw.unwrap();
 
     if data
         .argon2
         .verify_password(revoke_request.password.as_bytes(), &hashed_password)
         .is_err()
     {
-        return Ok(HttpResponse::Unauthorized().finish());
+        return Err(Error::Unauthorized("Wrong username or password".to_string()));
     }
 
-    let tokens_raw = sqlx::query_scalar(&format!(
+    delete(refresh_tokens::table)
-        "SELECT token FROM refresh_tokens WHERE uuid = '{}' AND device_name = $1",
+        .filter(rdsl::uuid.eq(uuid))
-        uuid
+        .filter(rdsl::device_name.eq(&revoke_request.device_name))
-    ))
+        .execute(&mut conn)
-    .bind(&revoke_request.device_name)
+        .await?;
-    .fetch_all(&data.pool)
-    .await;
 
-    if tokens_raw.is_err() {
+    Ok(HttpResponse::Ok().finish())
-        error!("{:?}", tokens_raw);
-        return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
-    }
-
-    let tokens: Vec<String> = tokens_raw.unwrap();
-
-    let mut refresh_tokens_delete = vec![];
-
-    for token in tokens {
-        refresh_tokens_delete.push(
-            sqlx::query("DELETE FROM refresh_tokens WHERE token = $1")
-                .bind(token.clone())
-                .execute(&data.pool),
-        );
-    }
-
-    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();
-
-    if !errors.is_empty() {
-        error!("{:?}", errors);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    Ok(HttpResponse::Ok().json(Response::new(true)))
 }

src/api/v1/invites/id.rs

@@ -1,6 +1,7 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Guild, Invite, Member},
@@ -15,29 +16,17 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
+
-    }
+    check_access_token(auth_header, &mut conn).await?;
 
     let invite_id = path.into_inner().0;
 
-    let result = Invite::fetch_one(&data.pool, invite_id).await;
+    let invite = Invite::fetch_one(&mut conn, invite_id).await?;
 
-    if let Err(error) = result {
+    let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;
-        return Ok(error);
-    }
-
-    let invite = result.unwrap();
-
-    let guild_result = Guild::fetch_one(&data.pool, invite.guild_uuid).await;
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
 
     Ok(HttpResponse::Ok().json(guild))
 }
@@ -50,43 +39,19 @@ pub async fn join(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let invite_id = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    let invite = Invite::fetch_one(&mut conn, invite_id).await?;
 
-    let result = Invite::fetch_one(&data.pool, invite_id).await;
+    let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;
 
-    if let Err(error) = result {
+    Member::new(&mut conn, uuid, guild.uuid).await?;
-        return Ok(error);
-    }
-
-    let invite = result.unwrap();
-
-    let guild_result = Guild::fetch_one(&data.pool, invite.guild_uuid).await;
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
-
-    let member = Member::new(&data.pool, uuid, guild.uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
 
     Ok(HttpResponse::Ok().json(guild))
 }

src/api/v1/servers/mod.rs

@@ -1,9 +1,9 @@
-use actix_web::{get, post, web, Error, HttpRequest, HttpResponse, Scope};
+use actix_web::{get, post, web, 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::{error::Error, api::v1::auth::check_access_token, structs::{Guild, StartAmountQuery}, utils::get_auth_header, Data};
 
 #[derive(Deserialize)]
 struct GuildInfo {
@@ -26,33 +26,21 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    let uuid = authorized.unwrap();
 
     let guild = Guild::new(
-        &data.pool,
+        &mut conn,
         guild_info.name.clone(),
         guild_info.description.clone(),
         uuid,
     )
-    .await;
+    .await?;
 
-    if let Err(error) = guild {
+    Ok(HttpResponse::Ok().json(guild))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guild.unwrap()))
 }
 
 #[get("")]
@@ -63,28 +51,16 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(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 {
+    check_access_token(auth_header, &mut data.pool.get().await.unwrap()).await?;
-        return Ok(error);
+
-    }
+    let guilds = Guild::fetch_amount(&data.pool, start, amount).await?;
-
+
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    Ok(HttpResponse::Ok().json(guilds))
-
-    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,12 +1,12 @@
 use crate::{
+    error::Error,
     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 actix_web::{HttpRequest, HttpResponse, get, post, web};
-use log::error;
 use serde::Deserialize;
 
 pub mod uuid;
@@ -25,52 +25,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}_channels", guild_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let channels_result = Channel::fetch_all(&data.pool, guild_uuid).await;
+    let channels = Channel::fetch_all(&data.pool, guild_uuid).await?;
 
-    if let Err(error) = channels_result {
+    data
-        return Ok(error);
-    }
-
-    let channels = channels_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(channels))
 }
@@ -84,27 +59,15 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
@@ -116,9 +79,5 @@ pub async fn create(
     )
     .await;
 
-    if let Err(error) = channel {
-        return Ok(error);
-    }
-
     Ok(HttpResponse::Ok().json(channel.unwrap()))
 }

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

@@ -1,12 +1,12 @@
 use crate::{
+    error::Error,
     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 actix_web::{HttpRequest, HttpResponse, get, web};
-use log::error;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -24,60 +24,31 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
-        channel = serde_json::from_str(&cache_hit).unwrap()
+        channel = serde_json::from_str(&cache_hit)?
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-        if let Err(error) = channel_result {
+        data
-            return Ok(error);
-        }
-
-        channel = channel_result.unwrap();
-
-        let cache_result = data
             .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-            .await;
+            .await?;
-
-        if let Err(error) = cache_result {
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
     }
 
     let messages = channel
-        .fetch_messages(&data.pool, message_request.amount, message_request.offset)
+        .fetch_messages(&mut conn, message_request.amount, message_request.offset)
-        .await;
+        .await?;
 
-    if let Err(error) = messages {
+    Ok(HttpResponse::Ok().json(messages))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(messages.unwrap()))
 }

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

@@ -2,14 +2,14 @@ pub mod messages;
 pub mod socket;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Channel, Member},
     utils::get_auth_header,
 };
-use ::uuid::Uuid;
+use uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, delete, get, web};
+use actix_web::{HttpRequest, HttpResponse, delete, get, web};
-use log::error;
 
 #[get("{uuid}/channels/{channel_uuid}")]
 pub async fn get(
@@ -19,52 +19,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+    let channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-    if let Err(error) = channel_result {
+    data
-        return Ok(error);
-    }
-
-    let channel = channel_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(channel))
 }
@@ -77,55 +52,27 @@ pub async fn delete(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
         channel = serde_json::from_str(&cache_hit).unwrap();
 
-        let result = data.del_cache_key(format!("{}", channel_uuid)).await;
+        data.del_cache_key(format!("{}", channel_uuid)).await?;
-
-        if let Err(error) = result {
-            error!("{}", error)
-        }
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
-
-        if let Err(error) = channel_result {
-            return Ok(error);
     }
 
-        channel = channel_result.unwrap();
+    channel.delete(&mut conn).await?;
-    }
-
-    let delete_result = channel.delete(&data.pool).await;
-
-    if let Err(error) = delete_result {
-        return Ok(error);
-    }
 
     Ok(HttpResponse::Ok().finish())
 }

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

@@ -1,7 +1,6 @@
 use actix_web::{Error, HttpRequest, HttpResponse, get, rt, web};
 use actix_ws::AggregatedMessage;
 use futures_util::StreamExt as _;
-use log::error;
 use uuid::Uuid;
 
 use crate::{
@@ -22,57 +21,30 @@ pub async fn echo(
     let headers = req.headers();
 
     // Retrieve auth header
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     // Get uuids from path
     let (guild_uuid, channel_uuid) = path.into_inner();
 
+    let mut conn = data.pool.get().await.map_err(|e| crate::error::Error::from(e))?;
+
     // Authorize client using auth header
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    // Unwrap user uuid from authorization
-    let uuid = authorized.unwrap();
 
     // Get server member from psql
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    // Get cache for channel
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
     // Return channel cache or result from psql as `channel` variable
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
         channel = serde_json::from_str(&cache_hit).unwrap()
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-        if let Err(error) = channel_result {
+        data
-            return Ok(error);
-        }
-
-        channel = channel_result.unwrap();
-
-        let cache_result = data
             .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-            .await;
+            .await?;
-
-        if let Err(error) = cache_result {
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
     }
 
     let (res, mut session_1, stream) = actix_ws::handle(&req, stream)?;
@@ -82,17 +54,11 @@ pub async fn echo(
         // aggregate continuation frames up to 1MiB
         .max_continuation_size(2_usize.pow(20));
 
-    let pubsub_result = data.cache_pool.get_async_pubsub().await;
+    let mut pubsub = data.cache_pool.get_async_pubsub().await.map_err(|e| crate::error::Error::from(e))?;
-
-    if let Err(error) = pubsub_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     let mut session_2 = session_1.clone();
 
     rt::spawn(async move {
-        let mut pubsub = pubsub_result.unwrap();
         pubsub.subscribe(channel_uuid.to_string()).await.unwrap();
         while let Some(msg) = pubsub.on_message().next().await {
             let payload: String = msg.get_payload().unwrap();
@@ -118,7 +84,7 @@ pub async fn echo(
                         .await
                         .unwrap();
                     channel
-                        .new_message(&data.pool, uuid, text.to_string())
+                        .new_message(&mut data.pool.get().await.unwrap(), uuid, text.to_string())
                         .await
                         .unwrap();
                 }

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

@@ -1,8 +1,9 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 use uuid::Uuid;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Guild, Member},
@@ -22,43 +23,21 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
-    if let Err(error) = member {
+    let invites = guild.get_invites(&mut conn).await?;
-        return Ok(error);
-    }
 
-    let guild_result = Guild::fetch_one(&data.pool, guild_uuid).await;
+    Ok(HttpResponse::Ok().json(invites))
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
-
-    let invites = guild.get_invites(&data.pool).await;
-
-    if let Err(error) = invites {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(invites.unwrap()))
 }
 
 #[post("{uuid}/invites")]
@@ -70,45 +49,21 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    let member = Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member_result = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
-
-    if let Err(error) = member_result {
-        return Ok(error);
-    }
-
-    let member = member_result.unwrap();
-
-    let guild_result = Guild::fetch_one(&data.pool, guild_uuid).await;
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
 
     let custom_id = invite_request.as_ref().map(|ir| ir.custom_id.clone());
 
-    let invite = guild.create_invite(&data.pool, &member, custom_id).await;
+    let invite = guild.create_invite(&mut conn, &member, custom_id).await?;
 
-    if let Err(error) = invite {
+    Ok(HttpResponse::Ok().json(invite))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(invite.unwrap()))
 }

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

@@ -1,4 +1,4 @@
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
 use uuid::Uuid;
 
 mod channels;
@@ -6,6 +6,7 @@ mod invites;
 mod roles;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Guild, Member},
@@ -40,33 +41,17 @@ pub async fn res(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
+
-    }
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
+
-    let uuid = authorized.unwrap();
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
-
+
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    Ok(HttpResponse::Ok().json(guild))
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let guild = Guild::fetch_one(&data.pool, guild_uuid).await;
-
-    if let Err(error) = guild {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guild.unwrap()))
 }

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

@@ -1,13 +1,14 @@
+use ::uuid::Uuid;
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
+use serde::Deserialize;
+
 use crate::{
+    error::Error,
     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;
 
 pub mod uuid;
 
@@ -24,52 +25,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}_roles", guild_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}_roles", guild_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let roles_result = Role::fetch_all(&data.pool, guild_uuid).await;
+    let roles = Role::fetch_all(&mut conn, guild_uuid).await?;
 
-    if let Err(error) = roles_result {
+    data
-        return Ok(error);
-    }
-
-    let roles = roles_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(roles))
 }
@@ -83,35 +59,19 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await.unwrap();
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
-    let role = Role::new(&data.pool, guild_uuid, role_info.name.clone()).await;
+    let role = Role::new(&mut conn, guild_uuid, role_info.name.clone()).await?;
 
-    if let Err(error) = role {
+    Ok(HttpResponse::Ok().json(role))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(role.unwrap()))
 }

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

@@ -1,12 +1,12 @@
 use crate::{
+    error::Error,
     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 actix_web::{HttpRequest, HttpResponse, get, web};
-use log::error;
 
 #[get("{uuid}/roles/{role_uuid}")]
 pub async fn get(
@@ -16,52 +16,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, role_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", role_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let role_result = Role::fetch_one(&data.pool, guild_uuid, role_uuid).await;
+    let role = Role::fetch_one(&mut conn, role_uuid).await?;
 
-    if let Err(error) = role_result {
+    data
-        return Ok(error);
-    }
-
-    let role = role_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}", role_uuid), role.clone(), 60)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(role))
 }

src/api/v1/stats.rs

@@ -1,31 +1,31 @@
 use std::time::SystemTime;
 
-use actix_web::{HttpResponse, Responder, get, web};
+use actix_web::{HttpResponse, get, web};
+use diesel::QueryDsl;
+use diesel_async::RunQueryDsl;
 use serde::Serialize;
 
+use crate::error::Error;
 use crate::Data;
+use crate::schema::users::dsl::{users, uuid};
 
 const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
 
 #[derive(Serialize)]
 struct Response {
-    accounts: usize,
+    accounts: i64,
     uptime: u64,
     version: String,
     build_number: String,
 }
 
 #[get("/stats")]
-pub async fn res(data: web::Data<Data>) -> impl Responder {
+pub async fn res(data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let accounts;
+    let accounts: i64 = users
-    if let Ok(users) = sqlx::query("SELECT uuid FROM users")
+        .select(uuid)
-        .fetch_all(&data.pool)
+        .count()
-        .await
+        .get_result(&mut data.pool.get().await?)
-    {
+        .await?;
-        accounts = users.len();
-    } else {
-        return HttpResponse::InternalServerError().finish();
-    }
 
     let response = Response {
         // TODO: Get number of accounts from db
@@ -39,5 +39,5 @@ pub async fn res(data: web::Data<Data>) -> impl Responder {
         build_number: String::from("how do i implement this?"),
     };
 
-    HttpResponse::Ok().json(response)
+    Ok(HttpResponse::Ok().json(response))
 }

src/api/v1/users/me.rs

@@ -1,51 +1,41 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use diesel::{prelude::Queryable, ExpressionMethods, QueryDsl, Selectable, SelectableHelper};
+use diesel_async::RunQueryDsl;
 use log::error;
 use serde::Serialize;
+use uuid::Uuid;
 
-use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
+use crate::{error::Error, api::v1::auth::check_access_token, schema::users::{self, dsl}, utils::get_auth_header, Data};
 
-#[derive(Serialize)]
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
-    display_name: String,
+    display_name: Option<String>,
 }
 
 #[get("/me")]
 pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    if let Err(error) = authorized {
+    let user: Result<Response, diesel::result::Error> = dsl::users
-        return Ok(error);
+        .filter(dsl::uuid.eq(uuid))
-    }
+        .select(Response::as_select())
-
+        .get_result(&mut conn)
-    let uuid = authorized.unwrap();
-
-    let row = sqlx::query_as(&format!(
-        "SELECT username, display_name FROM users WHERE uuid = '{}'",
-        uuid
-    ))
-    .fetch_one(&data.pool)
         .await;
 
-    if let Err(error) = row {
+    if let Err(error) = user {
         error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
+        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let (username, display_name): (String, Option<String>) = row.unwrap();
+    Ok(HttpResponse::Ok().json(user.unwrap()))
-
-    Ok(HttpResponse::Ok().json(Response {
-        uuid: uuid.to_string(),
-        username,
-        display_name: display_name.unwrap_or_default(),
-    }))
 }

src/api/v1/users/mod.rs

@@ -1,15 +1,19 @@
-use crate::{api::v1::auth::check_access_token, structs::StartAmountQuery, utils::get_auth_header, Data};
+use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use diesel::{prelude::Queryable, QueryDsl, Selectable, SelectableHelper};
-use log::error;
+use diesel_async::RunQueryDsl;
 use serde::Serialize;
-use sqlx::prelude::FromRow;
+use ::uuid::Uuid;
+
+use crate::{error::Error,api::v1::auth::check_access_token, schema::users::{self, dsl}, structs::StartAmountQuery, utils::get_auth_header, Data};
 
 mod me;
 mod uuid;
 
-#[derive(Serialize, FromRow)]
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
     display_name: Option<String>,
     email: String,
@@ -30,7 +34,7 @@ pub async fn res(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
     let start = request_query.start.unwrap_or(0);
 
@@ -40,24 +44,17 @@ pub async fn res(
         return Ok(HttpResponse::BadRequest().finish());
     }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
+
-    }
+    let users: Vec<Response> = dsl::users
-
+        .order_by(dsl::username)
-    let row = sqlx::query_as("SELECT CAST(uuid AS VARCHAR), username, display_name, email FROM users ORDER BY username LIMIT $1 OFFSET $2")
+        .offset(start)
-        .bind(amount)
+        .limit(amount)
-        .bind(start)
+        .select(Response::as_select())
-        .fetch_all(&data.pool)
+        .load(&mut conn)
-        .await;
+        .await?;
-
+
-    if let Err(error) = row {
+    Ok(HttpResponse::Ok().json(users))
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    let accounts: Vec<Response> = row.unwrap();
-
-    Ok(HttpResponse::Ok().json(accounts))
 }

src/api/v1/users/uuid.rs

@@ -1,15 +1,19 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
+use diesel_async::RunQueryDsl;
 use log::error;
 use serde::Serialize;
 use uuid::Uuid;
 
-use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
+use crate::{error::Error, api::v1::auth::check_access_token, schema::users::{self, dsl}, utils::get_auth_header, Data};
 
-#[derive(Serialize, Clone)]
+#[derive(Serialize, Queryable, Selectable, Clone)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
-    display_name: String,
+    display_name: Option<String>,
 }
 
 #[get("/{uuid}")]
@@ -22,17 +26,11 @@ pub async fn res(
 
     let uuid = path.into_inner().0;
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
 
     let cache_result = data.get_cache_key(uuid.to_string()).await;
 
@@ -42,25 +40,11 @@ pub async fn res(
             .body(cache_hit));
     }
 
-    let row = sqlx::query_as(&format!(
+    let user: Response = dsl::users
-        "SELECT username, display_name FROM users WHERE uuid = '{}'",
+        .filter(dsl::uuid.eq(uuid))
-        uuid
+        .select(Response::as_select())
-    ))
+        .get_result(&mut conn)
-    .fetch_one(&data.pool)
+        .await?;
-    .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    let (username, display_name): (String, Option<String>) = row.unwrap();
-
-    let user = Response {
-        uuid: uuid.to_string(),
-        username,
-        display_name: display_name.unwrap_or_default(),
-    };
 
     let cache_result = data
         .set_cache_key(uuid.to_string(), user.clone(), 1800)

src/config.rs

@@ -1,4 +1,4 @@
-use crate::Error;
+use crate::error::Error;
 use log::debug;
 use serde::Deserialize;
 use tokio::fs::read_to_string;

src/error.rs

@@ -0,0 +1,79 @@
+use std::{io, time::SystemTimeError};
+
+use actix_web::{error::ResponseError, http::{header::{ContentType, ToStrError}, StatusCode}, HttpResponse};
+use deadpool::managed::{BuildError, PoolError};
+use redis::RedisError;
+use serde::Serialize;
+use thiserror::Error;
+use diesel::{result::Error as DieselError, ConnectionError};
+use diesel_async::pooled_connection::PoolError as DieselPoolError;
+use tokio::task::JoinError;
+use serde_json::Error as JsonError;
+use toml::de::Error as TomlError;
+use log::error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error(transparent)]
+    SqlError(#[from] DieselError),
+    #[error(transparent)]
+    PoolError(#[from] PoolError<DieselPoolError>),
+    #[error(transparent)]
+    BuildError(#[from] BuildError),
+    #[error(transparent)]
+    RedisError(#[from] RedisError),
+    #[error(transparent)]
+    ConnectionError(#[from] ConnectionError),
+    #[error(transparent)]
+    JoinError(#[from] JoinError),
+    #[error(transparent)]
+    IoError(#[from] io::Error),
+    #[error(transparent)]
+    TomlError(#[from] TomlError),
+    #[error(transparent)]
+    JsonError(#[from] JsonError),
+    #[error(transparent)]
+    SystemTimeError(#[from] SystemTimeError),
+    #[error(transparent)]
+    ToStrError(#[from] ToStrError),
+    #[error(transparent)]
+    RandomError(#[from] getrandom::Error),
+    #[error("{0}")]
+    PasswordHashError(String),
+    #[error("{0}")]
+    BadRequest(String),
+    #[error("{0}")]
+    Unauthorized(String),
+}
+
+impl ResponseError for Error {
+    fn error_response(&self) -> HttpResponse {
+        error!("{}: {}", self.status_code(), self.to_string());
+
+        HttpResponse::build(self.status_code())
+            .insert_header(ContentType::json())
+            .json(WebError::new(self.to_string()))
+    }
+
+    fn status_code(&self) -> StatusCode {
+        match *self {
+            Error::SqlError(DieselError::NotFound) => StatusCode::NOT_FOUND,
+            Error::BadRequest(_) => StatusCode::BAD_REQUEST,
+            Error::Unauthorized(_) => StatusCode::UNAUTHORIZED,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct WebError {
+    message: String,
+}
+
+impl WebError {
+    fn new(message: String) -> Self {
+        Self {
+            message,
+        }
+    }
+}

src/main.rs

@@ -2,22 +2,24 @@ use actix_cors::Cors;
 use actix_web::{App, HttpServer, web};
 use argon2::Argon2;
 use clap::Parser;
+use error::Error;
 use simple_logger::SimpleLogger;
 use diesel_async::pooled_connection::AsyncDieselConnectionManager;
 use diesel_async::pooled_connection::deadpool::Pool;
-use diesel_async::RunQueryDsl;
 use std::time::SystemTime;
 mod config;
 use config::{Config, ConfigBuilder};
-mod api;
+use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness};
+
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!();
 
 type Conn = deadpool::managed::Object<AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>>;
 
+mod api;
 pub mod structs;
 pub mod utils;
 pub mod schema;
-
+pub mod error;
-type Error = Box<dyn std::error::Error>;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -55,8 +57,18 @@ async fn main() -> Result<(), Error> {
 
     let cache_pool = redis::Client::open(config.cache_database.url())?;
 
-    let mut conn = pool.get().await?;
+    let database_url = config.database.url();
 
+    tokio::task::spawn_blocking(move || {
+    use diesel::prelude::Connection;
+    use diesel_async::async_connection_wrapper::AsyncConnectionWrapper;
+
+
+        let mut conn = AsyncConnectionWrapper::<diesel_async::AsyncPgConnection>::establish(&database_url)?;
+
+        conn.run_pending_migrations(MIGRATIONS)?;
+        Ok::<_, Box<dyn std::error::Error + Send + Sync>>(())
+    }).await?.unwrap();
 
     /*
     **Stored for later possible use**

src/schema.rs

@@ -26,7 +26,7 @@ diesel::table! {
         #[max_length = 32]
         name -> Varchar,
         #[max_length = 500]
-        description -> Varchar,
+        description -> Nullable<Varchar>,
     }
 }
 

src/structs.rs

@@ -1,15 +1,50 @@
-use std::str::FromStr;
+use diesel::{delete, insert_into, prelude::{Insertable, Queryable}, ExpressionMethods, QueryDsl, Selectable, SelectableHelper};
-
-use actix_web::HttpResponse;
-use diesel::Selectable;
-use log::error;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
+use diesel_async::{pooled_connection::AsyncDieselConnectionManager, RunQueryDsl};
 
-use crate::{Conn, Data, schema::*};
+use crate::{error::Error, Conn, Data, schema::*};
 
-#[derive(Serialize, Deserialize, Clone, Selectable)]
+fn load_or_empty<T>(query_result: Result<Vec<T>, diesel::result::Error>) -> Result<Vec<T>, diesel::result::Error> {
+    match query_result {
+        Ok(vec) => Ok(vec),
+        Err(diesel::result::Error::NotFound) => Ok(Vec::new()),
+        Err(e) => Err(e),
+    }
+}
+
+#[derive(Queryable, Selectable, Insertable, Clone)]
 #[diesel(table_name = channels)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+struct ChannelBuilder {
+    uuid: Uuid,
+    guild_uuid: Uuid,
+    name: String,
+    description: Option<String>,
+}
+
+impl ChannelBuilder {
+    async fn build(self, conn: &mut Conn) -> Result<Channel, Error> {
+        use self::channel_permissions::dsl::*;
+        let channel_permission: Vec<ChannelPermission> = load_or_empty(
+            channel_permissions
+                .filter(channel_uuid.eq(self.uuid))
+                .select(ChannelPermission::as_select())
+                .load(conn)
+                .await
+        )?;
+
+        Ok(Channel {
+            uuid: self.uuid,
+            guild_uuid: self.guild_uuid,
+            name: self.name,
+            description: self.description,
+            permissions: channel_permission,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Channel {
     pub uuid: Uuid,
     pub guild_uuid: Uuid,
@@ -18,116 +53,50 @@ pub struct Channel {
     pub permissions: Vec<ChannelPermission>,
 }
 
-#[derive(Serialize, Clone)]
+#[derive(Serialize, Deserialize, Clone, Queryable, Selectable)]
-struct ChannelPermissionBuilder {
-    role_uuid: String,
-    permissions: i32,
-}
-
-impl ChannelPermissionBuilder {
-    fn build(&self) -> ChannelPermission {
-        ChannelPermission {
-            role_uuid: Uuid::from_str(&self.role_uuid).unwrap(),
-            permissions: self.permissions,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Selectable)]
 #[diesel(table_name = channel_permissions)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct ChannelPermission {
     pub role_uuid: Uuid,
-    pub permissions: i32,
+    pub permissions: i64,
 }
 
 impl Channel {
     pub async fn fetch_all(
-        conn: &mut Conn,
+        pool: &deadpool::managed::Pool<AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>, Conn>,
         guild_uuid: Uuid,
-    ) -> Result<Vec<Self>, HttpResponse> {
+    ) -> Result<Vec<Self>, Error> {
+        let mut conn = pool.get().await?;
 
+        use channels::dsl;
+        let channel_builders: Vec<ChannelBuilder> = load_or_empty(
+            dsl::channels
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .select(ChannelBuilder::as_select())
+                .load(&mut conn)
+                .await
+        )?;
 
-        if let Err(error) = row {
+        let channel_futures = channel_builders.iter().map(async move |c| {
-            error!("{}", error);
+            let mut conn = pool.get().await?;
-
+            c.clone().build(&mut conn).await
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let channels: Vec<(String, String, Option<String>)> = row.unwrap();
-
-        let futures = channels.iter().map(async |t| {
-            let (uuid, name, description) = t.to_owned();
-
-            let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", uuid))
-                .fetch_all(pool)
-                .await;
-
-            if let Err(error) = row {
-                error!("{}", error);
-
-                return Err(HttpResponse::InternalServerError().finish())
-            }
-
-            let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
-
-            Ok(Self {
-                uuid: Uuid::from_str(&uuid).unwrap(),
-                guild_uuid,
-                name,
-                description,
-                permissions: channel_permission_builders.iter().map(|b| b.build()).collect(),
-            })
         });
         
-        let channels = futures::future::join_all(futures).await;
+        futures::future::try_join_all(channel_futures).await
-
-        let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
-
-        channels
     }
 
     pub async fn fetch_one(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
-        guild_uuid: Uuid,
         channel_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
-        let row = sqlx::query_as(&format!(
+        use channels::dsl;
-            "SELECT name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'",
+        let channel_builder: ChannelBuilder = dsl::channels
-            guild_uuid, channel_uuid
+            .filter(dsl::uuid.eq(channel_uuid))
-        ))
+            .select(ChannelBuilder::as_select())
-        .fetch_one(pool)
+            .get_result(conn)
-        .await;
+            .await?;
 
-        if let Err(error) = row {
+        channel_builder.build(conn).await
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let (name, description): (String, Option<String>) = row.unwrap();
-
-        let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", channel_uuid))
-            .fetch_all(pool)
-            .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
-
-        Ok(Self {
-            uuid: channel_uuid,
-            guild_uuid,
-            name,
-            description,
-            permissions: channel_permission_builders
-                .iter()
-                .map(|b| b.build())
-                .collect(),
-        })
     }
 
     pub async fn new(
@@ -135,20 +104,24 @@ impl Channel {
         guild_uuid: Uuid,
         name: String,
         description: Option<String>,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
+        let mut conn = data.pool.get().await?;
+
         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))
+        let new_channel = ChannelBuilder {
-            .bind(&name)
+            uuid: channel_uuid,
-            .bind(&description)
+            guild_uuid: guild_uuid,
-            .execute(&data.pool)
+            name: name.clone(),
-            .await;
+            description: description.clone(),
+        };
 
-        if let Err(error) = row {
+        insert_into(channels::table)
-            error!("{}", error);
+            .values(new_channel)
-            return Err(HttpResponse::InternalServerError().finish());
+            .execute(&mut conn)
-        }
+            .await?;
 
+        // returns different object because there's no reason to build the channelbuilder (wastes 1 database request)
         let channel = Self {
             uuid: channel_uuid,
             guild_uuid,
@@ -157,88 +130,66 @@ impl Channel {
             permissions: vec![],
         };
 
-        let cache_result = data
+        data
             .set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
-            .await;
+            .await?;
 
-        if let Err(error) = cache_result {
+        data.del_cache_key(format!("{}_channels", guild_uuid)).await?;
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let cache_deletion_result = data.del_cache_key(format!("{}_channels", guild_uuid)).await;
-
-        if let Err(error) = cache_deletion_result {
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
 
         Ok(channel)
     }
 
-    pub async fn delete(self, pool: &Pool<Postgres>) -> Result<(), HttpResponse> {
+    pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
-        let result = sqlx::query(&format!(
+        use channels::dsl;
-            "DELETE FROM channels WHERE channel_uuid = '{}'",
+        delete(channels::table)
-            self.uuid
+            .filter(dsl::uuid.eq(self.uuid))
-        ))
+            .execute(conn)
-        .execute(pool)
+            .await?;
-        .await;
-
-        if let Err(error) = result {
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
 
         Ok(())
     }
 
     pub async fn fetch_messages(
         &self,
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         amount: i64,
         offset: i64,
-    ) -> Result<Vec<Message>, HttpResponse> {
+    ) -> Result<Vec<Message>, Error> {
-        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))
+        use messages::dsl;
-            .bind(amount)
+        let messages: Vec<Message> = load_or_empty(
-            .bind(offset)
+            dsl::messages
-            .fetch_all(pool)
+                .filter(dsl::channel_uuid.eq(self.uuid))
-            .await;
+                .select(Message::as_select())
+                .limit(amount)
+                .offset(offset)
+                .load(conn)
+                .await
+        )?;
 
-        if let Err(error) = row {
+        Ok(messages)
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let message_builders: Vec<MessageBuilder> = row.unwrap();
-
-        Ok(message_builders.iter().map(|b| b.build()).collect())
     }
 
     pub async fn new_message(
         &self,
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         user_uuid: Uuid,
         message: String,
-    ) -> Result<Message, HttpResponse> {
+    ) -> Result<Message, Error> {
         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))
+        let message = Message {
-            .bind(&message)
-            .execute(pool)
-            .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        Ok(Message {
             uuid: message_uuid,
             channel_uuid: self.uuid,
             user_uuid,
             message,
-        })
+        };
+
+        insert_into(messages::table)
+            .values(message.clone())
+            .execute(conn)
+            .await?;
+
+        Ok(message)
     }
 }
 
@@ -280,6 +231,34 @@ impl Permissions {
     }
 }
 
+#[derive(Serialize, Queryable, Selectable, Insertable, Clone)]
+#[diesel(table_name = guilds)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+struct GuildBuilder {
+    uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    owner_uuid: Uuid,
+}
+
+impl GuildBuilder {
+    async fn build(self, conn: &mut Conn) -> Result<Guild, Error> {
+        let member_count = Member::count(conn, self.uuid).await?;
+
+        let roles = Role::fetch_all(conn, self.uuid).await?;
+
+        Ok(Guild {
+            uuid: self.uuid,
+            name: self.name,
+            description: self.description,
+            icon: String::from("bogus"),
+            owner_uuid: self.owner_uuid,
+            roles: roles,
+            member_count: member_count,
+        })
+    }
+}
+
 #[derive(Serialize)]
 pub struct Guild {
     pub uuid: Uuid,
@@ -292,85 +271,40 @@ pub struct Guild {
 }
 
 impl Guild {
-    pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
+    pub async fn fetch_one(conn: &mut Conn, guild_uuid: Uuid) -> Result<Self, Error> {
-        let row = sqlx::query_as(&format!(
+        use guilds::dsl;
-            "SELECT CAST(owner_uuid AS VARCHAR), name, description FROM guilds WHERE uuid = '{}'",
+        let guild_builder: GuildBuilder = dsl::guilds
-            guild_uuid
+            .filter(dsl::uuid.eq(guild_uuid))
-        ))
+            .select(GuildBuilder::as_select())
-        .fetch_one(pool)
+            .get_result(conn)
-        .await;
+            .await?;
 
-        if let Err(error) = row {
+        guild_builder.build(conn).await
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let (owner_uuid_raw, name, description): (String, String, Option<String>) = row.unwrap();
-
-        let owner_uuid = Uuid::from_str(&owner_uuid_raw).unwrap();
-
-        let member_count = Member::count(pool, guild_uuid).await?;
-
-        let roles = Role::fetch_all(pool, guild_uuid).await?;
-
-        Ok(Self {
-            uuid: guild_uuid,
-            name,
-            description,
-            // FIXME: This isnt supposed to be bogus
-            icon: String::from("bogus"),
-            owner_uuid,
-            roles,
-            member_count,
-        })
     }
 
     pub async fn fetch_amount(
-        pool: &Pool<Postgres>,
+        pool: &deadpool::managed::Pool<AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>, Conn>,
-        start: i32,
+        offset: i64,
-        amount: i32,
+        amount: i64,
-    ) -> Result<Vec<Self>, HttpResponse> {
+    ) -> Result<Vec<Self>, Error> {
         // Fetch guild data from database
-        let rows = sqlx::query_as::<_, (String, String, String, Option<String>)>(
+        let mut conn = pool.get().await?;
-            "SELECT CAST(uuid AS VARCHAR), CAST(owner_uuid AS VARCHAR), name, description 
+
-            FROM guilds 
+        use guilds::dsl;
-            ORDER BY name 
+        let guild_builders: Vec<GuildBuilder> = load_or_empty(
-            LIMIT $1 OFFSET $2",
+            dsl::guilds
-        )
+                .select(GuildBuilder::as_select())
-        .bind(amount)
+                .order_by(dsl::uuid)
-        .bind(start)
+                .offset(offset)
-        .fetch_all(pool)
+                .limit(amount)
+                .load(&mut conn)
                 .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 {
+        // Process each guild concurrently
-                uuid,
+        let guild_futures = guild_builders.iter().map(async move |g| {
-                name,
+            let mut conn = pool.get().await?;
-                description,
+            g.clone().build(&mut conn).await
-                icon: String::from("bogus"), // FIXME: Replace with actual icon handling
-                owner_uuid,
-                roles,
-                member_count,
-            })
         });
 
         // Execute all futures concurrently and collect results
@@ -378,49 +312,38 @@ impl Guild {
     }
 
     pub async fn new(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         name: String,
         description: Option<String>,
         owner_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
         let guild_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let guild_builder = GuildBuilder {
-            "INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)",
+            uuid: guild_uuid,
-            guild_uuid, owner_uuid
+            name: name.clone(),
-        ))
+            description: description.clone(),
-        .bind(&name)
+            owner_uuid,
-        .bind(&description)
+        };
-        .execute(pool)
-        .await;
 
-        if let Err(error) = row {
+        insert_into(guilds::table)
-            error!("{}", error);
+            .values(guild_builder)
-            return Err(HttpResponse::InternalServerError().finish());
+            .execute(conn)
-        }
+            .await?;
 
-        let row = sqlx::query(&format!(
+        let member_uuid = Uuid::now_v7();
-            "INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')",
+
-            Uuid::now_v7(),
+        let member = Member {
+            uuid: member_uuid,
+            nickname: None,
+            user_uuid: owner_uuid,
             guild_uuid,
-            owner_uuid
+        };
-        ))
-        .execute(pool)
-        .await;
 
-        if let Err(error) = row {
+        insert_into(guild_members::table)
-            error!("{}", error);
+            .values(member)
-
+            .execute(conn)
-            let row = sqlx::query(&format!("DELETE FROM guilds WHERE uuid = '{}'", guild_uuid))
+            .await?;
-                .execute(pool)
-                .await;
-
-            if let Err(error) = row {
-                error!("{}", error);
-            }
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
 
         Ok(Guild {
             uuid: guild_uuid,
@@ -433,168 +356,104 @@ impl Guild {
         })
     }
 
-    pub async fn get_invites(&self, pool: &Pool<Postgres>) -> Result<Vec<Invite>, HttpResponse> {
+    pub async fn get_invites(&self, conn: &mut Conn) -> Result<Vec<Invite>, Error> {
-        let invites = sqlx::query_as(&format!(
+        use invites::dsl;
-            "SELECT (id, guild_uuid, user_uuid) FROM invites WHERE guild_uuid = '{}'",
+        let invites = load_or_empty(
-            self.uuid
+            dsl::invites
-        ))
+                .filter(dsl::guild_uuid.eq(self.uuid))
-        .fetch_all(pool)
+                .select(Invite::as_select())
-        .await;
+                .load(conn)
+                .await
+        )?;
 
-        if let Err(error) = invites {
+        Ok(invites)
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        Ok(invites
-            .unwrap()
-            .iter()
-            .map(|b: &InviteBuilder| b.build())
-            .collect())
     }
 
     pub async fn create_invite(
         &self,
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         member: &Member,
         custom_id: Option<String>,
-    ) -> Result<Invite, HttpResponse> {
+    ) -> Result<Invite, Error> {
         let invite_id;
 
-        if custom_id.is_none() {
+        if let Some(id) = custom_id {
+            invite_id = id;
+            if invite_id.len() > 32 {
+                return Err(Error::BadRequest("MAX LENGTH".to_string()))
+            }
+        } else {
             let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
             invite_id = random_string::generate(8, charset);
-        } else {
-            invite_id = custom_id.unwrap();
-            if invite_id.len() > 32 {
-                return Err(HttpResponse::BadRequest().finish());
-            }
         }
 
-        let result = sqlx::query(&format!(
+        let invite = Invite {
-            "INSERT INTO invites (id, guild_uuid, user_uuid) VALUES ($1, '{}', '{}'",
-            self.uuid, member.user_uuid
-        ))
-        .bind(&invite_id)
-        .execute(pool)
-        .await;
-
-        if let Err(error) = result {
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        Ok(Invite {
             id: invite_id,
             user_uuid: member.user_uuid,
             guild_uuid: self.uuid,
-        })
+        };
+
+        insert_into(invites::table)
+            .values(invite.clone())
+            .execute(conn)
+            .await?;
+
+        Ok(invite)
     }
 }
 
-#[derive(FromRow)]
+#[derive(Serialize, Clone, Queryable, Selectable, Insertable)]
-struct RoleBuilder {
+#[diesel(table_name = roles)]
-    uuid: String,
+#[diesel(check_for_backend(diesel::pg::Pg))]
-    guild_uuid: String,
-    name: String,
-    color: i64,
-    position: i32,
-    permissions: i64,
-}
-
-impl RoleBuilder {
-    fn build(&self) -> Role {
-        Role {
-            uuid: Uuid::from_str(&self.uuid).unwrap(),
-            guild_uuid: Uuid::from_str(&self.guild_uuid).unwrap(),
-            name: self.name.clone(),
-            color: self.color,
-            position: self.position,
-            permissions: self.permissions,
-        }
-    }
-}
-
-#[derive(Serialize, Clone)]
 pub struct Role {
     uuid: Uuid,
     guild_uuid: Uuid,
     name: String,
-    color: i64,
+    color: i32,
     position: i32,
     permissions: i64,
 }
 
 impl Role {
     pub async fn fetch_all(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         guild_uuid: Uuid,
-    ) -> Result<Vec<Self>, HttpResponse> {
+    ) -> Result<Vec<Self>, Error> {
-        let role_builders_result = sqlx::query_as(&format!("SELECT (uuid, guild_uuid, name, color, position, permissions) FROM roles WHERE guild_uuid = '{}'", guild_uuid))
+        use roles::dsl;
-            .fetch_all(pool)
+        let roles: Vec<Role> = load_or_empty(
-            .await;
+            dsl::roles
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .select(Role::as_select())
+                .load(conn)
+                .await
+        )?;
 
-        if let Err(error) = role_builders_result {
+        Ok(roles)
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let role_builders: Vec<RoleBuilder> = role_builders_result.unwrap();
-
-        Ok(role_builders.iter().map(|b| b.build()).collect())
     }
 
     pub async fn fetch_one(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         role_uuid: Uuid,
-        guild_uuid: Uuid,
+    ) -> Result<Self, Error> {
-    ) -> Result<Self, HttpResponse> {
+        use roles::dsl;
-        let row = sqlx::query_as(&format!("SELECT (name, color, position, permissions) FROM roles WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, role_uuid))
+        let role: Role = dsl::roles
-            .fetch_one(pool)
+            .filter(dsl::uuid.eq(role_uuid))
-            .await;
+            .select(Role::as_select())
+            .get_result(conn)
+            .await?;
 
-        if let Err(error) = row {
+        Ok(role)
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let (name, color, position, permissions) = row.unwrap();
-
-        Ok(Role {
-            uuid: role_uuid,
-            guild_uuid,
-            name,
-            color,
-            position,
-            permissions,
-        })
     }
 
     pub async fn new(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         guild_uuid: Uuid,
         name: String,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
         let role_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let role = Role {
-            "INSERT INTO channels (uuid, guild_uuid, name, position) VALUES ('{}', '{}', $1, $2)",
-            role_uuid, guild_uuid
-        ))
-        .bind(&name)
-        .bind(0)
-        .execute(pool)
-        .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let role = Self {
             uuid: role_uuid,
             guild_uuid,
             name,
@@ -603,10 +462,18 @@ impl Role {
             permissions: 0,
         };
 
+        insert_into(roles::table)
+            .values(role.clone())
+            .execute(conn)
+            .await?;
+
         Ok(role)
     }
 }
 
+#[derive(Queryable, Selectable, Insertable)]
+#[diesel(table_name = guild_members)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Member {
     pub uuid: Uuid,
     pub nickname: Option<String>,
@@ -615,67 +482,51 @@ pub struct Member {
 }
 
 impl Member {
-    async fn count(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<i64, HttpResponse> {
+    async fn count(conn: &mut Conn, guild_uuid: Uuid) -> Result<i64, Error> {
-        let member_count = sqlx::query_scalar(&format!(
+        use guild_members::dsl;
-            "SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'",
+        let count: i64 = dsl::guild_members
-            guild_uuid
+            .filter(dsl::guild_uuid.eq(guild_uuid))
-        ))
+            .count()
-        .fetch_one(pool)
+            .get_result(conn)
-        .await;
+            .await?;
 
-        if let Err(error) = member_count {
+        Ok(count)
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        Ok(member_count.unwrap())
     }
 
     pub async fn fetch_one(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         user_uuid: Uuid,
         guild_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
-        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))
+    use guild_members::dsl;
-            .fetch_one(pool)
+    let member: Member = dsl::guild_members
-            .await;
+        .filter(dsl::user_uuid.eq(user_uuid))
+        .filter(dsl::guild_uuid.eq(guild_uuid))
+        .select(Member::as_select())
+        .get_result(conn)
+        .await?;
 
-        if let Err(error) = row {
+        Ok(member)
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        let (uuid, nickname): (String, Option<String>) = row.unwrap();
-
-        Ok(Self {
-            uuid: Uuid::from_str(&uuid).unwrap(),
-            nickname,
-            user_uuid,
-            guild_uuid,
-        })
     }
 
     pub async fn new(
-        pool: &Pool<Postgres>,
+        conn: &mut Conn,
         user_uuid: Uuid,
         guild_uuid: Uuid,
-    ) -> Result<Self, HttpResponse> {
+    ) -> Result<Self, Error> {
         let member_uuid = Uuid::now_v7();
 
-        let row = sqlx::query(&format!(
+        let member = Member {
-            "INSERT INTO guild_members uuid, guild_uuid, user_uuid VALUES ('{}', '{}', '{}')",
+            uuid: member_uuid,
-            member_uuid, guild_uuid, user_uuid
+            guild_uuid,
-        ))
+            user_uuid,
-        .execute(pool)
+            nickname: None,
-        .await;
+        };
 
-        if let Err(error) = row {
+        insert_into(guild_members::table)
-            error!("{}", error);
+            .values(member)
-
+            .execute(conn)
-            return Err(HttpResponse::InternalServerError().finish());
+            .await?;
-        }
 
         Ok(Self {
             uuid: member_uuid,
@@ -686,26 +537,9 @@ impl Member {
     }
 }
 
-#[derive(FromRow)]
+#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
-struct MessageBuilder {
+#[diesel(table_name = messages)]
-    uuid: String,
+#[diesel(check_for_backend(diesel::pg::Pg))]
-    channel_uuid: String,
-    user_uuid: String,
-    message: String,
-}
-
-impl MessageBuilder {
-    fn build(&self) -> Message {
-        Message {
-            uuid: Uuid::from_str(&self.uuid).unwrap(),
-            channel_uuid: Uuid::from_str(&self.channel_uuid).unwrap(),
-            user_uuid: Uuid::from_str(&self.user_uuid).unwrap(),
-            message: self.message.clone(),
-        }
-    }
-}
-
-#[derive(Serialize)]
 pub struct Message {
     uuid: Uuid,
     channel_uuid: Uuid,
@@ -713,25 +547,8 @@ pub struct Message {
     message: String,
 }
 
-#[derive(FromRow)]
-pub struct InviteBuilder {
-    id: String,
-    user_uuid: String,
-    guild_uuid: String,
-}
-
-impl InviteBuilder {
-    fn build(&self) -> Invite {
-        Invite {
-            id: self.id.clone(),
-            user_uuid: Uuid::from_str(&self.user_uuid).unwrap(),
-            guild_uuid: Uuid::from_str(&self.guild_uuid).unwrap(),
-        }
-    }
-}
-
 /// Server invite struct
-#[derive(Serialize)]
+#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
 pub struct Invite {
     /// case-sensitive alphanumeric string with a fixed length of 8 characters, can be up to 32 characters for custom invites
     id: String,
@@ -742,25 +559,20 @@ pub struct Invite {
 }
 
 impl Invite {
-    pub async fn fetch_one(pool: &Pool<Postgres>, invite_id: String) -> Result<Self, HttpResponse> {
+    pub async fn fetch_one(conn: &mut Conn, invite_id: String) -> Result<Self, Error> {
-        let invite: Result<InviteBuilder, sqlx::Error> =
+        use invites::dsl;
-            sqlx::query_as("SELECT id, user_uuid, guild_uuid FROM invites WHERE id = $1")
+        let invite: Invite = dsl::invites
-                .bind(invite_id)
+            .filter(dsl::id.eq(invite_id))
-                .fetch_one(pool)
+            .select(Invite::as_select())
-                .await;
+            .get_result(conn)
+            .await?;
 
-        if let Err(error) = invite {
+        Ok(invite)
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish());
-        }
-
-        Ok(invite.unwrap().build())
     }
 }
 
 #[derive(Deserialize)]
 pub struct StartAmountQuery {
-    pub start: Option<i32>,
+    pub start: Option<i64>,
-    pub amount: Option<i32>,
+    pub amount: Option<i64>,
 }

src/utils.rs

@@ -1,5 +1,4 @@
 use actix_web::{
-    HttpResponse,
     cookie::{Cookie, SameSite, time::Duration},
     http::header::HeaderMap,
 };
@@ -8,25 +7,31 @@ use hex::encode;
 use redis::RedisError;
 use serde::Serialize;
 
-use crate::Data;
+use crate::{error::Error, Data};
 
-pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, HttpResponse> {
+pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, Error> {
     let auth_token = headers.get(actix_web::http::header::AUTHORIZATION);
 
     if auth_token.is_none() {
-        return Err(HttpResponse::Unauthorized().finish());
+        return Err(Error::Unauthorized("No authorization header provided".to_string()));
     }
 
-    let auth = auth_token.unwrap().to_str();
+    let auth_raw = auth_token.unwrap().to_str()?;
 
-    if let Err(error) = auth {
+    let mut auth = auth_raw.split_whitespace();
-        return Err(HttpResponse::Unauthorized().json(format!(r#" {{ "error": "{}" }} "#, error)));
+
+    let auth_type = auth.nth(0);
+
+    let auth_value = auth.nth(0);
+
+    if auth_type.is_none() {
+        return Err(Error::BadRequest("Authorization header is empty".to_string()));
+    } else if auth_type.is_some_and(|at| at != "Bearer") {
+        return Err(Error::BadRequest("Only token auth is supported".to_string()));
     }
     
-    let auth_value = auth.unwrap().split_whitespace().nth(1);
-
     if auth_value.is_none() {
-        return Err(HttpResponse::BadRequest().finish());
+        return Err(Error::BadRequest("No token provided".to_string()));
     }
 
     Ok(auth_value.unwrap())
@@ -60,12 +65,12 @@ impl Data {
         key: String,
         value: impl Serialize,
         expire: u32,
-    ) -> Result<(), RedisError> {
+    ) -> Result<(), Error> {
         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();
+        let value_json = serde_json::to_string(&value)?;
 
         redis::cmd("SET")
             .arg(&[key_encoded.clone(), value_json])
@@ -75,7 +80,9 @@ impl Data {
         redis::cmd("EXPIRE")
             .arg(&[key_encoded, expire.to_string()])
             .exec_async(&mut conn)
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn get_cache_key(&self, key: String) -> Result<String, RedisError> {