Phase 2.2: MongoDB connection and models

backend/src/main.rs

@@ -2,13 +2,31 @@ use axum::{
     routing::get,
     Router,
     response::Json,
+    extract::State,
 };
 use serde_json::json;
 use tower_http::trace::TraceLayer;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+use std::sync::Arc;
+
+mod config;
+mod db;
+mod models;
+
+use config::Config;
+use db::MongoDb;
+
+#[derive(Clone)]
+struct AppState {
+    db: Arc<MongoDb>,
+}
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
+    // Load configuration
+    let config = Config::from_env()?;
+    
+    // Initialize tracing
     tracing_subscriber::registry()
         .with(
             tracing_subscriber::EnvFilter::try_from_default_env()
@@ -18,22 +36,39 @@ async fn main() {
         .init();
 
     tracing::info!("Starting Normogen backend server");
+    tracing::info!("MongoDB URI: {}", config.database.uri);
+    tracing::info!("Database: {}", config.database.database);
+
+    // Connect to MongoDB
+    let mongodb = MongoDb::new(&config.database.uri, &config.database.database).await?;
+    tracing::info!("Connected to MongoDB");
+
+    // Health check
+    let health_status = mongodb.health_check().await?;
+    tracing::info!("MongoDB health: {}", health_status);
+
+    let app_state = AppState {
+        db: Arc::new(mongodb),
+    };
 
     let app = Router::new()
         .route("/health", get(health_check))
         .route("/ready", get(readiness_check))
+        .with_state(app_state)
         .layer(TraceLayer::new_for_http());
 
-    let addr = std::net::SocketAddr::from(([0, 0, 0, 0], 8000));
+    let addr = format!("{}:{}", config.server.host, config.server.port);
     tracing::info!("Listening on {}", addr);
     
-    let listener = tokio::net::TcpListener::bind(addr)
+    let listener = tokio::net::TcpListener::bind(&addr)
         .await
         .expect("Failed to bind address");
     
     axum::serve(listener, app)
         .await
         .expect("Server error");
+        
+    Ok(())
 }
 
 async fn health_check() -> Json<serde_json::Value> {
@@ -43,10 +78,12 @@ async fn health_check() -> Json<serde_json::Value> {
     }))
 }
 
-async fn readiness_check() -> Json<serde_json::Value> {
+async fn readiness_check(State(state): State<AppState>) -> Json<serde_json::Value> {
+    let db_status = state.db.health_check().await.unwrap_or_else(|_| "disconnected".to_string());
+    
     Json(json!({
         "status": "ready",
-        "database": "not_connected",
+        "database": db_status,
         "timestamp": chrono::Utc::now().to_rfc3339(),
     }))
 }