Rename DatabaseError::Internal to DatabaseError::Error

gemcoder21 · gemcoder21 · commit 031d64f76e4a · 2025-12-28T02:30:39.000Z
Refactors the DatabaseError enum by renaming the Internal variant to Error across storage and API layers. Updates all usages and error handling logic to use the new variant name for consistency and clarity.
diff --git a/apps/api/src/responders.rs b/apps/api/src/responders.rs
@@ -48,7 +48,7 @@ impl From<DatabaseError> for ApiError {
     fn from(error: DatabaseError) -> Self {
         match error {
             DatabaseError::NotFound => ApiError::NotFound(error.to_string()),
-            DatabaseError::Internal(msg) => ApiError::InternalServerError(msg),
+            DatabaseError::Error(msg) => ApiError::InternalServerError(msg),
         }
     }
 }
diff --git a/crates/storage/src/error.rs b/crates/storage/src/error.rs
@@ -4,14 +4,14 @@ use std::fmt;
 #[derive(Debug, Clone)]
 pub enum DatabaseError {
     NotFound,
-    Internal(String),
+    Error(String),
 }
 
 impl fmt::Display for DatabaseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             DatabaseError::NotFound => write!(f, "Resource not found"),
-            DatabaseError::Internal(msg) => write!(f, "Internal database error: {}", msg),
+            DatabaseError::Error(msg) => write!(f, "{}", msg),
         }
     }
 }
@@ -22,7 +22,7 @@ impl From<diesel::result::Error> for DatabaseError {
     fn from(error: diesel::result::Error) -> Self {
         match error {
             diesel::result::Error::NotFound => DatabaseError::NotFound,
-            e => DatabaseError::Internal(e.to_string()),
+            e => DatabaseError::Error(e.to_string()),
         }
     }
 }
