add repositories

Signed-off-by: simonsan <[email protected]>

crates/error/src/lib.rs

@@ -293,6 +293,26 @@ pub enum DatabaseStorageErrorKind {
         #[source]
         source: sea_orm::error::SqlErr,
     },
+
+    /// Failed to read item {item_type}::{item_id} from database: {source}
+    RepositoryReadFailed {
+        source: sea_orm::DbErr,
+        item_type: String,
+        item_id: String,
+    },
+
+    /// Failed to delete item {item_type}::{item_id} from database: {source}
+    RepositoryDeleteFailed {
+        source: sea_orm::prelude::DbErr,
+        item_type: String,
+        item_id: String,
+    },
+
+    /// Failed to create item {item_type} in database: {source}
+    RepositoryCreateFailed {
+        source: sea_orm::prelude::DbErr,
+        item_type: String,
+    },
 }
 
 /// [`TomlFileStorageErrorKind`] describes the errors that can happen while dealing with the Toml file storage.

crates/storage/src/migration/m20240325_000001_create_activities.rs

@@ -45,6 +45,26 @@ impl MigrationTrait for Migration {
                     )
                     .to_owned(),
             )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .table(Activities::Table)
+                    .name("idx_activities_parent_guid")
+                    .col(Activities::ParentGuid)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .table(Activities::Table)
+                    .name("idx_activities_description")
+                    .col(Activities::Description)
+                    .to_owned(),
+            )
             .await
     }
 

crates/storage/src/migration/m20240326_000001_create_tags.rs

@@ -17,6 +17,16 @@ impl MigrationTrait for Migration {
                     .col(ColumnDef::new(Tags::Tag).text().not_null())
                     .to_owned(),
             )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .table(Tags::Table)
+                    .name("idx_tags_tag")
+                    .col(Tags::Tag)
+                    .to_owned(),
+            )
             .await
     }
 

crates/storage/src/migration/m20240326_000002_create_categories.rs

@@ -23,6 +23,16 @@ impl MigrationTrait for Migration {
                     .col(ColumnDef::new(Categories::Description).text().null())
                     .to_owned(),
             )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .table(Categories::Table)
+                    .name("idx_categories_category")
+                    .col(Categories::Category)
+                    .to_owned(),
+            )
             .await
     }
 

crates/storage/src/repository.rs

@@ -1,8 +1,10 @@
+pub mod activity;
 pub mod category;
+pub mod tag;
 
 use pace_error::{PaceOptResult, PaceResult};
 
