refactor: Update error handling

server/src/client_communication.rs

···
  */
 
 extern crate rocket;
+use crate::errors::LuminaDbError;
 use crate::rate_limiter::RateLimit;
 use crate::timeline::fetch_timeline_post_ids_by_timeline_name;
 use crate::user::User;
···
 													}
 													Err(e) => {
 														match e {
-															LuminaError::Postgres(postgres_error) => {
-																// Check if it's a "no rows returned" type error
-																if postgres_error.to_string().contains("no rows") || postgres_error.to_string().contains("RowCount") {
-																	info_elog!( ev_log,"Session revival failed: token not found or expired.");
-																} else {
-																	info_elog!(ev_log,"Session revival failed: database error: {:?}", postgres_error);
+															LuminaError::DbError(LuminaDbError::Postgres(postgres_error)) => {
+																	// Check if it's a "no rows returned" type error
+																	if postgres_error.to_string().contains("no rows") || postgres_error.to_string().contains("RowCount") {
+																		info_elog!( ev_log,"Session revival failed: token not found or expired.");
+																	} else {
+																		info_elog!(ev_log,"Session revival failed: database error: {:?}", postgres_error);
+																	}
 																}
-															}
-
+															
 															_ => {
 																info_elog!(ev_log,"Session revival failed: {:?}", e);
 															}
···
 														}
 														Err(e) => {
 															match e {
-																LuminaError::Postgres(e) =>
+																LuminaError::DbError(crate::errors::LuminaDbError::Postgres(e)) =>
 																	error_elog!(ev_log,"While creating session token: {:?}", e),
-																LuminaError::Bb8Pool(e) =>
+																LuminaError::Bb8RunErrorPg(e) =>
 																	warn_elog!(ev_log,"There was an error creating session token: {}", e),
 																_ => {}
 															}

server/src/database.rs

···
 use bb8_redis::RedisConnectionManager;
 use cynthia_con::{CynthiaColors, CynthiaStyles};
 use std::time::Duration;
-use tokio_postgres as postgres;
+use crate::postgres;
 use tokio_postgres::NoTls;
 
 pub(crate) async fn setup() -> Result<PgConn, LuminaError> {
···
         std::env::var("LUMINA_REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".into());
     let redis_pool = {
         info_elog!(ev_log, "Setting up Redis connection to {}...", redis_url);
-        let manager = RedisConnectionManager::new(redis_url.clone()).map_err(LuminaError::Redis)?;
+        let manager = RedisConnectionManager::new(redis_url.clone())?;
         // Configure pool sizes
         let redis_pool = Pool::builder()
             .max_size(50)
···
         let pg_manager = PostgresConnectionManager::new(pg_config.clone(), NoTls);
         let pg_pool = Pool::builder()
             .build(pg_manager)
-            .await
-            .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+            .await?;
         {
             let pg_conn = pg_pool
                 .get()
-                .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                .await?;
             pg_conn
                 .batch_execute(include_str!("../../SQL/create_pg.sql"))
-                .await
-                .map_err(LuminaError::Postgres)?;
-
+                .await?;
             // Populate bloom filters
             let mut redis_conn = redis_pool
                 .get()
-                .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                .await?;
             let email_key = "bloom:email";
             let username_key = "bloom:username";
 
             let rows = pg_conn
                 .query("SELECT email, username FROM users", &[])
-                .await
-                .map_err(LuminaError::Postgres)?;
+                .await?;
             for row in rows {
                 let email: String = row.get(0);
                 let username: String = row.get(1);
···
                     .arg(email)
                     .query_async(&mut *redis_conn)
                     .await
-                    .map_err(LuminaError::Redis)?;
+                    ?;
                 let _: () = redis::cmd("BF.ADD")
                     .arg(username_key)
                     .arg(username)
                     .query_async(&mut *redis_conn)
                     .await
-                    .map_err(LuminaError::Redis)?;
+                    ?;
             }
             info_elog!(ev_log, "Bloom filters populated from PostgreSQL.",);
         };
···
             .arg(pattern)
             .query_async(&mut **redis_conn)
             .await
-            .map_err(LuminaError::Redis)?;
+            ?;
 
         cursor = result.0;
         let keys = result.1;
···
                 .arg(&key)
                 .query_async(&mut **redis_conn)
                 .await
-                .map_err(LuminaError::Redis)?;
+                ?;
             if ttl == -1 || ttl == 0 {
                 expired_keys.push(key);
             }
···
                 .arg(&expired_keys)
                 .query_async(&mut **redis_conn)
                 .await
-                .map_err(LuminaError::Redis)?;
+                ?;
         }
 
         if cursor == 0 {
···
             )
             .query_async(&mut **redis_conn)
             .await
-            .map_err(LuminaError::Redis)?;
+            ?;
         return Ok(());
     };
 
···
                 )
                 .query_async(&mut **redis_conn)
                 .await
-                .map_err(LuminaError::Redis)?;
+                ?;
         }
         Err(_) => {
             // If query fails, just update timestamp to avoid repeated failures
···
                 )
                 .query_async(&mut **redis_conn)
                 .await
-                .map_err(LuminaError::Redis)?;
+                ?;
         }
     }
 

