Merge pull request #103 from refactor-group/more_refactoring

More refactoring

docs/architecture/crate_dependency_graph.md

@@ -0,0 +1,11 @@
+
+This diagram represents the dependency structure of the crates in this project. Each arrow indicates a dependency relationship between the crates. For example, the `web` crate depends on both the `domain` and `service` crates, while the `entity_api` crate depends on the `entity` and `service` crates.
+
+```mermaid
+graph TD;
+    web-->domain;
+    web-->service;
+    domain-->entity_api;
+    entity_api-->entity;
+    entity_api-->service;
+```

domain/Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 
 [dependencies]
 chrono = { version = "0.4.38", features = ["serde"] }
-entity = { path = "../entity" }
 entity_api = { path = "../entity_api" }
 jsonwebtoken = "9"
 service = { path = "../service" }

domain/src/action.rs

@@ -0,0 +1,18 @@
+use crate::actions::Model;
+use crate::error::Error;
+use entity_api::IntoQueryFilterMap;
+use entity_api::{actions, query};
+use sea_orm::DatabaseConnection;
+
+pub use entity_api::action::{create, delete_by_id, find_by_id, update, update_status};
+
+pub async fn find_by(
+    db: &DatabaseConnection,
+    params: impl IntoQueryFilterMap,
+) -> Result<Vec<Model>, Error> {
+    let actions =
+        query::find_by::<actions::Entity, actions::Column>(db, params.into_query_filter_map())
+            .await?;
+
+    Ok(actions)
+}

domain/src/agreement.rs

@@ -1,14 +1,20 @@
+use crate::agreements::Model;
 use crate::error::Error;
-use entity::agreements::Model;
-pub use entity_api::agreement::{create, delete_by_id, find_by_id, update};
-use entity_api::{agreement, IntoQueryFilterMap};
+use entity_api::IntoQueryFilterMap;
+use entity_api::{agreements, query};
 use sea_orm::DatabaseConnection;
 
+pub use entity_api::agreement::{create, delete_by_id, find_by_id, update};
+
 pub async fn find_by(
     db: &DatabaseConnection,
     params: impl IntoQueryFilterMap,
 ) -> Result<Vec<Model>, Error> {
-    let agreements = agreement::find_by(db, params.into_query_filter_map()).await?;
+    let agreements = query::find_by::<agreements::Entity, agreements::Column>(
+        db,
+        params.into_query_filter_map(),
+    )
+    .await?;
 
     Ok(agreements)
 }

domain/src/coaching_relationship.rs

@@ -0,0 +1,23 @@
+use crate::coaching_relationships::Model;
+use crate::error::Error;
+use entity_api::IntoQueryFilterMap;
+use entity_api::{coaching_relationships, query};
+use sea_orm::DatabaseConnection;
+
+pub use entity_api::coaching_relationship::{
+    create, find_by_id, find_by_organization_with_user_names, find_by_user,
+    get_relationship_with_user_names, CoachingRelationshipWithUserNames,
+};
+
+pub async fn find_by(
+    db: &DatabaseConnection,
+    params: impl IntoQueryFilterMap,
+) -> Result<Vec<Model>, Error> {
+    let coaching_relationships = query::find_by::<
+        coaching_relationships::Entity,
+        coaching_relationships::Column,
+    >(db, params.into_query_filter_map())
+    .await?;
+
+    Ok(coaching_relationships)
+}

domain/src/coaching_session.rs

@@ -1,13 +1,18 @@
+use crate::coaching_sessions::Model;
 use crate::error::{DomainErrorKind, Error, ExternalErrorKind, InternalErrorKind};
 use crate::gateway::tiptap::client as tiptap_client;
 use chrono::{DurationRound, TimeDelta};
-use entity::coaching_sessions::Model;
-use entity_api::{coaching_relationship, coaching_session, organization};
+use entity_api::{
+    coaching_relationship, coaching_session, coaching_sessions, organization, query,
+    IntoQueryFilterMap,
+};
 use log::*;
 use sea_orm::DatabaseConnection;
 use serde_json::json;
 use service::config::Config;
 
+pub use entity_api::coaching_session::{find_by_id, find_by_id_with_coaching_relationship};
+
 pub async fn create(
     db: &DatabaseConnection,
     config: &Config,
@@ -82,20 +87,15 @@ pub async fn create(
     }
 }
 
