No longer pass around a DBConnection for EntityApi, but AppState instead

entity_api/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 entity = { path = "../entity" }
+service = { path = "../service" }
 serde_json = "1.0.107"
 log = "0.4.20"
 

entity_api/src/error.rs

@@ -17,6 +17,7 @@ pub struct Error {
 
 #[derive(Debug)]
 pub enum EntityApiErrorType {
+    DatabaseConnectionLost,
     // Record not found
     RecordNotFound,
     // Record not updated
@@ -50,7 +51,7 @@ impl From<DbErr> for Error {
             },
             DbErr::Conn(_) => Error {
                 inner: err,
-                error_type: EntityApiErrorType::SystemError,
+                error_type: EntityApiErrorType::DatabaseConnectionLost,
             },
             DbErr::Exec(_) => Error {
                 inner: err,

entity_api/src/lib.rs

@@ -1,8 +1,8 @@
-use sea_orm::DatabaseConnection;
+use service::AppState;
 
 pub mod error;
 pub mod organization;
 
-pub async fn seed_database(db: &DatabaseConnection) {
-    organization::seed_database(db).await;
+pub async fn seed_database(app_state: &AppState) {
+    organization::seed_database(app_state).await;
 }

entity_api/src/organization.rs

@@ -1,27 +1,32 @@
 use super::error::Error;
 use entity::organization;
 use organization::{Entity, Model};
-use sea_orm::{entity::prelude::*, ActiveValue, DatabaseConnection};
+use sea_orm::{entity::prelude::*, ActiveValue};
 use serde_json::json;
+use service::AppState;
 
-pub async fn find_all(db: &DatabaseConnection) -> Vec<Model> {
+pub async fn find_all(app_state: &AppState) -> Vec<Model> {
+    let db = app_state.database_connection.as_ref().unwrap();
     Entity::find().all(db).await.unwrap_or(vec![])
 }
 
-pub async fn find_by_id(db: &DatabaseConnection, id: i32) -> Result<Option<Model>, Error> {
+pub async fn find_by_id(app_state: &AppState, id: i32) -> Result<Option<Model>, Error> {
+    let db = app_state.database_connection.as_ref().unwrap();
     Entity::find_by_id(id)
         .one(db)
         .await
         .map_err(|err| err.into())
 }
 
-pub(crate) async fn seed_database(db: &DatabaseConnection) {
+pub(crate) async fn seed_database(app_state: &AppState) {
     let organization_names = [
         "Jim Hodapp Coaching",
         "Caleb Coaching",
         "Enterprise Software",
     ];
 
+    let db = app_state.database_connection.as_ref().unwrap();
+
     for name in organization_names {
         let organization = organization::ActiveModel::from_json(json!({
             "name": name,

src/main.rs

@@ -36,7 +36,7 @@ async fn main() {
     let mut app_state = AppState::new(config);
     app_state = service::init_database(app_state).await.unwrap();
 
-    entity_api::seed_database(app_state.database_connection.as_ref().unwrap()).await;
+    entity_api::seed_database(&app_state).await;
 
     web::init_server(app_state).await.unwrap();
 }

web/src/controller/organization_controller.rs

@@ -22,8 +22,7 @@ impl OrganizationController {
     /// --request GET \
     /// http://localhost:4000/organizations
     pub async fn index(State(app_state): State<AppState>) -> impl IntoResponse {
-        let organizations =
-            OrganizationApi::find_all(&app_state.database_connection.unwrap()).await;
+        let organizations = OrganizationApi::find_all(&app_state).await;
 
         Json(organizations)
     }
@@ -36,7 +35,7 @@ impl OrganizationController {
         debug!("GET Organization by id: {}", id);
 
         let organization: Result<Option<organization::Model>, Error> =
-            OrganizationApi::find_by_id(&app_state.database_connection.unwrap(), id)
+            OrganizationApi::find_by_id(&app_state, id)
                 .await
                 .map_err(|err| err.into());
 

web/src/error.rs

@@ -12,6 +12,7 @@ pub type Result<T> = core::result::Result<T, Error>;
 #[derive(Debug, Serialize)]
 
 pub enum Error {
+    DatabaseConnectionLost,
     InternalServer,
     EntityNotFound,
     UnprocessableEntity,
@@ -28,6 +29,11 @@ impl std::fmt::Display for Error {
 impl IntoResponse for Error {
     fn into_response(self) -> Response {
         match self {
+            Error::DatabaseConnectionLost => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "DB CONNECTION LOST - INTERNAL SERVER ERROR",
+            )
+                .into_response(),
             Error::InternalServer => {
                 (StatusCode::INTERNAL_SERVER_ERROR, "INTERNAL SERVER ERROR").into_response()
             }
@@ -42,6 +48,7 @@ impl IntoResponse for Error {
 impl From<EntityApiError> for Error {
     fn from(err: EntityApiError) -> Self {
         match err.error_type {
+            EntityApiErrorType::DatabaseConnectionLost => Error::DatabaseConnectionLost,
             EntityApiErrorType::RecordNotFound => Error::EntityNotFound,
             EntityApiErrorType::RecordNotUpdated => Error::UnprocessableEntity,
             EntityApiErrorType::SystemError => Error::InternalServer,