server/src/errors.rs

···
 #[derive(Debug)]
 pub(crate) enum LuminaError {
     ConfInvalid(String),
-    Bb8Pool(String),
-    Postgres(crate::postgres::Error),
+    DbError(LuminaDbError),
+    Bb8RunErrorPg(bb8::RunError<crate::postgres::Error>),
+    Bb8RunErrorRedis(bb8::RunError<redis::RedisError>),
     Unknown,
     RocketFaillure(Box<rocket::Error>),
     BcryptError,
···
     AuthenticationWrongPassword,
     UUidError,
     RegexError,
-    Redis(redis::RedisError),
     SerializationError(String),
     JoinFaillure,
 }
+
+impl From<LuminaDbError> for LuminaError {
+    fn from(v: LuminaDbError) -> Self {
+        Self::DbError(v)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum LuminaDbError {
+    Redis(redis::RedisError),
+    Postgres(crate::postgres::Error),
+}
+
 impl From<rocket::Error> for LuminaError {
     fn from(err: rocket::Error) -> Self {
         LuminaError::RocketFaillure(Box::new(err))
···
 
 impl From<crate::postgres::Error> for LuminaError {
     fn from(err: crate::postgres::Error) -> Self {
-        LuminaError::Postgres(err)
+        LuminaError::DbError(LuminaDbError::Postgres(err))
     }
 }
 
 impl From<redis::RedisError> for LuminaError {
     fn from(err: redis::RedisError) -> Self {
-        LuminaError::Redis(err)
+        LuminaError::DbError(LuminaDbError::Redis(err))
+    }
+}
+impl From<bb8::RunError<crate::postgres::Error>> for LuminaError {
+    fn from(err: bb8::RunError<crate::postgres::Error>) -> Self {
+        LuminaError::Bb8RunErrorPg(err)
+    }
+}
+impl From<bb8::RunError<redis::RedisError>> for LuminaError {
+    fn from(err: bb8::RunError<redis::RedisError>) -> Self {
+        LuminaError::Bb8RunErrorRedis(err)
     }
 }
+impl ToString for LuminaError {
+    fn to_string(&self) -> String {
+        match self {
+            LuminaError::ConfInvalid(s) => format!("Configuration invalid: {}", s),
+            LuminaError::DbError(e) => match e {
+                LuminaDbError::Redis(re) => format!("Redis error: {}", re),
+                LuminaDbError::Postgres(pe) => format!("Postgres error: {}", pe),
+            },
+            LuminaError::Bb8RunErrorPg(e) => format!("Postgres connection pool error: {}", e),
+            LuminaError::Bb8RunErrorRedis(e) => format!("Redis connection pool error: {}", e),
+            LuminaError::RocketFaillure(e) => format!("Rocket error: {}", e),
+            LuminaError::BcryptError => "Bcrypt error".to_string(),
+            LuminaError::RegisterEmailInUse => "Email already in use".to_string(),
+            LuminaError::RegisterUsernameInUse => "Username already in use".to_string(),
+            LuminaError::RegisterEmailNotValid => "Email not valid".to_string(),
+            LuminaError::RegisterUsernameInvalid(s) => format!("Username invalid: {}", s),
+            LuminaError::RegisterPasswordNotValid(s) => format!("Password not valid: {}", s),
+            LuminaError::AuthenticationWrongPassword => "Wrong password".to_string(),
+            LuminaError::UUidError => "UUID error".to_string(),
+            LuminaError::RegexError => "Regex error".to_string(),
+            LuminaError::SerializationError(s) => format!("Serialization error: {}", s),
+            LuminaError::JoinFaillure => "Process join failure".to_string(),
+            LuminaError::Unknown => "Unknown error".to_string(),
+        }
+    }
+}

server/src/main.rs

···
                                 None
                             }
 
-                            Err(LuminaError::Postgres(a)) => {
+                            Err(LuminaError::DbError(crate::errors::LuminaDbError::Postgres(a))) => {
                                 error_elog!(ev_log, "While connecting to postgres database: {}", a);
                                 None
                             }
-                            Err(LuminaError::Bb8Pool(a)) => {
+                            Err(LuminaError::Bb8RunErrorPg(a)) => {
                                 error_elog!(ev_log, "While setting up database pool: {}", a);
                                 None
                             }
-                            Err(LuminaError::Redis(a)) => {
+                            Err(LuminaError::DbError(crate::errors::LuminaDbError::Redis(a))) => {
+                                error_elog!(ev_log, "While connecting to Redis: {}", a);
+                                None
+                            }
+                            Err(LuminaError::Bb8RunErrorRedis(a)) => {
                                 error_elog!(ev_log, "While connecting to Redis: {}", a);
                                 None
                             }

server/src/tests.rs

···
  *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use std::mem;
 use crate::database::{self, DatabaseConnections};
 use crate::timeline;
+use crate::errors::LuminaError;
 
 #[tokio::test]
 async fn test_database_setup() {
···
 
     assert!(result.is_none(), "Cache should be invalidated");
 }
+
+
+#[test]
+fn print_sizes() {
+    println!("Size of LuminaError: {} bytes", mem::size_of::<LuminaError>());
+    println!("Size of Rocket Error: {} bytes", mem::size_of::<rocket::Error>());
+    println!("Size of Postgres Error: {} bytes", mem::size_of::<crate::postgres::Error>());
+    println!("Size of Redis Error: {} bytes", mem::size_of::<redis::RedisError>());
+        println!("Size of DbError: {} bytes", mem::size_of::<crate::errors::LuminaDbError>());
+        println!("Size of bb8 RunError Postgres: {} bytes", mem::size_of::<bb8::RunError<crate::postgres::Error>>());
+        println!("Size of bb8 RunError Redis: {} bytes", mem::size_of::<bb8::RunError<redis::RedisError>>());
+    println!("Size of String: {} bytes", mem::size_of::<String>());
+}

server/src/timeline.rs

···
  *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use crate::errors::LuminaError;
+use crate::errors::{LuminaDbError, LuminaError};
 use crate::helpers::events::EventLogger;
 use crate::{DbConn, error_elog, info_elog, user};
 use serde::{Deserialize, Serialize};
···
         .arg(serialized)
         .query_async(&mut **redis_conn)
         .await
-        .map_err(LuminaError::Redis)?;
+        ?;
 
     // Also cache metadata
     let meta_key = get_cache_meta_key(timeline_id);
···
         .arg(total_count)
         .query_async(&mut **redis_conn)
         .await
-        .map_err(LuminaError::Redis)?;
+        ?;
 
     Ok(())
 }
···
         .arg(cache_key)
         .query_async(&mut **redis_conn)
         .await
-        .map_err(LuminaError::Redis)?;
+        ?;
 
     match cached_data {
         Some(data) => {
···
             .arg(&pattern)
             .query_async(&mut **redis_conn)
             .await
-            .map_err(LuminaError::Redis)?;
+            ?;
 
         cursor = result.0;
         let keys = result.1;
···
                 .arg(&keys)
                 .query_async(&mut **redis_conn)
                 .await
-                .map_err(LuminaError::Redis)?;
+                ?;
         }
 
         if cursor == 0 {
···
             let client = pg_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let row = client
                 .query_one(
···
                     &[&timeline_uuid],
                 )
                 .await
-                .map_err(LuminaError::Postgres)?;
+               ?;
 
             let count: i64 = row.get(0);
             Ok(count as usize)
···
             let client = pg_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let rows = client
 				.query(
···
 					&[&timeline_uuid, &(limit as i64), &(offset as i64)],
 				)
 				.await
-				.map_err(LuminaError::Postgres)?;
+				?;
 
             let post_ids = rows
                 .into_iter()
···
         DbConn::PgsqlConnection(_, redis_pool) => redis_pool
             .get()
             .await
-            .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?,
+            ?,
     };
 
     // Log the requested timeline id for tracking
···
         .arg(format!("timeline_lookup:{}", timeline_id))
         .query_async(&mut *redis_conn)
         .await
-        .map_err(LuminaError::Redis)?;
+        ?;
 
     // Check if this timeline should be cached
     let should_cache = is_high_traffic_timeline(&mut redis_conn, timeline_id).await?;
···
                         page,
                         s
                     ),
-                    LuminaError::Redis(redis_err) => error_elog!(
+                    LuminaError::DbError(LuminaDbError::Redis(redis_err)) => error_elog!(
                         event_logger,
                         "Failed to cache timeline {} page {}: {:?}",
                         timeline_id,
···
             let client = pg_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let item_uuid = Uuid::parse_str(item_id).map_err(|_| LuminaError::UUidError)?;
             client
···
                     &[&timeline_uuid, &item_uuid],
                 )
                 .await
-                .map_err(LuminaError::Postgres)?;
+               ?;
 
             // Invalidate cache
             let mut redis_conn = redis_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             if let Err(e) = invalidate_timeline_cache(&mut redis_conn, timeline_id).await {
                 error_elog!(
                     event_logger,
···
             let client = pg_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let item_uuid = Uuid::parse_str(item_id).map_err(|_| LuminaError::UUidError)?;
             client
···
                     &[&timeline_uuid, &item_uuid],
                 )
                 .await
-                .map_err(LuminaError::Postgres)?;
+               ?;
 
             // Invalidate cache
             let mut redis_conn = redis_pool
                 .get()
                 .await
-                .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                ?;
             if let Err(e) = invalidate_timeline_cache(&mut redis_conn, timeline_id).await {
                 error_elog!(
                     event_logger,

server/src/user.rs

···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 let row = client
                     .query_one("SELECT password FROM users WHERE id = $1", &[&self.id])
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 let password: String = row.get(0);
                 Ok(password)
             }
···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 // Some username and email validation should be done here
                 // Check if the email is already in use
                 let email_exists = client
                     .query("SELECT * FROM users WHERE email = $1", &[&email])
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 if !email_exists.is_empty() {
                     return Err(LuminaError::RegisterEmailInUse);
                 }
···
                 let username_exists = client
                     .query("SELECT * FROM users WHERE username = $1", &[&username])
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 if !username_exists.is_empty() {
                     return Err(LuminaError::RegisterUsernameInUse);
                 }
···
                 let id = client
 					.query_one("INSERT INTO users (email, username, password) VALUES ($1, $2, $3) RETURNING id", &[&email, &username, &password])
 					.await
-					.map_err(LuminaError::Postgres)?;
+					?;
                 Ok(User {
                     id: id.get(0),
                     email,
···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 let user = client
 					.query_one(
 						&format!("SELECT id, email, username, COALESCE(foreign_instance_id, '') FROM users WHERE {} = $1", identifyer_type),
 						&[&identifier],
 					)
 					.await
-					.map_err(LuminaError::Postgres)?;
+					?;
                 Ok(User {
                     id: user.get(0),
                     email: user.get(1),
···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 let session_key = Uuid::new_v4().to_string();
                 let id = client
                     .query_one(
···
                         &[&user_id, &session_key],
                     )
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 info_elog!(
                     ev_log,
                     "New session created by {}",
···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 let user = client
 					.query_one("SELECT users.id, users.email, users.username FROM users JOIN sessions ON users.id = sessions.user_id WHERE sessions.session_key = $1", &[&token])
 					.await
-					.map_err(LuminaError::Postgres)?;
+					?;
                 Ok(User {
                     id: user.get(0),
                     email: user.get(1),
···
                 let client = pg_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 let mut redis_conn = redis_pool
                     .get()
                     .await
-                    .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                    ?;
                 // fastbloom_rs expects bytes, so we use the string as bytes
                 let email_key = String::from("bloom:email");
                 let username_key = String::from("bloom:username");
···
                     let email_db = client
                         .query("SELECT * FROM users WHERE email = $1", &[&email])
                         .await
-                        .map_err(LuminaError::Postgres)?;
+                        ?;
                     if !email_db.is_empty() {
                         return Err(LuminaError::RegisterEmailInUse);
                     }
···
                     let username_db = client
                         .query("SELECT * FROM users WHERE username = $1", &[&username])
                         .await
-                        .map_err(LuminaError::Postgres)?;
+                        ?;
                     if !username_db.is_empty() {
                         return Err(LuminaError::RegisterUsernameInUse);
                     }
···
                 let email_db = client
                     .query("SELECT * FROM users WHERE email = $1", &[&email])
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 if !email_db.is_empty() {
                     // Update bloom filter after DB check
                     let _: () = redis::cmd("BF.ADD")
···
                 let username_db = client
                     .query("SELECT * FROM users WHERE username = $1", &[&username])
                     .await
-                    .map_err(LuminaError::Postgres)?;
+                    ?;
                 if !username_db.is_empty() {
                     let _: () = redis::cmd("BF.ADD")
                         .arg(&username_key)