-pub async fn find_by_id(db: &DatabaseConnection, id: entity::Id) -> Result<Model, Error> {
-    Ok(coaching_session::find_by_id(db, id).await?)
-}
-
-pub async fn find_by_id_with_coaching_relationship(
-    db: &DatabaseConnection,
-    id: entity::Id,
-) -> Result<(Model, entity::coaching_relationships::Model), Error> {
-    Ok(coaching_session::find_by_id_with_coaching_relationship(db, id).await?)
-}
-
 pub async fn find_by(
     db: &DatabaseConnection,
-    params: std::collections::HashMap<String, String>,
+    params: impl IntoQueryFilterMap,
 ) -> Result<Vec<Model>, Error> {
-    Ok(coaching_session::find_by(db, params).await?)
+    let coaching_sessions = query::find_by::<coaching_sessions::Entity, coaching_sessions::Column>(
+        db,
+        params.into_query_filter_map(),
+    )
+    .await?;
+
+    Ok(coaching_sessions)
 }

domain/src/jwt/mod.rs

@@ -13,7 +13,7 @@
 //! use domain::jwt::generate_collab_token;
 //! use sea_orm::DatabaseConnection;
 //! use service::config::Config;
-//! use entity::Id;
+//! use crate::Id;
 //!
 //! async fn example(db: &DatabaseConnection, config: &Config, coaching_session_id: Id) {
 //!     match generate_collab_token(db, config, coaching_session_id).await {
@@ -23,18 +23,14 @@
 //! }
 //! ```
 
-use crate::coaching_session;
 use crate::error::{DomainErrorKind, Error, InternalErrorKind};
+use crate::{coaching_session, jwts::Jwt, Id};
 use claims::TiptapCollabClaims;
-use entity::Id;
 use jsonwebtoken::{encode, EncodingKey, Header};
 use log::*;
 use sea_orm::DatabaseConnection;
 use service::config::Config;
 
-// re-export the Jwt struct from the entity module
-pub use entity::jwt::Jwt;
-
 pub(crate) mod claims;
 
 /// Generates a collaboration token for a coaching session.

domain/src/lib.rs

@@ -1,14 +1,27 @@
-//! This module re-exports `IntoQueryFilterMap` and `QueryFilterMap` from the `entity_api` crate.
+//! This module re-exports various items from the `entity_api` crate.
 //!
 //! The purpose of this re-export is to ensure that consumers of the `domain` crate do not need to
 //! directly depend on the `entity_api` crate. By re-exporting these items, we provide a clear and
 //! consistent interface for working with query filters within the domain layer, while encapsulating
 //! the underlying implementation details remain in the `entity_api` crate.
 pub use entity_api::{IntoQueryFilterMap, QueryFilterMap};
 
+// Re-exports from `entity`
+pub use entity_api::user::{AuthSession, Backend, Credentials};
+pub use entity_api::{
+    actions, agreements, coachees, coaches, coaching_relationships, coaching_sessions, jwts, notes,
+    organizations, overarching_goals, users, Id,
+};
+
+pub mod action;
 pub mod agreement;
+pub mod coaching_relationship;
 pub mod coaching_session;
 pub mod error;
 pub mod jwt;
+pub mod note;
+pub mod organization;
+pub mod overarching_goal;
+pub mod user;
 
 pub(crate) mod gateway;

domain/src/note.rs

@@ -0,0 +1 @@
+pub use entity_api::note::{create, find_by, find_by_id, update};

domain/src/organization.rs

@@ -0,0 +1,3 @@
+pub use entity_api::organization::{
+    create, delete_by_id, find_all, find_by, find_by_id, find_by_user, update,
+};

domain/src/overarching_goal.rs

@@ -0,0 +1,20 @@
+use crate::error::Error;
+use crate::overarching_goals::Model;
+use entity_api::IntoQueryFilterMap;
+use entity_api::{overarching_goals, query};
+use sea_orm::DatabaseConnection;
+
+pub use entity_api::overarching_goal::{create, find_by_id, update, update_status};
+
+pub async fn find_by(
+    db: &DatabaseConnection,
+    params: impl IntoQueryFilterMap,
+) -> Result<Vec<Model>, Error> {
+    let overarching_goals = query::find_by::<overarching_goals::Entity, overarching_goals::Column>(
+        db,
+        params.into_query_filter_map(),
+    )
+    .await?;
+
+    Ok(overarching_goals)
+}

domain/src/user.rs

@@ -0,0 +1 @@
+pub use entity_api::user::{create, find_by_email};

entity/src/lib.rs

@@ -8,7 +8,7 @@ pub mod coachees;
 pub mod coaches;
 pub mod coaching_relationships;
 pub mod coaching_sessions;
