refactor: [#281] replace to_* methods with TryFrom trait for DTO conversions

- Convert GrafanaSection, PrometheusSection, SshCredentialsConfig,
  DatabaseSection, TrackerCoreSection, TrackerSection, and ProviderSection
  to use TryFrom trait for domain type conversion
- Update environment_config.rs to use try_into() for all conversions
- Remove old to_* methods (no backward compatibility needed pre-v1.0)

Follows pattern documented in docs/decisions/tryfrom-for-dto-to-domain-conversion.md

Author: josecelano

src/application/command_handlers/create/config/environment_config.rs

@@ -4,6 +4,8 @@
 //! all configuration needed to create a deployment environment. It handles
 //! deserialization from configuration sources and conversion to domain types.
 
+use std::convert::TryInto;
+
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -327,27 +329,21 @@ impl EnvironmentCreationConfig {
         };
 
         // Convert ProviderSection (DTO) to domain ProviderConfig (validates profile_name, etc.)
-        let provider_config = self.provider.to_provider_config()?;
+        let provider_config = self.provider.try_into()?;
 
         // Get SSH port before consuming ssh_credentials
         let ssh_port = self.ssh_credentials.port;
 
         // Convert SSH credentials config to domain type
-        let ssh_credentials = self.ssh_credentials.to_ssh_credentials()?;
+        let ssh_credentials = self.ssh_credentials.try_into()?;
 
         // Convert TrackerSection (DTO) to domain TrackerConfig (validates bind addresses, etc.)
-        let tracker_config = self.tracker.to_tracker_config()?;
+        let tracker_config = self.tracker.try_into()?;
 
         // Convert Prometheus and Grafana sections to domain types
-        let prometheus_config = self
-            .prometheus
-            .map(|section| section.to_prometheus_config())
-            .transpose()?;
+        let prometheus_config = self.prometheus.map(TryInto::try_into).transpose()?;
 
-        let grafana_config = self
-            .grafana
-            .map(|section| section.to_grafana_config())
-            .transpose()?;
+        let grafana_config = self.grafana.map(TryInto::try_into).transpose()?;
 
         // Note: Grafana-Prometheus dependency is now validated at domain level
         // in UserInputs::with_tracker() when the environment is created

src/application/command_handlers/create/config/grafana.rs

@@ -3,6 +3,13 @@
 //! This module contains the DTO type for Grafana configuration used in
 //! environment creation. This type uses raw primitives (String) for JSON
 //! deserialization and converts to the rich domain type (`GrafanaConfig`).
+//!
+//! It follows the **`TryFrom` pattern** for DTO to domain conversion, delegating
+//! all business validation to the domain layer.
+//!
+//! See `docs/decisions/tryfrom-for-dto-to-domain-conversion.md` for rationale.
+
+use std::convert::TryFrom;
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -82,23 +89,20 @@ impl Default for GrafanaSection {
     }
 }
 
