refactor: convert docker_compose context to directory module with builder improvements

- Convert context.rs to directory module (context/mod.rs, builder.rs, database.rs, ports.rs)
- Extract database driver name constants (DRIVER_SQLITE, DRIVER_MYSQL)
- Rename DockerComposeContextBuilder::with_sqlite to ::new for clarity
- Simplify with_mysql to accept MysqlSetupConfig directly instead of 5 parameters
- Add MysqlSetupConfig to public re-exports
- Update all usages across production and test code

Author: josecelano

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::{
@@ -185,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/infrastructure/templating/docker_compose/template/renderer/docker_compose.rs

@@ -189,7 +189,7 @@ mod tests {
     use tempfile::TempDir;
 
     use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
-        DockerComposeContext, TrackerPorts,
+        DockerComposeContext, MysqlSetupConfig, TrackerPorts,
     };
 
     #[test]
@@ -219,14 +219,15 @@ mod tests {
             http_tracker_ports: vec![7070],
             http_api_port: 1212,
         };
+        let mysql_config = MysqlSetupConfig {
+            root_password: "rootpass123".to_string(),
+            database: "tracker_db".to_string(),
+            user: "tracker_user".to_string(),
+            password: "userpass123".to_string(),
+            port: 3306,
+        };
         let mysql_context = DockerComposeContext::builder(ports)
-            .with_mysql(
-                "rootpass123".to_string(),
-                "tracker_db".to_string(),
-                "tracker_user".to_string(),
-                "userpass123".to_string(),
-                3306,
-            )
+            .with_mysql(mysql_config)
             .build();
 
         let renderer = DockerComposeRenderer::new(template_manager);

src/infrastructure/templating/docker_compose/template/wrappers/docker_compose/context/builder.rs

@@ -0,0 +1,66 @@
+//! Builder for `DockerComposeContext`
+
+// Internal crate
+use crate::domain::prometheus::PrometheusConfig;
+
+use super::database::{DatabaseConfig, MysqlSetupConfig, DRIVER_MYSQL, DRIVER_SQLITE};
+use super::{DockerComposeContext, TrackerPorts};
+
+/// Builder for `DockerComposeContext`
+///
+/// Provides a fluent API for constructing Docker Compose contexts with optional features.
+/// Defaults to `SQLite` database configuration.
+pub struct DockerComposeContextBuilder {
+    ports: TrackerPorts,
+    database: DatabaseConfig,
+    prometheus_config: Option<PrometheusConfig>,
+}
+
+impl DockerComposeContextBuilder {
+    /// Creates a new builder with default `SQLite` configuration
+    pub(super) fn new(ports: TrackerPorts) -> Self {
+        Self {
+            ports,
+            database: DatabaseConfig {
+                driver: DRIVER_SQLITE.to_string(),
+                mysql: None,
+            },
+            prometheus_config: None,
+        }
+    }
+
+    /// Switches to `MySQL` database configuration
+    ///
+    /// # Arguments
+    ///
+    /// * `mysql_config` - `MySQL` setup configuration
+    #[must_use]
+    pub fn with_mysql(mut self, mysql_config: MysqlSetupConfig) -> Self {
+        self.database = DatabaseConfig {
+            driver: DRIVER_MYSQL.to_string(),
+            mysql: Some(mysql_config),
+        };
+        self
+    }
+
+    /// Adds Prometheus configuration
+    ///
+    /// # Arguments
+    ///
+    /// * `prometheus_config` - Prometheus configuration
+    #[must_use]
+    pub fn with_prometheus(mut self, prometheus_config: PrometheusConfig) -> Self {
+        self.prometheus_config = Some(prometheus_config);
+        self
+    }
+
+    /// Builds the `DockerComposeContext`
+    #[must_use]
+    pub fn build(self) -> DockerComposeContext {
+        DockerComposeContext {
+            database: self.database,
+            ports: self.ports,
+            prometheus_config: self.prometheus_config,
+        }
+    }
+}

src/infrastructure/templating/docker_compose/template/wrappers/docker_compose/context/database.rs

@@ -0,0 +1,58 @@
+//! Database configuration for Docker Compose templates
+
+// External crates
+use serde::Serialize;
+
+/// `SQLite` driver name
+pub const DRIVER_SQLITE: &str = "sqlite3";
+
+/// `MySQL` driver name
+pub const DRIVER_MYSQL: &str = "mysql";
+
+/// Database configuration for docker-compose template
+#[derive(Serialize, Debug, Clone)]
+pub struct DatabaseConfig {
+    /// Database driver: "sqlite3" or "mysql"
+    pub driver: String,
+    /// MySQL-specific configuration (only present when driver == "mysql")
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mysql: Option<MysqlSetupConfig>,
+}
+
+impl DatabaseConfig {
+    /// Get the database driver name
+    #[must_use]
+    pub fn driver(&self) -> &str {
+        &self.driver
+    }
+
+    /// Get the `MySQL` setup configuration if present
+    #[must_use]
+    pub fn mysql(&self) -> Option<&MysqlSetupConfig> {
+        self.mysql.as_ref()
+    }
+}
+
+/// `MySQL` setup configuration for Docker Compose initialization
+///
+/// This configuration is used to set up a new `MySQL` database in Docker Compose.
+/// It includes the root password needed for database initialization, unlike the
+/// domain `MysqlConfig` which is used for connecting to an existing database.
+///
+/// Key differences from domain `MysqlConfig`:
+/// - Includes `root_password` for database initialization
+/// - Used for Docker Compose environment variable setup
+/// - Does not include `host` (always the service name in Docker Compose)
+#[derive(Serialize, Debug, Clone)]
+pub struct MysqlSetupConfig {
+    /// `MySQL` root password for database initialization
+    pub root_password: String,
+    /// `MySQL` database name to create
+    pub database: String,
+    /// `MySQL` user to create
+    pub user: String,
+    /// `MySQL` password for the created user
+    pub password: String,
+    /// `MySQL` port
+    pub port: u16,
+}