diff --git a/crates/storage/src/repositories/config_repository.rs b/crates/storage/src/repositories/config_repository.rs
@@ -26,29 +26,29 @@ impl ConfigRepository for DatabaseClient {
     fn get_config_i64(&mut self, key: ConfigKey) -> Result<i64, DatabaseError> {
         self.get_config(key)?
             .parse()
-            .map_err(|e| DatabaseError::Internal(format!("Failed to parse config value: {}", e)))
+            .map_err(|e| DatabaseError::Error(format!("Failed to parse config value: {}", e)))
     }
 
     fn get_config_f64(&mut self, key: ConfigKey) -> Result<f64, DatabaseError> {
         self.get_config(key)?
             .parse()
-            .map_err(|e| DatabaseError::Internal(format!("Failed to parse config value: {}", e)))
+            .map_err(|e| DatabaseError::Error(format!("Failed to parse config value: {}", e)))
     }
 
     fn get_config_bool(&mut self, key: ConfigKey) -> Result<bool, DatabaseError> {
         self.get_config(key)?
             .parse()
-            .map_err(|e| DatabaseError::Internal(format!("Failed to parse config value: {}", e)))
+            .map_err(|e| DatabaseError::Error(format!("Failed to parse config value: {}", e)))
     }
 
     fn get_config_duration(&mut self, key: ConfigKey) -> Result<Duration, DatabaseError> {
         let value = self.get_config(key)?;
-        parse_duration(&value).ok_or_else(|| DatabaseError::Internal(format!("Failed to parse duration: {}", value)))
+        parse_duration(&value).ok_or_else(|| DatabaseError::Error(format!("Failed to parse duration: {}", value)))
     }
 
     fn get_config_vec_string(&mut self, key: ConfigKey) -> Result<Vec<String>, DatabaseError> {
         let value = self.get_config(key)?;
-        serde_json::from_str(&value).map_err(|e| DatabaseError::Internal(format!("Failed to parse config vec: {}", e)))
+        serde_json::from_str(&value).map_err(|e| DatabaseError::Error(format!("Failed to parse config vec: {}", e)))
     }
 
     fn add_config(&mut self, configs: Vec<ConfigRow>) -> Result<usize, DatabaseError> {
diff --git a/crates/storage/src/repositories/rewards_redemptions_repository.rs b/crates/storage/src/repositories/rewards_redemptions_repository.rs
@@ -20,11 +20,11 @@ impl RewardsRedemptionsRepository for DatabaseClient {
         let rewards = RewardsStore::get_rewards(self, username)?;
 
         if rewards.points < redemption_option.option.points {
-            return Err(DatabaseError::Internal("Not enough points".into()));
+            return Err(DatabaseError::Error("Not enough points".into()));
         }
 
         if redemption_option.option.remaining == Some(0) {
-            return Err(DatabaseError::Internal("Redemption option is no longer available".into()));
+            return Err(DatabaseError::Error("Redemption option is no longer available".into()));
         }
 
         let redemption_id = RewardsRedemptionsStore::add_redemption(
diff --git a/crates/storage/src/repositories/rewards_repository.rs b/crates/storage/src/repositories/rewards_repository.rs
@@ -16,13 +16,13 @@ fn has_custom_username(username: &str, address: &str) -> bool {
 fn validate_username(username: &str) -> Result<(), DatabaseError> {
     let len = username.len();
     if len < 4 {
-        return Err(DatabaseError::Internal("Username must be at least 4 characters".into()));
+        return Err(DatabaseError::Error("Username must be at least 4 characters".into()));
     }
     if len > 16 {
-        return Err(DatabaseError::Internal("Username must be at most 16 characters".into()));
+        return Err(DatabaseError::Error("Username must be at most 16 characters".into()));
     }
     if !username.chars().all(|c| c.is_ascii_alphanumeric()) {
-        return Err(DatabaseError::Internal("Username must contain only letters and digits".into()));
+        return Err(DatabaseError::Error("Username must contain only letters and digits".into()));
     }
     Ok(())
 }
@@ -107,17 +107,17 @@ impl RewardsRepository for DatabaseClient {
         validate_username(username)?;
 
         if UsernamesStore::username_exists(self, UsernameLookup::Username(username))? {
-            return Err(DatabaseError::Internal("Username already taken".into()));
+            return Err(DatabaseError::Error("Username already taken".into()));
         }
 
         if UsernamesStore::username_exists(self, UsernameLookup::Address(address))? {
             let existing = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;
             if has_custom_username(&existing.username, &existing.address) {
-                return Err(DatabaseError::Internal("Address already has a username".into()));
+                return Err(DatabaseError::Error("Address already has a username".into()));
             }
             let existing_rewards = RewardsStore::get_rewards(self, &existing.username)?;
             if !existing_rewards.is_enabled {
-                return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));
+                return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));
             }
             UsernamesStore::update_username(self, address, username)?;
         } else {
@@ -161,20 +161,20 @@ impl RewardsRepository for DatabaseClient {
         let existing = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;
 
         if !has_custom_username(&existing.username, &existing.address) {
-            return Err(DatabaseError::Internal("No custom username to change".into()));
+            return Err(DatabaseError::Error("No custom username to change".into()));
         }
 
         if existing.username.eq_ignore_ascii_case(new_username) {
-            return Err(DatabaseError::Internal("New username is the same as current".into()));
+            return Err(DatabaseError::Error("New username is the same as current".into()));
         }
 
         if UsernamesStore::username_exists(self, UsernameLookup::Username(new_username))? {
-            return Err(DatabaseError::Internal("Username already taken".into()));
+            return Err(DatabaseError::Error("Username already taken".into()));
         }
 
         let rewards = RewardsStore::get_rewards(self, &existing.username)?;
         if !rewards.is_enabled {
-            return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));
+            return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));
         }
 
         UsernamesStore::change_username(self, &existing.username, new_username)?;
