refactor: use CommandHandlerFactory in create and destroy handlers

Co-authored-by: josecelano <[email protected]>

Author: Copilot

src/presentation/commands/create/subcommands/environment.rs

@@ -4,12 +4,11 @@
 //! deployment environments from configuration files.
 
 use std::path::Path;
-use std::sync::Arc;
 
 use crate::application::command_handlers::create::config::EnvironmentCreationConfig;
-use crate::application::command_handlers::create::CreateCommandHandler;
 use crate::domain::Environment;
-use crate::presentation::commands::context::{report_error, CommandContext};
+use crate::presentation::commands::context::report_error;
+use crate::presentation::commands::factory::CommandHandlerFactory;
 use crate::presentation::user_output::UserOutput;
 
 use super::super::config_loader::ConfigLoader;
@@ -47,17 +46,15 @@ pub fn handle_environment_creation(
     env_file: &Path,
     working_dir: &Path,
 ) -> Result<(), CreateSubcommandError> {
-    let mut ctx = CommandContext::new(working_dir.to_path_buf());
+    let factory = CommandHandlerFactory::new();
+    let mut ctx = factory.create_context(working_dir.to_path_buf());
 
     // Step 1: Load configuration
     let config = load_configuration(ctx.output(), env_file)?;
 
-    // Step 2: Execute command (split borrow to avoid conflict)
-    let environment = {
-        let repository = ctx.repository().clone();
-        let clock = ctx.clock().clone();
-        execute_create_command(ctx.output(), config, repository, clock)?
-    };
+    // Step 2: Execute command (create handler before borrowing output)
+    let command_handler = factory.create_create_handler(&ctx);
+    let environment = execute_create_command(ctx.output(), command_handler, config)?;
 
     // Step 3: Display results
     display_creation_results(ctx.output(), &environment);
@@ -105,16 +102,14 @@ fn load_configuration(
 /// Execute the create command with the given configuration
 ///
 /// This step handles:
-/// - Creating the command handler with dependencies
-/// - Executing the create command
+/// - Executing the create command with the given handler
 /// - Handling command execution errors
 ///
 /// # Arguments
 ///
 /// * `output` - User output for progress messages
+/// * `command_handler` - Pre-created command handler
 /// * `config` - Validated environment creation configuration
-/// * `repository` - Repository for environment persistence
-/// * `clock` - Clock for timing operations
 ///
 /// # Returns
 ///
@@ -125,17 +120,14 @@ fn load_configuration(
 /// Returns an error if command execution fails (e.g., environment already exists).
 fn execute_create_command(
     output: &mut UserOutput,
+    command_handler: crate::application::command_handlers::CreateCommandHandler,
     config: EnvironmentCreationConfig,
-    repository: Arc<dyn crate::domain::environment::repository::EnvironmentRepository>,
-    clock: Arc<dyn crate::shared::Clock>,
 ) -> Result<Environment, CreateSubcommandError> {
     output.progress(&format!(
         "Creating environment '{}'...",
         config.environment.name
     ));
 
-    let command_handler = CreateCommandHandler::new(repository, clock);
-
     output.progress("Validating configuration and creating environment...");
 
     #[allow(clippy::manual_inspect)]
@@ -449,10 +441,10 @@ mod tests {
             let loader = ConfigLoader;
             let config = loader.load_from_file(&config_path).unwrap();
 
-            let ctx = CommandContext::new(temp_dir.path().to_path_buf());
-            let repository = ctx.repository().clone();
-            let clock = ctx.clock().clone();
-            let result = execute_create_command(&mut output, config, repository, clock);
+            let factory = CommandHandlerFactory::new();
+            let ctx = factory.create_context(temp_dir.path().to_path_buf());
+            let command_handler = factory.create_create_handler(&ctx);
+            let result = execute_create_command(&mut output, command_handler, config);
 
             assert!(result.is_ok(), "Should execute command successfully");
             let environment = result.unwrap();
@@ -485,21 +477,17 @@ mod tests {
             let loader = ConfigLoader;
             let config = loader.load_from_file(&config_path).unwrap();
 
-            let ctx = CommandContext::new(temp_dir.path().to_path_buf());
-            let repository = ctx.repository().clone();
-            let clock = ctx.clock().clone();
+            let factory = CommandHandlerFactory::new();
+            let ctx = factory.create_context(temp_dir.path().to_path_buf());
 
             // Create environment first time
-            let result1 = execute_create_command(
-                &mut output,
-                config.clone(),
-                repository.clone(),
-                clock.clone(),
-            );
+            let command_handler1 = factory.create_create_handler(&ctx);
+            let result1 = execute_create_command(&mut output, command_handler1, config.clone());
             assert!(result1.is_ok(), "First execution should succeed");
 
             // Try to create same environment again
-            let result2 = execute_create_command(&mut output, config, repository, clock);
+            let command_handler2 = factory.create_create_handler(&ctx);
+            let result2 = execute_create_command(&mut output, command_handler2, config);
             assert!(result2.is_err(), "Second execution should fail");
 
             match result2.unwrap_err() {
@@ -539,14 +527,13 @@ mod tests {
             fs::write(&config_path, config_json).unwrap();
 
             // Create environment
-            let ctx = CommandContext::new(temp_dir.path().to_path_buf());
+            let factory = CommandHandlerFactory::new();
+            let ctx = factory.create_context(temp_dir.path().to_path_buf());
             let loader = ConfigLoader;
             let config = loader.load_from_file(&config_path).unwrap();
             let mut quiet_output = UserOutput::new(VerbosityLevel::Quiet);
-            let repository = ctx.repository().clone();
-            let clock = ctx.clock().clone();
-            let environment =
-                execute_create_command(&mut quiet_output, config, repository, clock).unwrap();
+            let command_handler = factory.create_create_handler(&ctx);
+            let environment = execute_create_command(&mut quiet_output, command_handler, config).unwrap();
 
             // Test display function with custom output
             let stderr_buf = Vec::new();

src/presentation/commands/destroy/handler.rs

@@ -3,9 +3,9 @@
 //! This module handles the destroy command execution at the presentation layer,
 //! including environment validation, repository initialization, and user interaction.
 
-use crate::application::command_handlers::DestroyCommandHandler;
 use crate::domain::environment::name::EnvironmentName;
-use crate::presentation::commands::context::{report_error, CommandContext};
+use crate::presentation::commands::context::report_error;
+use crate::presentation::commands::factory::CommandHandlerFactory;
 
 use super::errors::DestroySubcommandError;
 
@@ -51,8 +51,9 @@ pub fn handle_destroy_command(
     environment_name: &str,
     working_dir: &std::path::Path,
 ) -> Result<(), DestroySubcommandError> {
-    // Create command context with all shared dependencies
-    let mut ctx = CommandContext::new(working_dir.to_path_buf());
+    // Create factory and context with all shared dependencies
+    let factory = CommandHandlerFactory::new();
+    let mut ctx = factory.create_context(working_dir.to_path_buf());
 
     // Display initial progress (to stderr)
     ctx.output()
@@ -71,7 +72,7 @@ pub fn handle_destroy_command(
     // Create and execute destroy command handler
     ctx.output().progress("Tearing down infrastructure...");
 
-    let command_handler = DestroyCommandHandler::new(ctx.repository().clone(), ctx.clock().clone());
+    let command_handler = factory.create_destroy_handler(&ctx);
 
     // Execute destroy - the handler will load the environment and handle all states internally
     let _destroyed_env = command_handler.execute(&env_name).map_err(|source| {