-pub trait Repository<T> {
+pub(crate) trait Repository<T> {
     /// Read a single entity by its id.
     ///
     /// # Arguments
@@ -16,7 +18,7 @@ pub trait Repository<T> {
     /// # Returns
     ///
     /// Returns the entity if it exists or None if it does not.
-    fn read(&self, id: &str) -> PaceOptResult<T>;
+    async fn read(&self, id: &str) -> PaceOptResult<T>;
 
     /// Read all entities of a given type.
     ///
@@ -28,7 +30,7 @@ pub trait Repository<T> {
     ///
     /// Returns a vector of all entities of the given type or an
     /// empty vector if there are none.
-    fn read_all(&self) -> PaceOptResult<Vec<T>>;
+    async fn read_all(&self) -> PaceOptResult<Vec<T>>;
 
     /// Create a new entity of a given type.
     ///
@@ -43,7 +45,7 @@ pub trait Repository<T> {
     /// # Returns
     ///
     /// Returns the id of the created entity.
-    fn create(&self, entity: &T) -> PaceResult<String>;
+    async fn create(&self, model: &T) -> PaceResult<String>;
 
     /// Update an existing entity of a given type.
     ///
@@ -59,7 +61,7 @@ pub trait Repository<T> {
     /// # Returns
     ///
     /// Returns nothing if the entity was updated successfully.
-    fn update(&self, id: &str, entity: &T) -> PaceResult<()>;
+    async fn update(&self, id: &str, model: &T) -> PaceResult<()>;
 
     /// Delete an existing entity of a given type.
     ///
@@ -70,5 +72,26 @@ pub trait Repository<T> {
     /// # Errors
     ///
     /// Returns an error if there was a problem deleting the entity.
-    fn delete(&self, id: &str) -> PaceResult<()>;
+    ///
+    /// # Returns
+    ///
+    /// Returns the deleted entity if it exists.
+    async fn delete(&self, id: &str) -> PaceOptResult<T>;
+}
+
+pub struct SeaOrmRepository<'conn> {
+    activity: activity::ActivityRepository<'conn, sea_orm::DatabaseConnection>,
+    category: category::CategoryRepository<'conn, sea_orm::DatabaseConnection>,
+    tag: tag::TagRepository<'conn, sea_orm::DatabaseConnection>,
+}
+
+impl<'conn> SeaOrmRepository<'conn> {
+    #[must_use]
+    pub const fn new(connection: &'conn sea_orm::DatabaseConnection) -> Self {
+        Self {
+            activity: activity::ActivityRepository::new(connection),
+            category: category::CategoryRepository::new(connection),
+            tag: tag::TagRepository::new(connection),
+        }
+    }
 }

crates/storage/src/repository/activity.rs

@@ -0,0 +1,81 @@
+use pace_error::{DatabaseStorageErrorKind, PaceOptResult, PaceResult};
+use sea_orm::{EntityTrait, IntoActiveModel};
+
+use crate::entity::activities::{Entity as ActivityEntity, Model as ActivityModel};
+use crate::repository::Repository;
+
+pub struct ActivityRepository<'conn, C> {
+    connection: &'conn C,
+}
+
+impl<'conn, C> ActivityRepository<'conn, C> {
+    pub const fn new(connection: &'conn C) -> Self {
+        Self { connection }
+    }
+}
+
+impl<'conn> Repository<ActivityModel> for ActivityRepository<'conn, sea_orm::DatabaseConnection> {
+    async fn read(&self, id: &str) -> PaceOptResult<ActivityModel> {
+        Ok(ActivityEntity::find_by_id(id)
+            .one(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryReadFailed {
+                source,
+                item_type: "activity".to_string(),
+                item_id: id.to_string(),
+            })?)
+    }
+
+    async fn read_all(&self) -> PaceOptResult<Vec<ActivityModel>> {
+        let items = ActivityEntity::find()
+            .all(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryReadFailed {
+                source,
+                item_type: "activity".to_string(),
+                item_id: "all".to_string(),
+            })?;
+
+        if items.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(items))
+    }
+
+    async fn create(&self, model: &ActivityModel) -> PaceResult<String> {
+        // TODO: What else should we do with ActiveModel here?
+        let active_model = model.clone().into_active_model();
+
+        let id = ActivityEntity::insert(active_model)
+            .exec(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryCreateFailed {
+                source,
+                item_type: "activity".to_string(),
+            })?
+            .last_insert_id;
+
+        Ok(id)
+    }
+
+    async fn update(&self, id: &str, model: &ActivityModel) -> PaceResult<()> {
+        unimplemented!()
+    }
+
+    async fn delete(&self, id: &str) -> PaceOptResult<ActivityModel> {
+        let item = self.read(id).await?;
+
+        // TODO: Unused result here, what should we do with the rows affected?
+        _ = ActivityEntity::delete_by_id(id)
+            .exec(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryDeleteFailed {
+                source,
+                item_type: "activity".to_string(),
+                item_id: id.to_string(),
+            })?;
+
+        Ok(item)
+    }
+}

crates/storage/src/repository/category.rs

@@ -1,32 +1,81 @@
-use pace_error::{PaceOptResult, PaceResult};
-use sea_orm::{sea_query::Query, DatabaseConnection};
+use pace_error::{DatabaseStorageErrorKind, PaceOptResult, PaceResult};
+use sea_orm::{EntityTrait, IntoActiveModel};
 
 use crate::entity::categories::{Entity as CategoryEntity, Model as CategoryModel};
-use crate::entity::tags::Entity as TagEntity;
 use crate::repository::Repository;
 
-pub struct CategoryRepository {
-    connection: DatabaseConnection,
+pub struct CategoryRepository<'conn, C> {
+    connection: &'conn C,
 }
 
-impl Repository<CategoryEntity> for CategoryRepository {
-    fn read(&self, id: &str) -> PaceOptResult<CategoryEntity> {
-        unimplemented!()
+impl<'conn, C> CategoryRepository<'conn, C> {
+    pub const fn new(connection: &'conn C) -> Self {
+        Self { connection }
     }
+}
 
-    fn read_all(&self) -> PaceOptResult<Vec<CategoryEntity>> {
-        unimplemented!()
+impl<'conn> Repository<CategoryModel> for CategoryRepository<'conn, sea_orm::DatabaseConnection> {
+    async fn read(&self, id: &str) -> PaceOptResult<CategoryModel> {
+        Ok(CategoryEntity::find_by_id(id)
+            .one(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryReadFailed {
+                source,
+                item_type: "category".to_string(),
+                item_id: id.to_string(),
+            })?)
     }
 
-    fn create(&self, entity: &CategoryEntity) -> PaceResult<String> {
-        unimplemented!()
+    async fn read_all(&self) -> PaceOptResult<Vec<CategoryModel>> {
+        let items = CategoryEntity::find()
+            .all(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryReadFailed {
+                source,
+                item_type: "category".to_string(),
+                item_id: "all".to_string(),
+            })?;
+
+        if items.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(items))
     }
 
-    fn update(&self, id: &str, entity: &CategoryEntity) -> PaceResult<()> {
-        unimplemented!()
+    async fn create(&self, model: &CategoryModel) -> PaceResult<String> {
+        // TODO: What else should we do with ActiveModel here?
+        let active_model = model.clone().into_active_model();
+
+        let id = CategoryEntity::insert(active_model)
+            .exec(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryCreateFailed {
+                source,
+                item_type: "category".to_string(),
+            })?
+            .last_insert_id;
+
+        Ok(id)
     }
 
-    fn delete(&self, id: &str) -> PaceResult<()> {
+    async fn update(&self, id: &str, model: &CategoryModel) -> PaceResult<()> {
         unimplemented!()
     }
+
+    async fn delete(&self, id: &str) -> PaceOptResult<CategoryModel> {
+        let item = self.read(id).await?;
+
+        // TODO: Unused result here, what should we do with the rows affected?
+        _ = CategoryEntity::delete_by_id(id)
+            .exec(self.connection)
+            .await
+            .map_err(|source| DatabaseStorageErrorKind::RepositoryDeleteFailed {
+                source,
+                item_type: "category".to_string(),
+                item_id: id.to_string(),
+            })?;
+
+        Ok(item)
+    }
 }