Merge #240: refactor: improve database configuration type safety and module organization

b2bf805 refactor: extract driver name constants in domain database module (Jose Celano)
21d9254 refactor: convert docker_compose context to directory module with builder improvements (Jose Celano)
bc39c9c refactor: rename DockerComposeContextBuilder::new to with_sqlite (Jose Celano)
b97d446 refactor: rename MysqlConfig to MysqlSetupConfig in docker_compose context (Jose Celano)
634a1e7 refactor: convert database.rs into folder module with separate driver modules (Jose Celano)
0057ea3 refactor: extract SqliteConfig and MysqlConfig from DatabaseConfig enum (Jose Celano)

Pull request description:

  ## Summary

  This PR refactors the database configuration structure across the application to improve type safety, eliminate magic strings, and enhance module organization.

  ## Changes

  ### 1. Database Configuration Type Extraction
  - Extracted `SqliteConfig` and `MysqlConfig` from the `DatabaseConfig` enum
  - Converted `database.rs` to `database/` folder module with separate driver modules
  - Improved type safety and modularity

  ### 2. Infrastructure Layer Improvements
  - Renamed `MysqlConfig` → `MysqlSetupConfig` in docker_compose context (clearer naming for initialization)
  - Converted `docker_compose/context.rs` to directory module with submodules:
    - `builder.rs` - Builder pattern implementation
    - `database.rs` - Database configuration and constants
    - `ports.rs` - Port configuration
  - Renamed `DockerComposeContextBuilder::with_sqlite()` → `::new()` (SQLite is the default)

  ### 3. Builder API Enhancements
  - Simplified `with_mysql()` to accept `MysqlSetupConfig` struct instead of 5 individual parameters
  - Extracted driver name constants: `DRIVER_SQLITE = "sqlite3"`, `DRIVER_MYSQL = "mysql"`
  - Eliminated magic strings throughout the codebase

  ### 4. Domain Layer Consistency
  - Added driver name constants to `domain/tracker/database/mod.rs`
  - Updated `driver_name()` method to use constants
  - Ensures consistency between domain and infrastructure layers

  ## Testing

  All pre-commit checks passed:
  - ✅ 1,515 unit tests
  - ✅ 8 E2E integration tests
  - ✅ 373 doctests
  - ✅ Linting (clippy, rustfmt, shellcheck, markdown, yaml, toml, cspell)
  - ✅ E2E infrastructure lifecycle tests
  - ✅ E2E deployment workflow tests

  ## Benefits

  - **Type Safety**: Stronger typing with dedicated config structs
  - **Maintainability**: Eliminated magic strings with constants
  - **Clarity**: Better module organization and clearer naming
  - **Consistency**: Unified approach across domain and infrastructure layers
  - **Usability**: Simpler builder API with struct parameters

  ## Migration

  No breaking changes for end users. Internal refactoring only.

ACKs for top commit:
  josecelano:
    ACK b2bf805

Tree-SHA512: 6fe279891b0a28b212938a33e91fe38f0f5b4dcb1c6bc6b92e22069bcbbb6032e1416aa989436853f0c317e8eee837025d412e3d5bccb32d212e8803b52cd8db

Author: josecelano

src/application/command_handlers/create/config/tracker/tracker_core_section.rs

@@ -8,7 +8,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::application::command_handlers::create::config::errors::CreateConfigError;
-use crate::domain::tracker::{DatabaseConfig, TrackerCoreConfig};
+use crate::domain::tracker::{DatabaseConfig, MysqlConfig, SqliteConfig, TrackerCoreConfig};
 
 /// Database configuration section (application DTO)
 ///
@@ -69,22 +69,22 @@ impl DatabaseSection {
     /// future validation.
     pub fn to_database_config(&self) -> Result<DatabaseConfig, CreateConfigError> {
         match self {
-            Self::Sqlite { database_name } => Ok(DatabaseConfig::Sqlite {
+            Self::Sqlite { database_name } => Ok(DatabaseConfig::Sqlite(SqliteConfig {
                 database_name: database_name.clone(),
-            }),
+            })),
             Self::Mysql {
                 host,
                 port,
                 database_name,
                 username,
                 password,
-            } => Ok(DatabaseConfig::Mysql {
+            } => Ok(DatabaseConfig::Mysql(MysqlConfig {
                 host: host.clone(),
                 port: *port,
                 database_name: database_name.clone(),
                 username: username.clone(),
                 password: password.clone(),
-            }),
+            })),
         }
     }
 }
@@ -143,9 +143,9 @@ mod tests {
 
         assert_eq!(
             config.database,
-            DatabaseConfig::Sqlite {
+            DatabaseConfig::Sqlite(SqliteConfig {
                 database_name: "tracker.db".to_string()
-            }
+            })
         );
         assert!(!config.private);
     }
@@ -217,13 +217,13 @@ mod tests {
 
         assert_eq!(
             config.database,
-            DatabaseConfig::Mysql {
+            DatabaseConfig::Mysql(MysqlConfig {
                 host: "localhost".to_string(),
                 port: 3306,
                 database_name: "tracker".to_string(),
                 username: "tracker_user".to_string(),
                 password: "secure_password".to_string(),
-            }
+            })
         );
         assert!(!config.private);
     }

src/application/command_handlers/create/config/tracker/tracker_section.rs

