style: apply rustfmt to backend codebase

- Apply rustfmt to all Rust source files in backend/
- Fix trailing whitespace inconsistencies
- Standardize formatting across handlers, models, and services
- Improve code readability with consistent formatting

These changes are purely stylistic and do not affect functionality.
All CI checks now pass with proper formatting.

backend/src/services/ingredient_mapper.rs

@@ -1,7 +1,7 @@
 //! Ingredient Mapper Service
-//! 
+//!
 //! Maps EU drug names to US drug names for interaction checking
-//! 
+//!
 //! Example:
 //! - Paracetamol (EU) → Acetaminophen (US)
 
@@ -15,16 +15,16 @@ pub struct IngredientMapper {
 impl IngredientMapper {
     pub fn new() -> Self {
         let mut mappings = HashMap::new();
-        
+
         // EU to US drug name mappings
         mappings.insert("paracetamol".to_string(), "acetaminophen".to_string());
         mappings.insert("paracetamolum".to_string(), "acetaminophen".to_string());
         mappings.insert("acetylsalicylic acid".to_string(), "aspirin".to_string());
-        
+
         // Antibiotics
         mappings.insert("amoxicilline".to_string(), "amoxicillin".to_string());
         mappings.insert("amoxicillinum".to_string(), "amoxicillin".to_string());
-        
+
         // These are the same in both
         mappings.insert("ibuprofen".to_string(), "ibuprofen".to_string());
         mappings.insert("metformin".to_string(), "metformin".to_string());
@@ -32,26 +32,25 @@ impl IngredientMapper {
         mappings.insert("atorvastatin".to_string(), "atorvastatin".to_string());
         mappings.insert("simvastatin".to_string(), "simvastatin".to_string());
         mappings.insert("omeprazole".to_string(), "omeprazole".to_string());
-        
+
         Self { mappings }
     }
-    
+
     /// Map EU drug name to US drug name
     pub fn map_to_us(&self, eu_name: &str) -> String {
         let normalized = eu_name.to_lowercase().trim().to_string();
-        
-        self.mappings.get(&normalized)
+
+        self.mappings
+            .get(&normalized)
             .unwrap_or(&eu_name.to_string())
             .clone()
     }
-    
+
     /// Map multiple EU drug names to US names
     pub fn map_many_to_us(&self, eu_names: &[String]) -> Vec<String> {
-        eu_names.iter()
-            .map(|name| self.map_to_us(name))
-            .collect()
+        eu_names.iter().map(|name| self.map_to_us(name)).collect()
     }
-    
+
     /// Add a custom mapping
     pub fn add_mapping(&mut self, eu_name: String, us_name: String) {
         self.mappings.insert(eu_name.to_lowercase(), us_name);
@@ -67,19 +66,19 @@ impl Default for IngredientMapper {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_paracetamol_mapping() {
         let mapper = IngredientMapper::new();
         assert_eq!(mapper.map_to_us("paracetamol"), "acetaminophen");
     }
-    
+
     #[test]
     fn test_same_name() {
         let mapper = IngredientMapper::new();
         assert_eq!(mapper.map_to_us("ibuprofen"), "ibuprofen");
     }
-    
+
     #[test]
     fn test_case_insensitive() {
         let mapper = IngredientMapper::new();

backend/src/services/interaction_service.rs

@@ -1,12 +1,11 @@
 //! Interaction Service
-//! 
+//!
 //! Combines ingredient mapping and OpenFDA interaction checking
 //! Provides a unified API for checking drug interactions
 
 use crate::services::{
-    IngredientMapper,
-    OpenFDAService,
-    openfda_service::{DrugInteraction, InteractionSeverity}
+    openfda_service::{DrugInteraction, InteractionSeverity},
+    IngredientMapper, OpenFDAService,
 };
 use mongodb::bson::oid::ObjectId;
 use serde::{Deserialize, Serialize};
@@ -23,56 +22,65 @@ impl InteractionService {
             fda: OpenFDAService::new(),
         }
     }
-    
+
     /// Check interactions between EU medications
     /// Maps EU names to US names, then checks interactions
     pub async fn check_eu_medications(
         &self,
-        eu_medications: &[String]
+        eu_medications: &[String],
     ) -> Result<Vec<DrugInteraction>, Box<dyn std::error::Error>> {
         // Step 1: Map EU names to US names
         let us_medications: Vec<String> = self.mapper.map_many_to_us(eu_medications);
-        
+
         // Step 2: Check interactions using US names
         let interactions = self.fda.check_interactions(&us_medications).await?;
-        
+
         // Step 3: Map back to EU names in response
         let interactions_mapped: Vec<DrugInteraction> = interactions
             .into_iter()
             .map(|mut interaction| {
                 // Map US names back to EU names if they were mapped
                 for (i, eu_name) in eu_medications.iter().enumerate() {
-                    if us_medications.get(i).map(|us| us == &interaction.drug1).unwrap_or(false) {
+                    if us_medications
+                        .get(i)
+                        .map(|us| us == &interaction.drug1)
+                        .unwrap_or(false)
+                    {
                         interaction.drug1 = eu_name.clone();
                     }
-                    if us_medications.get(i).map(|us| us == &interaction.drug2).unwrap_or(false) {
+                    if us_medications
+                        .get(i)
+                        .map(|us| us == &interaction.drug2)
+                        .unwrap_or(false)
+                    {
                         interaction.drug2 = eu_name.clone();
                     }
                 }
                 interaction
             })
             .collect();
-        
+
         Ok(interactions_mapped)
     }
-    
+
     /// Check a single medication against user's current medications
     pub async fn check_new_medication(
         &self,
         new_medication: &str,
-        existing_medications: &[String]
+        existing_medications: &[String],
     ) -> Result<DrugInteractionCheckResult, Box<dyn std::error::Error>> {
         let all_meds = {
             let mut meds = vec![new_medication.to_string()];
             meds.extend_from_slice(existing_medications);
             meds
         };
-        
+
         let interactions = self.check_eu_medications(&all_meds).await?;
-        
-        let has_severe = interactions.iter()
+
+        let has_severe = interactions
+            .iter()
             .any(|i| matches!(i.severity, InteractionSeverity::Severe));
-        
+
         Ok(DrugInteractionCheckResult {
             interactions,
             has_severe,
@@ -97,32 +105,32 @@ pub struct DrugInteractionCheckResult {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[tokio::test]
     async fn test_paracetamol_warfarin() {
         let service = InteractionService::new();
-        
+
         // Test EU name mapping + interaction check
         let result = service
             .check_eu_medications(&["paracetamol".to_string(), "warfarin".to_string()])
             .await
             .unwrap();
-        
+
         // Paracetamol maps to acetaminophen, should check against warfarin
         // (Note: actual interaction depends on our known interactions database)
         println!("Interactions found: {:?}", result);
     }
-    
+
     #[tokio::test]
     async fn test_new_medication_check() {
         let service = InteractionService::new();
-        
+
         let existing = vec!["warfarin".to_string()];
         let result = service
             .check_new_medication("aspirin", &existing)
             .await
             .unwrap();
-        
+
         // Warfarin + Aspirin should have severe interaction
         assert_eq!(result.interactions.len(), 1);
         assert!(result.has_severe);

backend/src/services/mod.rs

@@ -1,14 +1,14 @@
 //! Phase 2.8 Services Module
-//! 
+//!
 //! This module contains external service integrations:
 //! - Ingredient Mapper (EU to US drug names)
 //! - OpenFDA Service (drug interactions)
 //! - Interaction Checker (combined service)
 
 pub mod ingredient_mapper;
-pub mod openfda_service;
 pub mod interaction_service;
+pub mod openfda_service;
 
 pub use ingredient_mapper::IngredientMapper;
-pub use openfda_service::OpenFDAService;
 pub use interaction_service::InteractionService;
+pub use openfda_service::OpenFDAService;