refactor(hm-config): Replace stringly-typed backend: String with a closed enum

Author: markovejnovic

crates/hm-config/src/lib.rs

@@ -15,10 +15,37 @@ pub mod creds;
 
 pub const DEFAULT_API_URL: &str = "https://api.harmont.dev";
 
-/// Default execution backend for `hm run` when no `--backend`/`--cloud` flag
-/// is given.
-fn default_backend() -> String {
-    "docker".to_owned()
+/// Execution backend for `hm run`. Closed set parsed at the config boundary so
+/// invalid values are rejected at deserialize time instead of mis-dispatching
+/// later, and every consumer match is exhaustively checked by the compiler.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Backend {
+    Docker,
+    Cloud,
+}
+
+impl Default for Backend {
+    fn default() -> Self {
+        Backend::Docker
+    }
+}
+
+impl Backend {
+    /// Stable lowercase wire/CLI name (matches the `serde` representation).
+    #[must_use]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Backend::Docker => "docker",
+            Backend::Cloud => "cloud",
+        }
+    }
+}
+
+impl std::fmt::Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -53,8 +80,8 @@ impl Default for Preferences {
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Config {
-    #[serde(default = "default_backend")]
-    pub backend: String,
+    #[serde(default)]
+    pub backend: Backend,
     #[serde(default)]
     pub cloud: CloudConfig,
     #[serde(default)]
@@ -64,7 +91,7 @@ pub struct Config {
 impl Default for Config {
     fn default() -> Self {
         Self {
-            backend: default_backend(),
+            backend: Backend::default(),
             cloud: CloudConfig::default(),
             preferences: Preferences::default(),
         }
@@ -156,7 +183,7 @@ mod tests {
     #[test]
     fn default_config_values() {
         let cfg = Config::default();
-        assert_eq!(cfg.backend, "docker");
+        assert_eq!(cfg.backend, Backend::Docker);
         assert_eq!(cfg.cloud.api_url, DEFAULT_API_URL);
         assert!(cfg.cloud.org.is_none());
         assert_eq!(cfg.preferences.format, "human");
@@ -241,7 +268,7 @@ org = "project-org"
     #[test]
     fn backend_defaults_docker_and_parses_and_layers() {
         // default
-        assert_eq!(Config::default().backend, "docker");
+        assert_eq!(Config::default().backend, Backend::Docker);
 
         // user file sets cloud; project file sets docker -> project wins.
         let mut user_file = tempfile::NamedTempFile::new().unwrap();
@@ -252,19 +279,19 @@ org = "project-org"
 
         let cfg =
             Config::load_from_paths(Some(user_file.path()), Some(project_file.path())).unwrap();
-        assert_eq!(cfg.backend, "docker");
+        assert_eq!(cfg.backend, Backend::Docker);
 
         // user file alone parses "cloud".
         let cfg_user = Config::load_from_paths(Some(user_file.path()), None).unwrap();
-        assert_eq!(cfg_user.backend, "cloud");
+        assert_eq!(cfg_user.backend, Backend::Cloud);
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn save_and_reload_roundtrip() {
         let tmp = tempfile::tempdir().unwrap();
         let path = tmp.path().join("config.toml");
         let cfg = Config {
-            backend: default_backend(),
+            backend: Backend::default(),
             cloud: CloudConfig {
                 org: Some("saved-org".into()),
                 api_url: DEFAULT_API_URL.to_owned(),

crates/hm/src/commands/init.rs

@@ -302,10 +302,15 @@ pub async fn handle(args: InitArgs) -> Result<()> {
     if project_config.exists() {
         let cfg =
             hm_config::Config::load_from_paths(None, Some(&project_config)).unwrap_or_default();
-        if cfg.backend == "cloud" {
-            tracing::info!("next step: run `hm run` to execute your pipeline on Harmont Cloud");
-        } else {
-            tracing::info!("next step: run `hm run` to execute your pipeline locally");
+        match cfg.backend {
+            hm_config::Backend::Cloud => {
+                tracing::info!(
+                    "next step: run `hm run` to execute your pipeline on Harmont Cloud"
+                );
+            }
+            hm_config::Backend::Docker => {
+                tracing::info!("next step: run `hm run` to execute your pipeline locally");
+            }
         }
     } else {
         tracing::info!("next step: run `hm run` to execute your pipeline locally");

crates/hm/src/commands/run/mod.rs

@@ -43,7 +43,7 @@ pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
                 None
             }
         })
-        .unwrap_or_else(|| ctx.config.backend.clone());
+        .unwrap_or_else(|| ctx.config.backend.to_string());
 
     // 2. Cloud needs auth + org resolution up front — fail fast on a missing
     //    token before any render work. We resolve the credentials here but

crates/hm/tests/cmd_init.rs

@@ -489,7 +489,7 @@ fn cloud_project_config_layers_correctly() {
     std::fs::write(&config_path, content).unwrap();
 
     let cfg = hm_config::Config::load_from_paths(None, Some(&config_path)).unwrap();
-    assert_eq!(cfg.backend, "cloud");
+    assert_eq!(cfg.backend, hm_config::Backend::Cloud);
     assert_eq!(cfg.cloud.org.as_deref(), Some("test-org"));
     // Unrelated defaults survive layering.
     assert_eq!(cfg.preferences.format, "human");