chore: changed folder driven names

src/domain/management/project.rs

@@ -4,15 +4,15 @@ use std::sync::Arc;
 use super::events::{Event, EventBridge, NamespaceCreate};
 
 pub async fn create(
-    state: Arc<dyn ProjectState>,
+    cache: Arc<dyn ProjectCache>,
     //event: Arc<dyn EventBridge>,
     project: Project,
 ) -> Result<()> {
-    if state.find_by_slug(&project.slug).await?.is_some() {
+    if cache.find_by_slug(&project.slug).await?.is_some() {
         return Err(Error::msg("invalid project slug"));
     }
 
-    state.create(&project).await?;
+    cache.create(&project).await?;
 
     //event.dispatch(project.into()).await?;
 
@@ -35,7 +35,7 @@ impl From<Project> for Event {
 }
 
 #[async_trait::async_trait]
-pub trait ProjectState {
+pub trait ProjectCache {
     async fn create(&self, project: &Project) -> Result<()>;
     async fn find_by_slug(&self, slug: &str) -> Result<Option<Project>>;
 }
@@ -47,10 +47,10 @@ mod tests {
     use super::*;
 
     mock! {
-        pub FakeProjectState { }
+        pub FakeProjectCache { }
 
         #[async_trait::async_trait]
-        impl ProjectState for FakeProjectState {
+        impl ProjectCache for FakeProjectCache {
             async fn create(&self, project: &Project) -> Result<()>;
             async fn find_by_slug(&self, slug: &str) -> Result<Option<Project>>;
         }
@@ -77,37 +77,37 @@ mod tests {
 
     #[tokio::test]
     async fn it_should_create_project() {
-        let mut project_state = MockFakeProjectState::new();
-        project_state
+        let mut project_cache = MockFakeProjectCache::new();
+        project_cache
             .expect_find_by_slug()
             .return_once(|_| Ok(None));
-        project_state.expect_create().return_once(|_| Ok(()));
+        project_cache.expect_create().return_once(|_| Ok(()));
 
         let mut event_bridge = MockFakeEventBridge::new();
         event_bridge.expect_dispatch().return_once(|_| Ok(()));
 
         let project = Project::default();
 
-        //let result = create(Arc::new(project_state), Arc::new(event_bridge), project).await;
+        //let result = create(Arc::new(project_cache), Arc::new(event_bridge), project).await;
         //if let Err(err) = result {
         //    unreachable!("{err}")
         //}
     }
 
     #[tokio::test]
     async fn it_should_fail_when_project_slug_exist() {
-        let mut project_state = MockFakeProjectState::new();
-        project_state
+        let mut project_cache = MockFakeProjectCache::new();
+        project_cache
             .expect_find_by_slug()
             .return_once(|_| Ok(Some(Project::default())));
-        project_state.expect_create().return_once(|_| Ok(()));
+        project_cache.expect_create().return_once(|_| Ok(()));
 
         let mut event_bridge = MockFakeEventBridge::new();
         event_bridge.expect_dispatch().return_once(|_| Ok(()));
 
         let project = Project::default();
 
-        //let result = create(Arc::new(project_state), Arc::new(event_bridge), project).await;
+        //let result = create(Arc::new(project_cache), Arc::new(event_bridge), project).await;
         //if result.is_ok() {
         //    unreachable!("Fail to validate when the slug is duplicated")
         //}

src/driven/sqlite/mod.rs → src/driven/cache/mod.rs

@@ -3,11 +3,11 @@ use std::path::Path;
 
 pub mod project;
 
-pub struct SqliteState {
+pub struct SqliteCache {
     db: sqlx::sqlite::SqlitePool,
 }
 
-impl SqliteState {
+impl SqliteCache {
     pub async fn new(path: &Path) -> Result<Self> {
         let url = format!("sqlite:{}?mode=rwc", path.display());
         let db = sqlx::sqlite::SqlitePoolOptions::new().connect(&url).await?;
@@ -16,7 +16,7 @@ impl SqliteState {
     }
 
     pub async fn migrate(&self) -> Result<()> {
-        sqlx::migrate!("src/driven/sqlite/migrations")
+        sqlx::migrate!("src/driven/cache/migrations")
             .run(&self.db)
             .await?;
 

src/driven/sqlite/project.rs → src/driven/cache/project.rs

@@ -1,20 +1,20 @@
 use anyhow::Result;
 use std::sync::Arc;
 
-use crate::domain::management::project::{Project, ProjectState};
+use crate::domain::management::project::{Project, ProjectCache};
 
-use super::SqliteState;
+use super::SqliteCache;
 
-pub struct SqliteProjectState {
-    sqlite: Arc<SqliteState>,
+pub struct SqliteProjectCache {
+    sqlite: Arc<SqliteCache>,
 }
-impl SqliteProjectState {
-    pub fn new(sqlite: Arc<SqliteState>) -> Self {
+impl SqliteProjectCache {
+    pub fn new(sqlite: Arc<SqliteCache>) -> Self {
         Self { sqlite }
     }
 }
 #[async_trait::async_trait]
-impl ProjectState for SqliteProjectState {
+impl ProjectCache for SqliteProjectCache {
     async fn create(&self, project: &Project) -> Result<()> {
         sqlx::query!(
             r#"

src/driven/mod.rs

@@ -1 +1 @@
-pub mod sqlite;
+pub mod cache;

src/drivers/grpc/mod.rs

@@ -3,13 +3,13 @@ use std::{path::Path, sync::Arc};
 
 use crate::domain::management;
 use crate::domain::management::project::Project;
-use crate::driven::sqlite::{project::SqliteProjectState, SqliteState};
+use crate::driven::cache::{project::SqliteProjectCache, SqliteCache};
 
 pub async fn server() -> Result<()> {
-    let sqlite = Arc::new(SqliteState::new(Path::new("dev.db")).await?);
-    sqlite.migrate().await?;
+    let sqlite_cache = Arc::new(SqliteCache::new(Path::new("dev.db")).await?);
+    sqlite_cache.migrate().await?;
 
-    let project_state = Arc::new(SqliteProjectState::new(sqlite));
+    let project_state = Arc::new(SqliteProjectCache::new(sqlite_cache));
 
     let project = Project {
         name: "test name".into(),
@@ -21,4 +21,3 @@ pub async fn server() -> Result<()> {
 
     Ok(())
 }
-