-impl GrafanaSection {
-    /// Converts this DTO to a domain `GrafanaConfig`
-    ///
-    /// This method performs validation and type conversion from the
-    /// string-based DTO to the strongly-typed domain model with secrecy
-    /// protection for the password.
-    ///
-    /// # Errors
-    ///
-    /// Returns `CreateConfigError::InvalidDomain` if the domain is invalid.
-    /// Returns `CreateConfigError::TlsProxyWithoutDomain` if `use_tls_proxy`
-    /// is true but no domain is provided.
-    pub fn to_grafana_config(&self) -> Result<GrafanaConfig, CreateConfigError> {
-        let use_tls_proxy = self.use_tls_proxy.unwrap_or(false);
+/// Converts from application DTO to domain type using `TryFrom` trait
+///
+/// This follows the idiomatic Rust pattern for fallible type
+/// conversions, enabling use of `.try_into()` and `TryFrom::try_from()`.
+///
+/// See `docs/decisions/tryfrom-for-dto-to-domain-conversion.md` for rationale.
+impl TryFrom<GrafanaSection> for GrafanaConfig {
+    type Error = CreateConfigError;
+
+    fn try_from(section: GrafanaSection) -> Result<Self, Self::Error> {
+        let use_tls_proxy = section.use_tls_proxy.unwrap_or(false);
 
         // Validate: use_tls_proxy requires domain
-        if use_tls_proxy && self.domain.is_none() {
+        if use_tls_proxy && section.domain.is_none() {
             return Err(CreateConfigError::TlsProxyWithoutDomain {
                 service_type: "Grafana".to_string(),
                 bind_address: "N/A (hardcoded port 3000)".to_string(),
@@ -107,7 +111,7 @@ impl GrafanaSection {
 
         // Parse domain if present
         let domain =
-            match &self.domain {
+            match &section.domain {
                 Some(domain_str) => Some(DomainName::new(domain_str).map_err(|e| {
                     CreateConfigError::InvalidDomain {
                         domain: domain_str.clone(),
@@ -118,8 +122,8 @@ impl GrafanaSection {
             };
 
         Ok(GrafanaConfig::new(
-            self.admin_user.clone(),
-            self.admin_password.clone(),
+            section.admin_user,
+            section.admin_password,
             domain,
             use_tls_proxy,
         ))
@@ -148,7 +152,7 @@ mod tests {
             use_tls_proxy: None,
         };
 
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, _> = section.try_into();
         assert!(result.is_ok());
 
         let config = result.unwrap();
@@ -159,7 +163,7 @@ mod tests {
     #[test]
     fn it_should_convert_default_section_to_default_config() {
         let section = GrafanaSection::default();
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, _> = section.try_into();
         assert!(result.is_ok());
 
         let config = result.unwrap();
@@ -175,7 +179,7 @@ mod tests {
             use_tls_proxy: None,
         };
 
-        let config = section.to_grafana_config().unwrap();
+        let config: GrafanaConfig = section.try_into().unwrap();
         let debug_output = format!("{config:?}");
 
         // Password should be redacted in debug output
@@ -192,7 +196,7 @@ mod tests {
             use_tls_proxy: Some(true),
         };
 
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, _> = section.try_into();
         assert!(result.is_ok());
 
         let config = result.unwrap();
@@ -209,7 +213,7 @@ mod tests {
             use_tls_proxy: Some(false),
         };
 
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, _> = section.try_into();
         assert!(result.is_ok());
 
         let config = result.unwrap();
@@ -229,7 +233,7 @@ mod tests {
             use_tls_proxy: Some(true),
         };
 
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, CreateConfigError> = section.try_into();
         assert!(result.is_err());
 
         let err = result.unwrap_err();
@@ -248,7 +252,7 @@ mod tests {
             use_tls_proxy: Some(true),
         };
 
-        let result = section.to_grafana_config();
+        let result: Result<GrafanaConfig, CreateConfigError> = section.try_into();
         assert!(result.is_err());
 
         let err = result.unwrap_err();

src/application/command_handlers/create/config/prometheus.rs

@@ -3,7 +3,13 @@
 //! This module contains the DTO type for Prometheus configuration used in
 //! environment creation. This type uses raw primitives (u32) for JSON
 //! deserialization and converts to the rich domain type (`PrometheusConfig`).
+//!
+//! # Conversion Pattern
+//!
+//! Uses `TryFrom` for idiomatic Rust conversion from DTO to domain type.
+//! See ADR: `docs/decisions/tryfrom-for-dto-to-domain-conversion.md`
 
+use std::convert::TryFrom;
 use std::num::NonZeroU32;
 
 use schemars::JsonSchema;
@@ -41,20 +47,14 @@ impl Default for PrometheusSection {
     }
 }
 
-impl PrometheusSection {
-    /// Converts this DTO to a domain `PrometheusConfig`
-    ///
-    /// This method performs validation and type conversion from the
-    /// u32 DTO to the strongly-typed domain model with `NonZeroU32`.
-    ///
-    /// # Errors
-    ///
-    /// Returns error if scrape interval is 0
-    pub fn to_prometheus_config(&self) -> Result<PrometheusConfig, CreateConfigError> {
-        let interval = NonZeroU32::new(self.scrape_interval_in_secs).ok_or_else(|| {
+impl TryFrom<PrometheusSection> for PrometheusConfig {
+    type Error = CreateConfigError;
+
+    fn try_from(section: PrometheusSection) -> Result<Self, Self::Error> {
+        let interval = NonZeroU32::new(section.scrape_interval_in_secs).ok_or_else(|| {
             CreateConfigError::InvalidPrometheusConfig(format!(
                 "Scrape interval must be greater than 0, got: {}",
-                self.scrape_interval_in_secs
+                section.scrape_interval_in_secs
             ))
         })?;
         Ok(PrometheusConfig::new(interval))
@@ -77,14 +77,14 @@ mod tests {
             scrape_interval_in_secs: 30,
         };
 
-        let config = section.to_prometheus_config().expect("Valid config");
+        let config: PrometheusConfig = section.try_into().expect("Valid config");
         assert_eq!(config.scrape_interval_in_secs(), 30);
     }
 
     #[test]
     fn it_should_convert_default_section_to_default_config() {
         let section = PrometheusSection::default();
-        let config = section.to_prometheus_config().expect("Valid config");
+        let config: PrometheusConfig = section.try_into().expect("Valid config");
 
         assert_eq!(config, PrometheusConfig::default());
     }
@@ -95,7 +95,7 @@ mod tests {
             scrape_interval_in_secs: 0,
         };
 
-        let result = section.to_prometheus_config();
+        let result: Result<PrometheusConfig, _> = section.try_into();
         assert!(result.is_err());
     }
 }