feat: [#232] convert docker-compose template to dynamic Tera with conditional MySQL support

Phase 1: Add MySQL service to docker-compose template

Changes:
- Convert docker-compose.yml to docker-compose.yml.tera (dynamic template)
- Add conditional MySQL 8.0 service (renders only when database.driver == 'mysql')
- Add MySQL healthcheck using mysqladmin ping
- Add mysql_data volume for persistence
- Create DockerComposeContext wrapper (supports SQLite and MySQL)
- Create DockerComposeTemplate wrapper with validation
- Create DockerComposeRenderer following renderer pattern
- Update DockerComposeProjectGenerator to render dynamically
- Add comprehensive unit tests for MySQL rendering (1460 tests passing)

MySQL Service Features:
- MySQL 8.0 with native password authentication
- Healthcheck: mysqladmin ping (10s interval, 5s timeout, 5 retries, 30s start_period)
- Environment variables: root password, database, user, password
- Port mapping: 3306
- Named volume for data persistence
- Network: backend_network

Testing:
- Unit tests verify MySQL service renders with all components
- Unit tests verify SQLite doesn't render MySQL service
- All 1460 unit tests passing
- Pre-commit checks passing

Limitation:
- Phase 2 needed: Environment configuration doesn't support MySQL yet
- Full E2E test with MySQL deferred to Phase 2

Related to #232

Author: josecelano

project-words.txt

@@ -140,6 +140,7 @@ mtorrust
 multiprocess
 myapp
 myenv
+mysqladmin
 nameof
 namespacing
 nanos
@@ -243,6 +244,7 @@ unrepresentable
 unsubscription
 usermod
 useroutput
+userpass
 userspace
 usize
 utmp

src/application/steps/rendering/docker_compose_templates.rs

@@ -31,6 +31,7 @@ use tracing::{info, instrument};
 
 use crate::domain::environment::Environment;
 use crate::domain::template::TemplateManager;
+use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::DockerComposeContext;
 use crate::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
 use crate::infrastructure::templating::docker_compose::{
     DockerComposeProjectGenerator, DockerComposeProjectGeneratorError,
@@ -99,8 +100,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             "Rendering Docker Compose templates"
         );
 
-        let generator =
-            DockerComposeProjectGenerator::new(&self.build_dir, self.template_manager.clone());
+        let generator = DockerComposeProjectGenerator::new(&self.build_dir, &self.template_manager);
 
         // Extract admin token from environment config
         let admin_token = self
@@ -113,7 +113,12 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             .clone();
         let env_context = EnvContext::new(admin_token);
 
-        let compose_build_dir = generator.render(&env_context).await?;
+        // For now, use SQLite configuration (MySQL support will be added in Phase 2)
+        let docker_compose_context = DockerComposeContext::new_sqlite();
+
+        let compose_build_dir = generator
+            .render(&env_context, &docker_compose_context)
+            .await?;
 
         info!(
             step = "render_docker_compose_templates",

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

@@ -0,0 +1,326 @@
+//! # docker-compose.yml Template Renderer
+//!
+//! This module handles rendering of the `docker-compose.yml.tera` template for Docker Compose deployments.
+//! It's responsible for creating `docker-compose.yml` files with service configurations from dynamic configuration.
+//!
+//! ## Responsibilities
+//!
+//! - Load the `docker-compose.yml.tera` template file
+//! - Process template with runtime context (database configuration, etc.)
+//! - Render final `docker-compose.yml` file for Docker Compose consumption
+
+use std::path::Path;
+use std::sync::Arc;
+use thiserror::Error;
+
+use crate::domain::template::file::File;
+use crate::domain::template::{FileOperationError, TemplateManager, TemplateManagerError};
+use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
+    DockerComposeContext, DockerComposeTemplate,
+};
+
+/// Errors that can occur during docker-compose.yml template rendering
+#[derive(Error, Debug)]
+pub enum DockerComposeRendererError {
+    /// Failed to get template path from template manager
+    #[error("Failed to get template path for '{file_name}': {source}")]
+    TemplatePathFailed {
+        file_name: String,
+        #[source]
+        source: TemplateManagerError,
+    },
+
+    /// Failed to read Tera template file content
+    #[error("Failed to read Tera template file '{file_name}': {source}")]
+    TeraTemplateReadFailed {
+        file_name: String,
+        #[source]
+        source: std::io::Error,
+    },
+
+    /// Failed to create File object from template content
+    #[error("Failed to create File object for '{file_name}': {source}")]
+    FileCreationFailed {
+        file_name: String,
+        #[source]
+        source: crate::domain::template::file::Error,
+    },
+
+    /// Failed to create docker-compose template with provided context
+    #[error("Failed to create DockerComposeTemplate: {source}")]
+    DockerComposeTemplateCreationFailed {
+        #[source]
+        source: crate::domain::template::TemplateEngineError,
+    },
+
+    /// Failed to render docker-compose template to output file
+    #[error("Failed to render docker-compose.yml template to file: {source}")]
+    DockerComposeTemplateRenderFailed {
+        #[source]
+        source: FileOperationError,
+    },
+}
+
+/// Handles rendering of the docker-compose.yml.tera template for Docker Compose deployments
+///
+/// This collaborator is responsible for all docker-compose.yml template-specific operations:
+/// - Loading the docker-compose.yml.tera template
+/// - Processing it with runtime context (database configuration, etc.)
+/// - Rendering the final docker-compose.yml file for Docker Compose consumption
+pub struct DockerComposeRenderer {
+    template_manager: Arc<TemplateManager>,
+}
+
+impl DockerComposeRenderer {
+    /// Template filename for the docker-compose.yml Tera template
+    const DOCKER_COMPOSE_TEMPLATE_FILE: &'static str = "docker-compose.yml.tera";
+
+    /// Output filename for the rendered docker-compose.yml file
+    const DOCKER_COMPOSE_OUTPUT_FILE: &'static str = "docker-compose.yml";
+
+    /// Default template path prefix for Docker Compose templates
+    const DOCKER_COMPOSE_TEMPLATE_PATH: &'static str = "docker-compose";
+
+    /// Creates a new docker-compose.yml template renderer
+    ///
+    /// # Arguments
+    ///
+    /// * `template_manager` - The template manager to source templates from
+    #[must_use]
+    pub fn new(template_manager: Arc<TemplateManager>) -> Self {
+        Self { template_manager }
+    }
+
+    /// Renders the docker-compose.yml.tera template with the provided context
+    ///
+    /// This method:
+    /// 1. Loads the docker-compose.yml.tera template from the template manager
+    /// 2. Reads the template content
+    /// 3. Creates a File object for template processing
+    /// 4. Creates a `DockerComposeTemplate` with the runtime context
+    /// 5. Renders the template to docker-compose.yml in the output directory
+    ///
+    /// # Arguments
+    ///
+    /// * `context` - The context containing service configuration
+    /// * `output_dir` - The directory where docker-compose.yml should be written
+    ///
+    /// # Returns
+    ///
+    /// * `Result<(), DockerComposeRendererError>` - Success or error from the template rendering operation
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - Template file cannot be found or read
+    /// - Template content is invalid
+    /// - Variable substitution fails
+    /// - Output file cannot be written
+    pub fn render(
+        &self,
+        context: &DockerComposeContext,
+        output_dir: &Path,
+    ) -> Result<(), DockerComposeRendererError> {
+        tracing::debug!("Rendering docker-compose.yml template with runtime variables");
+
+        // Get the docker-compose.yml template path
+        let template_path = self
+            .template_manager
+            .get_template_path(&Self::build_template_path())
+            .map_err(|source| DockerComposeRendererError::TemplatePathFailed {
+                file_name: Self::DOCKER_COMPOSE_TEMPLATE_FILE.to_string(),
+                source,
+            })?;
+
+        // Read the template file content
+        let template_content = std::fs::read_to_string(&template_path).map_err(|source| {
+            DockerComposeRendererError::TeraTemplateReadFailed {
+                file_name: Self::DOCKER_COMPOSE_TEMPLATE_FILE.to_string(),
+                source,
+            }
+        })?;
+
+        // Create File object for template processing
+        let template_file = File::new(Self::DOCKER_COMPOSE_TEMPLATE_FILE, template_content)
+            .map_err(|source| DockerComposeRendererError::FileCreationFailed {
+                file_name: Self::DOCKER_COMPOSE_TEMPLATE_FILE.to_string(),
+                source,
+            })?;
+
+        // Create the template with context
+        let docker_compose_template = DockerComposeTemplate::new(&template_file, context.clone())
+            .map_err(|source| {
+            DockerComposeRendererError::DockerComposeTemplateCreationFailed { source }
+        })?;
+
+        // Render to output file
+        let output_path = output_dir.join(Self::DOCKER_COMPOSE_OUTPUT_FILE);
+        docker_compose_template
+            .render(&output_path)
+            .map_err(
+                |source| DockerComposeRendererError::DockerComposeTemplateRenderFailed { source },
+            )?;
+
+        tracing::debug!(
+            output_path = %output_path.display(),
+            "docker-compose.yml template rendered successfully"
+        );
+
+        Ok(())
+    }
+
+    /// Builds the template path for the docker-compose.yml.tera file
+    ///
+    /// # Returns
+    ///
+    /// * `String` - The complete template path
+    fn build_template_path() -> String {
+        format!(
+            "{}/{}",
+            Self::DOCKER_COMPOSE_TEMPLATE_PATH,
+            Self::DOCKER_COMPOSE_TEMPLATE_FILE
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::DockerComposeContext;
+
+    #[test]
+    fn it_should_create_renderer_with_template_manager() {
+        let temp_dir = TempDir::new().unwrap();
+        let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
+
+        let renderer = DockerComposeRenderer::new(template_manager);
+
+        // Verify the renderer is created (smoke test)
+        assert!(std::mem::size_of_val(&renderer) > 0);
+    }
+
+    #[test]
+    fn it_should_build_correct_template_path() {
+        let path = DockerComposeRenderer::build_template_path();
+        assert_eq!(path, "docker-compose/docker-compose.yml.tera");
+    }
+
+    #[test]
+    fn it_should_render_docker_compose_with_mysql_service_when_driver_is_mysql() {
+        let temp_dir = TempDir::new().unwrap();
+        let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
+
+        let mysql_context = DockerComposeContext::new_mysql(
+            "rootpass123".to_string(),
+            "tracker_db".to_string(),
+            "tracker_user".to_string(),
+            "userpass123".to_string(),
+            3306,
+        );
+
+        let renderer = DockerComposeRenderer::new(template_manager);
+        let output_dir = TempDir::new().unwrap();
+
+        let result = renderer.render(&mysql_context, output_dir.path());
+        assert!(
+            result.is_ok(),
+            "Rendering with MySQL context should succeed"
+        );
+
+        let output_path = output_dir.path().join("docker-compose.yml");
+        let content = std::fs::read_to_string(&output_path)
+            .expect("Should be able to read rendered docker-compose.yml");
+
+        // Verify MySQL service is present
+        assert!(
+            content.contains("mysql:"),
+            "Rendered output should contain mysql service"
+        );
+        assert!(
+            content.contains("image: mysql:8.0"),
+            "Should use MySQL 8.0 image"
+        );
+
+        // Verify MySQL environment variables
+        assert!(
+            content.contains("MYSQL_ROOT_PASSWORD=rootpass123"),
+            "Should contain root password"
+        );
+        assert!(
+            content.contains("MYSQL_DATABASE=tracker_db"),
+            "Should contain database name"
+        );
+        assert!(
+            content.contains("MYSQL_USER=tracker_user"),
+            "Should contain username"
+        );
+        assert!(
+            content.contains("MYSQL_PASSWORD=userpass123"),
+            "Should contain password"
+        );
+
+        // Verify MySQL healthcheck
+        assert!(
+            content.contains("healthcheck:"),
+            "Should have healthcheck section"
+        );
+        assert!(
+            content.contains("mysqladmin"),
+            "Should use mysqladmin for healthcheck"
+        );
+        assert!(content.contains("ping"), "Should use ping command");
+
+        // Verify MySQL volume
+        assert!(
+            content.contains("mysql_data:"),
+            "Should have mysql_data volume definition"
+        );
+        assert!(
+            content.contains("driver: local"),
+            "Volume should use local driver"
+        );
+
+        // Verify port mapping
+        assert!(
+            content.contains("3306:3306"),
+            "Should expose MySQL port 3306"
+        );
+    }
+
+    #[test]
+    fn it_should_not_render_mysql_service_when_driver_is_sqlite() {
+        let temp_dir = TempDir::new().unwrap();
+        let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
+
+        let sqlite_context = DockerComposeContext::new_sqlite();
+
+        let renderer = DockerComposeRenderer::new(template_manager);
+        let output_dir = TempDir::new().unwrap();
+
+        let result = renderer.render(&sqlite_context, output_dir.path());
+        assert!(
+            result.is_ok(),
+            "Rendering with SQLite context should succeed"
+        );
+
+        let output_path = output_dir.path().join("docker-compose.yml");
+        let content = std::fs::read_to_string(&output_path)
+            .expect("Should be able to read rendered docker-compose.yml");
+
+        // Verify MySQL service is NOT present
+        assert!(
+            !content.contains("image: mysql:8.0"),
+            "Should not contain MySQL service"
+        );
+        assert!(
+            !content.contains("mysqladmin"),
+            "Should not contain MySQL healthcheck"
+        );
+        assert!(
+            !content.contains("mysql_data:"),
+            "Should not contain mysql_data volume"
+        );
+    }
+}