refactor: [#272] move tracker networks logic from template to Rust

Move conditional network selection from Tera template to pre-computed
Rust values. This follows the project pattern of keeping templates
simple by computing all logic in Rust.

Changes:
- Rename TrackerPorts to TrackerServiceConfig (more descriptive)
- Add networks: Vec<String> field to TrackerServiceConfig
- Add compute_networks() method for metrics/database/proxy networks
- Add has_prometheus, has_mysql, has_caddy parameters to constructor
- Update template to iterate over tracker.networks list
- Rename context field from 'ports' to 'tracker'
- Keep TrackerPorts type alias for backward compatibility
- Update all tests to use new 7-argument constructor

Author: josecelano

src/application/steps/rendering/docker_compose_templates.rs

@@ -35,7 +35,7 @@ use crate::domain::template::TemplateManager;
 use crate::domain::tracker::{DatabaseConfig, TrackerConfig};
 use crate::infrastructure::templating::caddy::{CaddyContext, CaddyService};
 use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
-    DockerComposeContext, DockerComposeContextBuilder, MysqlSetupConfig, TrackerPorts,
+    DockerComposeContext, DockerComposeContextBuilder, MysqlSetupConfig, TrackerServiceConfig,
 };
 use crate::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
 use crate::infrastructure::templating::docker_compose::{
@@ -109,15 +109,15 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         let generator = DockerComposeProjectGenerator::new(&self.build_dir, &self.template_manager);
 
         let admin_token = self.extract_admin_token();
-        let ports = self.build_tracker_ports();
+        let tracker = self.build_tracker_config();
 
         // 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::Sqlite(..) => Self::create_sqlite_contexts(admin_token, tracker),
             DatabaseConfig::Mysql(mysql_config) => Self::create_mysql_contexts(
                 admin_token,
-                ports,
+                tracker,
                 mysql_config.port,
                 mysql_config.database_name.clone(),
                 mysql_config.username.clone(),
@@ -156,34 +156,68 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         self.environment.admin_token().to_string()
     }
 
-    fn build_tracker_ports(&self) -> TrackerPorts {
+    fn build_tracker_config(&self) -> TrackerServiceConfig {
         let tracker_config = self.environment.tracker_config();
         let user_inputs = &self.environment.context().user_inputs;
 
         let (udp_tracker_ports, http_tracker_ports_without_tls, http_api_port, http_api_has_tls) =
             Self::extract_tracker_ports(tracker_config, user_inputs);
 
-        TrackerPorts::new(
+        // Determine which features are enabled (affects tracker networks)
+        let has_prometheus = self.environment.prometheus_config().is_some();
+        let has_mysql = matches!(
+            self.environment.database_config(),
+            DatabaseConfig::Mysql(..)
+        );
+        let has_caddy = self.has_caddy_enabled();
+
+        TrackerServiceConfig::new(
             udp_tracker_ports,
             http_tracker_ports_without_tls,
             http_api_port,
             http_api_has_tls,
+            has_prometheus,
+            has_mysql,
+            has_caddy,
         )
     }
 
+    /// Check if Caddy is enabled (HTTPS with at least one TLS-configured service)
+    fn has_caddy_enabled(&self) -> bool {
+        let user_inputs = &self.environment.context().user_inputs;
+
+        // Check if HTTPS is configured
+        if user_inputs.https.is_none() {
+            return false;
+        }
+
+        let tracker = &user_inputs.tracker;
+
+        // Check if any service has TLS configured
+        let tracker_api_has_tls = tracker.http_api_tls_domain().is_some();
+        let http_trackers_have_tls = !tracker.http_trackers_with_tls().is_empty();
+        let grafana_has_tls = user_inputs
+            .grafana
+            .as_ref()
+            .is_some_and(|g| g.tls_domain().is_some());
+
+        // Caddy is enabled if HTTPS is configured AND at least one service has TLS
+        tracker_api_has_tls || http_trackers_have_tls || grafana_has_tls
+    }
+
     fn create_sqlite_contexts(
         admin_token: String,
-        ports: TrackerPorts,
+        tracker: TrackerServiceConfig,
     ) -> (EnvContext, DockerComposeContextBuilder) {
         let env_context = EnvContext::new(admin_token);
-        let builder = DockerComposeContext::builder(ports);
+        let builder = DockerComposeContext::builder(tracker);
 
         (env_context, builder)
     }
 
     fn create_mysql_contexts(
         admin_token: String,
-        ports: TrackerPorts,
+        tracker: TrackerServiceConfig,
         port: u16,
         database_name: String,
         username: String,
@@ -208,7 +242,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             port,
         };
 
-        let builder = DockerComposeContext::builder(ports).with_mysql(mysql_config);
+        let builder = DockerComposeContext::builder(tracker).with_mysql(mysql_config);
 
         (env_context, builder)
     }

src/infrastructure/templating/docker_compose/template/renderer/docker_compose.rs

@@ -189,16 +189,19 @@ mod tests {
     use tempfile::TempDir;
 
     use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
-        DockerComposeContext, MysqlSetupConfig, TrackerPorts,
+        DockerComposeContext, MysqlSetupConfig, TrackerServiceConfig,
     };
 
-    /// Helper to create `TrackerPorts` for tests (no TLS)
-    fn test_tracker_ports() -> TrackerPorts {
-        TrackerPorts::new(
+    /// Helper to create `TrackerServiceConfig` for tests (no TLS, no networks)
+    fn test_tracker_config() -> TrackerServiceConfig {
+        TrackerServiceConfig::new(
             vec![6868, 6969], // UDP ports
             vec![7070],       // HTTP ports without TLS
             1212,             // API port
             false,            // API has no TLS
+            false,            // has_prometheus
+            false,            // has_mysql
+            false,            // has_caddy
         )
     }
 
@@ -224,15 +227,15 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
-        let ports = test_tracker_ports();
+        let tracker = test_tracker_config();
         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)
+        let mysql_context = DockerComposeContext::builder(tracker)
             .with_mysql(mysql_config)
             .build();
 
@@ -310,8 +313,8 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
-        let ports = test_tracker_ports();
-        let sqlite_context = DockerComposeContext::builder(ports).build();
+        let tracker = test_tracker_config();
+        let sqlite_context = DockerComposeContext::builder(tracker).build();
 
         let renderer = DockerComposeRenderer::new(template_manager);
         let output_dir = TempDir::new().unwrap();
@@ -349,10 +352,19 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
-        let ports = test_tracker_ports();
+        // Create tracker config with prometheus enabled
+        let tracker = TrackerServiceConfig::new(
+            vec![6868, 6969], // UDP ports
+            vec![7070],       // HTTP ports without TLS
+            1212,             // API port
+            false,            // API has no TLS
+            true,             // has_prometheus
+            false,            // has_mysql
+            false,            // has_caddy
+        );
         let prometheus_config =
             PrometheusConfig::new(std::num::NonZeroU32::new(15).expect("15 is non-zero"));
-        let context = DockerComposeContext::builder(ports)
+        let context = DockerComposeContext::builder(tracker)
             .with_prometheus(prometheus_config)
             .build();
 
@@ -417,7 +429,7 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
-        let context = DockerComposeContext::builder(test_tracker_ports()).build();
+        let context = DockerComposeContext::builder(test_tracker_config()).build();
 
         let renderer = DockerComposeRenderer::new(template_manager);
         let output_dir = TempDir::new().unwrap();

src/infrastructure/templating/docker_compose/template/renderer/project_generator.rs

@@ -185,7 +185,7 @@ mod tests {
     use tempfile::TempDir;
 
     use super::*;
-    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::TrackerPorts;
+    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::TrackerServiceConfig;
     use crate::infrastructure::templating::docker_compose::DOCKER_COMPOSE_SUBFOLDER;
 
     /// Creates a `TemplateManager` that uses the embedded templates
@@ -207,13 +207,16 @@ mod tests {
     /// Helper function to create a test docker-compose context with `SQLite`
     fn create_test_docker_compose_context_sqlite() -> DockerComposeContext {
         // Use default test ports (matching TrackerConfig::default())
-        let ports = TrackerPorts::new(
+        let tracker = TrackerServiceConfig::new(
             vec![6969], // UDP ports
             vec![7070], // HTTP ports without TLS
             1212,       // API port
             false,      // API has no TLS
+            false,      // has_prometheus
+            false,      // has_mysql
+            false,      // has_caddy
         );
-        DockerComposeContext::builder(ports).build()
+        DockerComposeContext::builder(tracker).build()
     }
 
     #[tokio::test]

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

@@ -6,14 +6,14 @@ use crate::domain::prometheus::PrometheusConfig;
 use crate::infrastructure::templating::caddy::CaddyContext;
 
 use super::database::{DatabaseConfig, MysqlSetupConfig, DRIVER_MYSQL, DRIVER_SQLITE};
-use super::{DockerComposeContext, TrackerPorts};
+use super::{DockerComposeContext, TrackerServiceConfig};
 
 /// 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,
+    tracker: TrackerServiceConfig,
     database: DatabaseConfig,
     prometheus_config: Option<PrometheusConfig>,
     grafana_config: Option<GrafanaConfig>,
@@ -23,9 +23,9 @@ pub struct DockerComposeContextBuilder {
 
 impl DockerComposeContextBuilder {
     /// Creates a new builder with default `SQLite` configuration
-    pub(super) fn new(ports: TrackerPorts) -> Self {
+    pub(super) fn new(tracker: TrackerServiceConfig) -> Self {
         Self {
-            ports,
+            tracker,
             database: DatabaseConfig {
                 driver: DRIVER_SQLITE.to_string(),
                 mysql: None,
@@ -102,7 +102,7 @@ impl DockerComposeContextBuilder {
     pub fn build(self) -> DockerComposeContext {
         DockerComposeContext {
             database: self.database,
-            ports: self.ports,
+            tracker: self.tracker,
             prometheus_config: self.prometheus_config,
             grafana_config: self.grafana_config,
             caddy_config: self.caddy_config,