@@ -123,7 +123,7 @@ mod tests {
 
     use super::*;
     use crate::application::command_handlers::create::config::tracker::tracker_core_section::DatabaseSection;
-    use crate::domain::tracker::DatabaseConfig;
+    use crate::domain::tracker::{DatabaseConfig, SqliteConfig};
 
     #[test]
     fn it_should_convert_to_domain_config_when_transforming_tracker_section() {
@@ -150,9 +150,9 @@ mod tests {
 
         assert_eq!(
             config.core.database,
-            DatabaseConfig::Sqlite {
+            DatabaseConfig::Sqlite(SqliteConfig {
                 database_name: "tracker.db".to_string()
-            }
+            })
         );
         assert!(!config.core.private);
         assert_eq!(config.udp_trackers.len(), 1);

src/application/steps/rendering/docker_compose_templates.rs

@@ -33,7 +33,7 @@ use crate::domain::environment::Environment;
 use crate::domain::template::TemplateManager;
 use crate::domain::tracker::{DatabaseConfig, TrackerConfig};
 use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
-    DockerComposeContext, DockerComposeContextBuilder, TrackerPorts,
+    DockerComposeContext, DockerComposeContextBuilder, MysqlSetupConfig, TrackerPorts,
 };
 use crate::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
 use crate::infrastructure::templating::docker_compose::{
@@ -111,20 +111,14 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         // Create contexts based on database configuration
         let database_config = self.environment.database_config();
         let (env_context, builder) = match database_config {
-            DatabaseConfig::Sqlite { .. } => Self::create_sqlite_contexts(admin_token, ports),
-            DatabaseConfig::Mysql {
-                port,
-                database_name,
-                username,
-                password,
-                ..
-            } => Self::create_mysql_contexts(
+            DatabaseConfig::Sqlite(..) => Self::create_sqlite_contexts(admin_token, ports),
+            DatabaseConfig::Mysql(mysql_config) => Self::create_mysql_contexts(
                 admin_token,
                 ports,
-                *port,
-                database_name.clone(),
-                username.clone(),
-                password.clone(),
+                mysql_config.port,
+                mysql_config.database_name.clone(),
+                mysql_config.username.clone(),
+                mysql_config.password.clone(),
             ),
         };
 
@@ -191,13 +185,15 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             password.clone(),
         );
 
-        let builder = DockerComposeContext::builder(ports).with_mysql(
+        let mysql_config = MysqlSetupConfig {
             root_password,
-            database_name,
-            username,
+            database: database_name,
+            user: username,
             password,
             port,
-        );
+        };
+
+        let builder = DockerComposeContext::builder(ports).with_mysql(mysql_config);
 
         (env_context, builder)
     }

src/domain/environment/mod.rs

@@ -127,8 +127,8 @@ pub use user_inputs::UserInputs;
 
 // Re-export tracker types for convenience
 pub use crate::domain::tracker::{
-    DatabaseConfig, HttpApiConfig, HttpTrackerConfig, TrackerConfig, TrackerCoreConfig,
-    UdpTrackerConfig,
+    DatabaseConfig, HttpApiConfig, HttpTrackerConfig, MysqlConfig, SqliteConfig, TrackerConfig,
+    TrackerCoreConfig, UdpTrackerConfig,
 };
 
 // Re-export Prometheus types for convenience

src/domain/tracker/config.rs

@@ -7,7 +7,7 @@ use std::net::SocketAddr;
 
 use serde::{Deserialize, Serialize};
 
-use super::DatabaseConfig;
+use super::{DatabaseConfig, SqliteConfig};
 
 /// Tracker deployment configuration
 ///
@@ -18,15 +18,15 @@ use super::DatabaseConfig;
 ///
 /// ```rust
 /// use torrust_tracker_deployer_lib::domain::tracker::{
-///     TrackerConfig, TrackerCoreConfig, DatabaseConfig,
+///     TrackerConfig, TrackerCoreConfig, DatabaseConfig, SqliteConfig,
 ///     UdpTrackerConfig, HttpTrackerConfig, HttpApiConfig
 /// };
 ///
 /// let tracker_config = TrackerConfig {
 ///     core: TrackerCoreConfig {
-///         database: DatabaseConfig::Sqlite {
+///         database: DatabaseConfig::Sqlite(SqliteConfig {
 ///             database_name: "tracker.db".to_string(),
-///         },
+///         }),
 ///         private: false,
 ///     },
 ///     udp_trackers: vec![
@@ -116,9 +116,9 @@ impl Default for TrackerConfig {
     fn default() -> Self {
         Self {
             core: TrackerCoreConfig {
-                database: DatabaseConfig::Sqlite {
+                database: DatabaseConfig::Sqlite(SqliteConfig {
                     database_name: "tracker.db".to_string(),
-                },
+                }),
                 private: false,
             },
             udp_trackers: vec![UdpTrackerConfig {
@@ -158,9 +158,9 @@ mod tests {
     fn it_should_create_tracker_config() {
         let config = TrackerConfig {
             core: TrackerCoreConfig {
-                database: DatabaseConfig::Sqlite {
+                database: DatabaseConfig::Sqlite(SqliteConfig {
                     database_name: "tracker.db".to_string(),
-                },
+                }),
                 private: true,
             },
             udp_trackers: vec![UdpTrackerConfig {
@@ -185,9 +185,9 @@ mod tests {
     fn it_should_serialize_tracker_config() {
         let config = TrackerConfig {
             core: TrackerCoreConfig {
-                database: DatabaseConfig::Sqlite {
+                database: DatabaseConfig::Sqlite(SqliteConfig {
                     database_name: "test.db".to_string(),
-                },
+                }),
                 private: false,
             },
             udp_trackers: vec![],