@@ -191,29 +191,29 @@ impl RewardsRepository for DatabaseClient {
         let referrer_rewards = RewardsStore::get_rewards(self, &referrer.username)?;
 
         if !referrer_rewards.is_enabled {
-            return Err(DatabaseError::Internal("Rewards are not enabled for this referral code".into()));
+            return Err(DatabaseError::Error(format!("Rewards are not enabled for referral code: {}", referral_code)));
         }
 
         if UsernamesStore::username_exists(self, UsernameLookup::Address(address))? {
             let username = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;
             let rewards = RewardsStore::get_rewards(self, &username.username)?;
             if !rewards.is_enabled {
-                return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));
+                return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));
             }
             if rewards.referrer_username.is_some() {
-                return Err(DatabaseError::Internal("Already used a referral code".into()));
+                return Err(DatabaseError::Error("Already used a referral code".into()));
             }
             if referrer.username == username.username || referrer.address.eq_ignore_ascii_case(&username.address) {
-                return Err(DatabaseError::Internal("Cannot use your own referral code".into()));
+                return Err(DatabaseError::Error("Cannot use your own referral code".into()));
             }
         }
 
         if SubscriptionsStore::get_device_subscription_address_exists(self, device_id, &referrer.address)? {
-            return Err(DatabaseError::Internal("Cannot use your own referral code".into()));
+            return Err(DatabaseError::Error("Cannot use your own referral code".into()));
         }
 
         if RewardsStore::get_referral_by_referred_device_id(self, device_id)?.is_some() {
-            return Err(DatabaseError::Internal("Device already used a referral code".into()));
+            return Err(DatabaseError::Error("Device already used a referral code".into()));
         }
 
         Ok(())

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ impl From<DatabaseError> for ApiError {`
`48`	`48`	`fn from(error: DatabaseError) -> Self {`
`49`	`49`	`match error {`
`50`	`50`	`DatabaseError::NotFound => ApiError::NotFound(error.to_string()),`
`51`		`- DatabaseError::Internal(msg) => ApiError::InternalServerError(msg),`
	`51`	`+ DatabaseError::Error(msg) => ApiError::InternalServerError(msg),`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@ use std::fmt;`
`4`	`4`	`#[derive(Debug, Clone)]`
`5`	`5`	`pub enum DatabaseError {`
`6`	`6`	`NotFound,`
`7`		`- Internal(String),`
	`7`	`+ Error(String),`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`impl fmt::Display for DatabaseError {`
`11`	`11`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`12`	`12`	`match self {`
`13`	`13`	`DatabaseError::NotFound => write!(f, "Resource not found"),`
`14`		`- DatabaseError::Internal(msg) => write!(f, "Internal database error: {}", msg),`
	`14`	`+ DatabaseError::Error(msg) => write!(f, "{}", msg),`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`	`}`
`@@ -22,7 +22,7 @@ impl From<diesel::result::Error> for DatabaseError {`
`22`	`22`	`fn from(error: diesel::result::Error) -> Self {`
`23`	`23`	`match error {`
`24`	`24`	`diesel::result::Error::NotFound => DatabaseError::NotFound,`
`25`		`- e => DatabaseError::Internal(e.to_string()),`
	`25`	`+ e => DatabaseError::Error(e.to_string()),`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ impl RewardsRedemptionsRepository for DatabaseClient {`
`20`	`20`	`let rewards = RewardsStore::get_rewards(self, username)?;`
`21`	`21`
`22`	`22`	`if rewards.points < redemption_option.option.points {`
`23`		`- return Err(DatabaseError::Internal("Not enough points".into()));`
	`23`	`+ return Err(DatabaseError::Error("Not enough points".into()));`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`if redemption_option.option.remaining == Some(0) {`
`27`		`- return Err(DatabaseError::Internal("Redemption option is no longer available".into()));`
	`27`	`+ return Err(DatabaseError::Error("Redemption option is no longer available".into()));`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`let redemption_id = RewardsRedemptionsStore::add_redemption(`
Original file line number	Diff line number	Diff line change
`@@ -16,13 +16,13 @@ fn has_custom_username(username: &str, address: &str) -> bool {`
`16`	`16`	`fn validate_username(username: &str) -> Result<(), DatabaseError> {`
`17`	`17`	`let len = username.len();`
`18`	`18`	`if len < 4 {`
`19`		`- return Err(DatabaseError::Internal("Username must be at least 4 characters".into()));`
	`19`	`+ return Err(DatabaseError::Error("Username must be at least 4 characters".into()));`
`20`	`20`	`}`
`21`	`21`	`if len > 16 {`
`22`		`- return Err(DatabaseError::Internal("Username must be at most 16 characters".into()));`
	`22`	`+ return Err(DatabaseError::Error("Username must be at most 16 characters".into()));`
`23`	`23`	`}`
`24`	`24`	`if !username.chars().all(\|c\| c.is_ascii_alphanumeric()) {`
`25`		`- return Err(DatabaseError::Internal("Username must contain only letters and digits".into()));`
	`25`	`+ return Err(DatabaseError::Error("Username must contain only letters and digits".into()));`
`26`	`26`	`}`
`27`	`27`	`Ok(())`
`28`	`28`	`}`
`@@ -107,17 +107,17 @@ impl RewardsRepository for DatabaseClient {`
`107`	`107`	`validate_username(username)?;`
`108`	`108`
`109`	`109`	`if UsernamesStore::username_exists(self, UsernameLookup::Username(username))? {`
`110`		`- return Err(DatabaseError::Internal("Username already taken".into()));`
	`110`	`+ return Err(DatabaseError::Error("Username already taken".into()));`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`if UsernamesStore::username_exists(self, UsernameLookup::Address(address))? {`
`114`	`114`	`let existing = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;`
`115`	`115`	`if has_custom_username(&existing.username, &existing.address) {`
`116`		`- return Err(DatabaseError::Internal("Address already has a username".into()));`
	`116`	`+ return Err(DatabaseError::Error("Address already has a username".into()));`
`117`	`117`	`}`
`118`	`118`	`let existing_rewards = RewardsStore::get_rewards(self, &existing.username)?;`
`119`	`119`	`if !existing_rewards.is_enabled {`
`120`		`- return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));`
	`120`	`+ return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));`
`121`	`121`	`}`
`122`	`122`	`UsernamesStore::update_username(self, address, username)?;`
`123`	`123`	`} else {`
`@@ -161,20 +161,20 @@ impl RewardsRepository for DatabaseClient {`
`161`	`161`	`let existing = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;`
`162`	`162`
`163`	`163`	`if !has_custom_username(&existing.username, &existing.address) {`
`164`		`- return Err(DatabaseError::Internal("No custom username to change".into()));`
	`164`	`+ return Err(DatabaseError::Error("No custom username to change".into()));`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`if existing.username.eq_ignore_ascii_case(new_username) {`
`168`		`- return Err(DatabaseError::Internal("New username is the same as current".into()));`
	`168`	`+ return Err(DatabaseError::Error("New username is the same as current".into()));`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`if UsernamesStore::username_exists(self, UsernameLookup::Username(new_username))? {`
`172`		`- return Err(DatabaseError::Internal("Username already taken".into()));`
	`172`	`+ return Err(DatabaseError::Error("Username already taken".into()));`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`let rewards = RewardsStore::get_rewards(self, &existing.username)?;`
`176`	`176`	`if !rewards.is_enabled {`
`177`		`- return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));`
	`177`	`+ return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`UsernamesStore::change_username(self, &existing.username, new_username)?;`
`@@ -191,29 +191,29 @@ impl RewardsRepository for DatabaseClient {`
`191`	`191`	`let referrer_rewards = RewardsStore::get_rewards(self, &referrer.username)?;`
`192`	`192`
`193`	`193`	`if !referrer_rewards.is_enabled {`
`194`		`- return Err(DatabaseError::Internal("Rewards are not enabled for this referral code".into()));`
	`194`	`+ return Err(DatabaseError::Error(format!("Rewards are not enabled for referral code: {}", referral_code)));`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`if UsernamesStore::username_exists(self, UsernameLookup::Address(address))? {`
`198`	`198`	`let username = UsernamesStore::get_username(self, UsernameLookup::Address(address))?;`
`199`	`199`	`let rewards = RewardsStore::get_rewards(self, &username.username)?;`
`200`	`200`	`if !rewards.is_enabled {`
`201`		`- return Err(DatabaseError::Internal("Rewards are not enabled for this user".into()));`
	`201`	`+ return Err(DatabaseError::Error("Rewards are not enabled for this user".into()));`
`202`	`202`	`}`
`203`	`203`	`if rewards.referrer_username.is_some() {`
`204`		`- return Err(DatabaseError::Internal("Already used a referral code".into()));`
	`204`	`+ return Err(DatabaseError::Error("Already used a referral code".into()));`
`205`	`205`	`}`
`206`	`206`	`if referrer.username == username.username \|\| referrer.address.eq_ignore_ascii_case(&username.address) {`
`207`		`- return Err(DatabaseError::Internal("Cannot use your own referral code".into()));`
	`207`	`+ return Err(DatabaseError::Error("Cannot use your own referral code".into()));`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`if SubscriptionsStore::get_device_subscription_address_exists(self, device_id, &referrer.address)? {`
`212`		`- return Err(DatabaseError::Internal("Cannot use your own referral code".into()));`
	`212`	`+ return Err(DatabaseError::Error("Cannot use your own referral code".into()));`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`if RewardsStore::get_referral_by_referred_device_id(self, device_id)?.is_some() {`
`216`		`- return Err(DatabaseError::Internal("Device already used a referral code".into()));`
	`216`	`+ return Err(DatabaseError::Error("Device already used a referral code".into()));`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`Ok(())`