-pub mod jwt;
+pub mod jwts;
 pub mod notes;
 pub mod organizations;
 pub mod overarching_goals;

entity_api/src/action.rs

@@ -1,13 +1,11 @@
 use super::error::{EntityApiErrorKind, Error};
-use crate::uuid_parse_str;
-use entity::actions::{self, ActiveModel, Entity, Model};
+use entity::actions::{ActiveModel, Entity, Model};
 use entity::{status::Status, Id};
 use sea_orm::{
     entity::prelude::*,
     ActiveValue::{Set, Unchanged},
     DatabaseConnection, TryIntoModel,
 };
-use std::collections::HashMap;
 
 use log::*;
 
@@ -106,68 +104,16 @@ pub async fn update_status(
 pub async fn delete_by_id(db: &DatabaseConnection, id: Id) -> Result<(), Error> {
     let result = find_by_id(db, id).await?;
 
-    match result {
-        Some(action_model) => {
-            debug!("Existing Action model to be deleted: {:?}", action_model);
-
-            action_model.delete(db).await?;
-            Ok(())
-        }
-        None => Err(Error {
-            source: None,
-            error_kind: EntityApiErrorKind::RecordNotFound,
-        }),
-    }
-}
-
-pub async fn find_by_id(db: &DatabaseConnection, id: Id) -> Result<Option<Model>, Error> {
-    match Entity::find_by_id(id).one(db).await {
-        Ok(Some(action)) => {
-            debug!("Action found: {:?}", action);
+    result.delete(db).await?;
 
-            Ok(Some(action))
-        }
-        Ok(None) => {
-            error!("Action with id {} not found", id);
-
-            Err(Error {
-                source: None,
-                error_kind: EntityApiErrorKind::RecordNotFound,
-            })
-        }
-        Err(err) => {
-            error!("Action with id {} not found and returned error {}", id, err);
-            Err(Error {
-                source: None,
-                error_kind: EntityApiErrorKind::RecordNotFound,
-            })
-        }
-    }
+    Ok(())
 }
 
-pub async fn find_by(
-    db: &DatabaseConnection,
-    query_params: HashMap<String, String>,
-) -> Result<Vec<Model>, Error> {
-    let mut query = Entity::find();
-
-    for (key, value) in query_params {
-        match key.as_str() {
-            "coaching_session_id" => {
-                let coaching_session_id = uuid_parse_str(&value)?;
-
-                query = query.filter(actions::Column::CoachingSessionId.eq(coaching_session_id));
-            }
-            _ => {
-                return Err(Error {
-                    source: None,
-                    error_kind: EntityApiErrorKind::InvalidQueryTerm,
-                });
-            }
-        }
-    }
-
-    Ok(query.all(db).await?)
+pub async fn find_by_id(db: &DatabaseConnection, id: Id) -> Result<Model, Error> {
+    Entity::find_by_id(id).one(db).await?.ok_or_else(|| Error {
+        source: None,
+        error_kind: EntityApiErrorKind::RecordNotFound,
+    })
 }
 
 #[cfg(test)]
@@ -178,7 +124,7 @@ pub async fn find_by(
 mod tests {
     use super::*;
     use entity::{actions::Model, Id};
-    use sea_orm::{DatabaseBackend, MockDatabase, Transaction};
+    use sea_orm::{DatabaseBackend, MockDatabase};
 
     #[tokio::test]
     async fn create_returns_a_new_action_model() -> Result<(), Error> {
@@ -286,29 +232,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test]
-    async fn find_by_returns_all_actions_associated_with_coaching_session() -> Result<(), Error> {
-        let db = MockDatabase::new(DatabaseBackend::Postgres).into_connection();
-        let mut query_params = HashMap::new();
-        let coaching_session_id = Id::new_v4();
-
-        query_params.insert(
-            "coaching_session_id".to_owned(),
-            coaching_session_id.to_string(),
-        );
-
-        let _ = find_by(&db, query_params).await;
-
-        assert_eq!(
-            db.into_transaction_log(),
-            [Transaction::from_sql_and_values(
-                DatabaseBackend::Postgres,
-                r#"SELECT "actions"."id", "actions"."coaching_session_id", "actions"."user_id", "actions"."body", "actions"."due_by", CAST("actions"."status" AS text), "actions"."status_changed_at", "actions"."created_at", "actions"."updated_at" FROM "refactor_platform"."actions" WHERE "actions"."coaching_session_id" = $1"#,
-                [coaching_session_id.into()]
-            )]
-        );
-
-        Ok(())
-    }
 }