Refactor errors of storage interface

Ref. #75

Author: treiher

Cargo.lock

@@ -16,6 +16,7 @@ authors = ["Tobias Reiher <valens@ardeidae.de>"]
 edition = "2024"
 
 [workspace.dependencies]
+anyhow = "1.0.97"
 assert_approx_eq = "1.1.0"
 chrono = { version = "0.4.20", default-features = false }
 log = { version = "0.4.26" }

Cargo.toml

@@ -6,6 +6,7 @@ edition.workspace = true
 publish = false
 
 [dependencies]
+anyhow = { workspace = true }
 chrono = { workspace = true, default-features = false }
 derive_more = { version = "2.0.1", features = ["as_ref", "deref", "display", "into"] }
 thiserror = { workspace = true }

crates/domain/Cargo.toml

@@ -18,104 +18,178 @@ use uuid::Uuid;
 
 #[allow(async_fn_in_trait)]
 pub trait SessionRepository {
-    async fn request_session(&self, user_id: UserID) -> Result<User, String>;
-    async fn initialize_session(&self) -> Result<User, String>;
-    async fn delete_session(&self) -> Result<(), String>;
+    async fn request_session(&self, user_id: UserID) -> Result<User, ReadError>;
+    async fn initialize_session(&self) -> Result<User, ReadError>;
+    async fn delete_session(&self) -> Result<(), DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait VersionRepository {
-    async fn read_version(&self) -> Result<String, String>;
+    async fn read_version(&self) -> Result<String, ReadError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait UserRepository {
-    async fn read_users(&self) -> Result<Vec<User>, String>;
-    async fn create_user(&self, name: Name, sex: Sex) -> Result<User, String>;
-    async fn replace_user(&self, user: User) -> Result<User, String>;
-    async fn delete_user(&self, id: UserID) -> Result<UserID, String>;
+    async fn read_users(&self) -> Result<Vec<User>, ReadError>;
+    async fn create_user(&self, name: Name, sex: Sex) -> Result<User, CreateError>;
+    async fn replace_user(&self, user: User) -> Result<User, UpdateError>;
+    async fn delete_user(&self, id: UserID) -> Result<UserID, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait BodyWeightRepository {
-    async fn sync_body_weight(&self) -> Result<Vec<BodyWeight>, String>;
-    async fn read_body_weight(&self) -> Result<Vec<BodyWeight>, String>;
-    async fn create_body_weight(&self, body_weight: BodyWeight) -> Result<BodyWeight, String>;
-    async fn replace_body_weight(&self, body_weight: BodyWeight) -> Result<BodyWeight, String>;
-    async fn delete_body_weight(&self, date: NaiveDate) -> Result<NaiveDate, String>;
+    async fn sync_body_weight(&self) -> Result<Vec<BodyWeight>, SyncError>;
+    async fn read_body_weight(&self) -> Result<Vec<BodyWeight>, ReadError>;
+    async fn create_body_weight(&self, body_weight: BodyWeight) -> Result<BodyWeight, CreateError>;
+    async fn replace_body_weight(&self, body_weight: BodyWeight)
+    -> Result<BodyWeight, UpdateError>;
+    async fn delete_body_weight(&self, date: NaiveDate) -> Result<NaiveDate, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait BodyFatRepository {
-    async fn sync_body_fat(&self) -> Result<Vec<BodyFat>, String>;
-    async fn read_body_fat(&self) -> Result<Vec<BodyFat>, String>;
-    async fn create_body_fat(&self, body_fat: BodyFat) -> Result<BodyFat, String>;
-    async fn replace_body_fat(&self, body_fat: BodyFat) -> Result<BodyFat, String>;
-    async fn delete_body_fat(&self, date: NaiveDate) -> Result<NaiveDate, String>;
+    async fn sync_body_fat(&self) -> Result<Vec<BodyFat>, SyncError>;
+    async fn read_body_fat(&self) -> Result<Vec<BodyFat>, ReadError>;
+    async fn create_body_fat(&self, body_fat: BodyFat) -> Result<BodyFat, CreateError>;
+    async fn replace_body_fat(&self, body_fat: BodyFat) -> Result<BodyFat, UpdateError>;
+    async fn delete_body_fat(&self, date: NaiveDate) -> Result<NaiveDate, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait PeriodRepository {
-    async fn sync_period(&self) -> Result<Vec<Period>, String>;
-    async fn read_period(&self) -> Result<Vec<Period>, String>;
-    async fn create_period(&self, period: Period) -> Result<Period, String>;
-    async fn replace_period(&self, period: Period) -> Result<Period, String>;
-    async fn delete_period(&self, date: NaiveDate) -> Result<NaiveDate, String>;
+    async fn sync_period(&self) -> Result<Vec<Period>, SyncError>;
+    async fn read_period(&self) -> Result<Vec<Period>, ReadError>;
+    async fn create_period(&self, period: Period) -> Result<Period, CreateError>;
+    async fn replace_period(&self, period: Period) -> Result<Period, UpdateError>;
+    async fn delete_period(&self, date: NaiveDate) -> Result<NaiveDate, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait ExerciseRepository {
-    async fn sync_exercises(&self) -> Result<Vec<Exercise>, String>;
-    async fn read_exercises(&self) -> Result<Vec<Exercise>, String>;
+    async fn sync_exercises(&self) -> Result<Vec<Exercise>, SyncError>;
+    async fn read_exercises(&self) -> Result<Vec<Exercise>, ReadError>;
     async fn create_exercise(
         &self,
         name: Name,
         muscles: Vec<ExerciseMuscle>,
-    ) -> Result<Exercise, String>;
-    async fn replace_exercise(&self, exercise: Exercise) -> Result<Exercise, String>;
-    async fn delete_exercise(&self, id: ExerciseID) -> Result<ExerciseID, String>;
+    ) -> Result<Exercise, CreateError>;
+    async fn replace_exercise(&self, exercise: Exercise) -> Result<Exercise, UpdateError>;
+    async fn delete_exercise(&self, id: ExerciseID) -> Result<ExerciseID, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait RoutineRepository {
-    async fn sync_routines(&self) -> Result<Vec<Routine>, String>;
-    async fn read_routines(&self) -> Result<Vec<Routine>, String>;
+    async fn sync_routines(&self) -> Result<Vec<Routine>, SyncError>;
+    async fn read_routines(&self) -> Result<Vec<Routine>, ReadError>;
     async fn create_routine(
         &self,
         name: Name,
         sections: Vec<RoutinePart>,
-    ) -> Result<Routine, String>;
+    ) -> Result<Routine, CreateError>;
     async fn modify_routine(
         &self,
         id: RoutineID,
         name: Option<Name>,
         archived: Option<bool>,
         sections: Option<Vec<RoutinePart>>,
-    ) -> Result<Routine, String>;
-    async fn delete_routine(&self, id: RoutineID) -> Result<RoutineID, String>;
+    ) -> Result<Routine, UpdateError>;
+    async fn delete_routine(&self, id: RoutineID) -> Result<RoutineID, DeleteError>;
 }
 
 #[allow(async_fn_in_trait)]
 pub trait TrainingSessionRepository {
-    async fn sync_training_sessions(&self) -> Result<Vec<TrainingSession>, String>;
-    async fn read_training_sessions(&self) -> Result<Vec<TrainingSession>, String>;
+    async fn sync_training_sessions(&self) -> Result<Vec<TrainingSession>, SyncError>;
+    async fn read_training_sessions(&self) -> Result<Vec<TrainingSession>, ReadError>;
     async fn create_training_session(
         &self,
         routine_id: RoutineID,
         date: NaiveDate,
         notes: String,
         elements: Vec<TrainingSessionElement>,
-    ) -> Result<TrainingSession, String>;
+    ) -> Result<TrainingSession, CreateError>;
     async fn modify_training_session(
         &self,
         id: TrainingSessionID,
         notes: Option<String>,
         elements: Option<Vec<TrainingSessionElement>>,
-    ) -> Result<TrainingSession, String>;
+    ) -> Result<TrainingSession, UpdateError>;
     async fn delete_training_session(
         &self,
         id: TrainingSessionID,
-    ) -> Result<TrainingSessionID, String>;
+    ) -> Result<TrainingSessionID, DeleteError>;
+}
+
+#[derive(Error, Debug)]
+pub enum StorageError {
+    #[error("no connection")]
+    NoConnection,
+    #[error("no session")]
+    NoSession,
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
+}
+
+#[derive(Error, Debug)]
+pub enum SyncError {
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
+}
+
+impl From<ReadError> for SyncError {
+    fn from(value: ReadError) -> Self {
+        match value {
+            ReadError::Storage(storage) => SyncError::Storage(storage),
+            ReadError::Other(other) => SyncError::Other(other),
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum ReadError {
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
+}
+
+#[derive(Error, Debug)]
+pub enum CreateError {
+    #[error("conflict")]
+    Conflict,
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
+}
+
+impl From<UpdateError> for CreateError {
+    fn from(value: UpdateError) -> Self {
+        match value {
+            UpdateError::Conflict => CreateError::Conflict,
+            UpdateError::Storage(storage) => CreateError::Storage(storage),
+            UpdateError::Other(other) => CreateError::Other(other),
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum UpdateError {
+    #[error("conflict")]
+    Conflict,
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
+}
+
+#[derive(Error, Debug)]
+pub enum DeleteError {
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error>),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/domain/src/lib.rs

@@ -9,7 +9,7 @@ publish = false
 valens-domain = { path = "../domain" }
 valens-web-app = { path = "../web-app" }
 
-anyhow = "1.0.97"
+anyhow = { workspace = true }
 chrono = { workspace = true, default-features = false, features = ["serde"] }
 gloo-net = { version = "0.6.0", default-features = false, features = ["http", "json"] }
 gloo-storage = "0.3.0"