refactor: deprecation handling

Bushuo · Bushuo · commit d55428cbba4a · 2025-07-17T18:52:16.000+02:00
use initialization logic instead of serde
diff --git a/rewatch/src/build/compile.rs b/rewatch/src/build/compile.rs
@@ -507,19 +507,15 @@ fn get_dependency_paths(
     build_dev_deps: bool,
 ) -> Vec<Vec<String>> {
     let normal_deps = config
-        .dependency_info
         .dependencies
-        .value
         .clone()
         .unwrap_or_default()
         .into_iter()
         .map(DependentPackage::Normal)
         .collect();
     let dev_deps = if build_dev_deps {
         config
-            .dependency_info
             .dev_dependencies
-            .value
             .clone()
             .unwrap_or_default()
             .into_iter()
diff --git a/rewatch/src/build/deps.rs b/rewatch/src/build/deps.rs
@@ -37,22 +37,11 @@ fn get_dep_modules(
     // Get the list of allowed dependency packages for this package
     let allowed_dependencies: AHashSet<String> = package
         .config
-        .dependency_info
         .dependencies
-        .value
         .as_ref()
         .unwrap_or(&vec![])
         .iter()
-        .chain(
-            package
-                .config
-                .dependency_info
-                .dev_dependencies
-                .value
-                .as_ref()
-                .unwrap_or(&vec![])
-                .iter(),
-        )
+        .chain(package.config.dev_dependencies.as_ref().unwrap_or(&vec![]).iter())
         .cloned()
         .collect();
 
diff --git a/rewatch/src/build/packages.rs b/rewatch/src/build/packages.rs
@@ -239,16 +239,25 @@ pub fn read_config(package_dir: &Path) -> Result<config::Config> {
     };
 
     config.inspect(|config| {
-        if config.dependency_info.dependencies.deprecation_warning {
-            deprecation_registry::log_deprecated_field("bs-dependencies", "dependencies", &config_path);
-        }
-        if config.dependency_info.dev_dependencies.deprecation_warning {
-            deprecation_registry::log_deprecated_field(
-                "bs-dev-dependencies",
-                "dev-dependencies",
-                &config_path,
-            );
-        }
+        config
+            .get_deprecations()
+            .iter()
+            .for_each(|deprecation_warning| match deprecation_warning {
+                config::DeprecationWarning::BsDependencies => {
+                    deprecation_registry::log_deprecated_field(
+                        "bs-dependencies",
+                        "dependencies",
+                        &config_path,
+                    );
+                }
+                config::DeprecationWarning::BsDevDependencies => {
+                    deprecation_registry::log_deprecated_field(
+                        "bs-dev-dependencies",
+                        "dev-dependencies",
+                        &config_path,
+                    );
+                }
+            });
     })
 }
 
@@ -312,8 +321,8 @@ fn read_dependencies(
     workspace_root: &Option<PathBuf>,
     show_progress: bool,
 ) -> Vec<Dependency> {
-    return parent_config.dependency_info.dependencies
-        .to_owned().value
+    return parent_config.dependencies
+        .clone()
         .unwrap_or_default()
         .iter()
         .filter_map(|package_name| {
@@ -901,21 +910,9 @@ pub fn validate_packages_dependencies(packages: &AHashMap<String, Package>) -> b
     let mut detected_unallowed_dependencies: AHashMap<String, UnallowedDependency> = AHashMap::new();
 
     for (package_name, package) in packages {
-        let bs_dependencies = &package
-            .config
-            .dependency_info
-            .dependencies
-            .to_owned()
-            .value
-            .unwrap_or(vec![]);
+        let bs_dependencies = &package.config.dependencies.to_owned().unwrap_or(vec![]);
         let pinned_dependencies = &package.config.pinned_dependencies.to_owned().unwrap_or(vec![]);
-        let dev_dependencies = &package
-            .config
-            .dependency_info
-            .dev_dependencies
-            .to_owned()
-            .value
-            .unwrap_or(vec![]);
+        let dev_dependencies = &package.config.dev_dependencies.to_owned().unwrap_or(vec![]);
 
         [
             ("bs-dependencies", bs_dependencies),
@@ -982,7 +979,6 @@ pub fn validate_packages_dependencies(packages: &AHashMap<String, Package>) -> b
 #[cfg(test)]
 mod test {
     use super::{Namespace, Package};
-    use crate::config::{Dependencies, DependencyInfo, Source};
     use ahash::{AHashMap, AHashSet};
     use std::path::PathBuf;
 
@@ -995,33 +991,13 @@ mod test {
     ) -> Package {
         Package {
             name: name.clone(),
-            config: crate::config::Config {
-                name: name.clone(),
-                sources: Some(crate::config::OneOrMore::Single(Source::Shorthand(String::from(
-                    "Source",
-                )))),
-                package_specs: None,
-                warnings: None,
-                suffix: None,
-                pinned_dependencies: Some(pinned_deps),
-                dependency_info: DependencyInfo {
-                    dependencies: Dependencies {
-                        deprecation_warning: false,
-                        value: Some(bs_deps),
-                    },
-                    dev_dependencies: Dependencies {
-                        deprecation_warning: false,
-                        value: Some(build_dev_deps),
-                    },
-                },
-                ppx_flags: None,
-                bsc_flags: None,
-                namespace: None,
-                jsx: None,
-                gentype_config: None,
-                namespace_entry: None,
+            config: super::config::tests::create_config(
+                name,
+                bs_deps,
+                pinned_deps,
+                build_dev_deps,
                 allowed_dependents,
-            },
+            ),
             source_folders: AHashSet::new(),
             source_files: None,
             namespace: Namespace::Namespace(String::from("Package1")),
diff --git a/rewatch/src/config.rs b/rewatch/src/config.rs
@@ -1,6 +1,6 @@
 use crate::build::packages;
 use crate::helpers::deserialize::*;
-use anyhow::Result;
+use anyhow::{Result, bail};
 use convert_case::{Case, Casing};
 use serde::Deserialize;
 use std::fs;
@@ -180,32 +180,10 @@ pub struct JsxSpecs {
 /// We do not care about the internal structure because the gentype config is loaded by bsc.
 pub type GenTypeConfig = serde_json::Value;
 
-/// Wrapper around dependencies to emit a warning when the bs- prefix is used
-#[derive(Deserialize, Debug, Clone)]
-pub struct Dependencies {
-    pub deprecation_warning: bool,
-    pub value: Option<Vec<String>>,
-}
-
-impl Default for Dependencies {
-    fn default() -> Self {
-        Self {
-            deprecation_warning: false,
-            value: None,
-        }
-    }
-}
-
-impl From<Dependencies> for Option<Vec<String>> {
-    fn from(dependencies: Dependencies) -> Self {
-        dependencies.value
-    }
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct DependencyInfo {
-    pub dependencies: Dependencies,
-    pub dev_dependencies: Dependencies,
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub enum DeprecationWarning {
+    BsDependencies,
+    BsDevDependencies,
 }
 
 /// # bsconfig.json representation
@@ -222,9 +200,18 @@ pub struct Config {
     pub suffix: Option<String>,
     #[serde(rename = "pinned-dependencies")]
     pub pinned_dependencies: Option<Vec<String>>,
-
-    #[serde(flatten, deserialize_with = "deserialize_dependencies")]
-    pub dependency_info: DependencyInfo,
+    pub dependencies: Option<Vec<String>>,
+    #[serde(rename = "dev-dependencies")]
+    pub dev_dependencies: Option<Vec<String>>,
+    // Deprecated field: overwrites dependencies
+    #[serde(rename = "bs-dependencies")]
+    bs_dependencies: Option<Vec<String>>,
+    // Deprecated field: overwrites dev_dependencies
+    #[serde(rename = "bs-dev-dependencies")]
+    bs_dev_dependencies: Option<Vec<String>>,
+    // Holds all deprecation warnings for the config struct
+    #[serde(skip)]
+    deprecation_warnings: Vec<DeprecationWarning>,
 
     #[serde(rename = "ppx-flags")]
     pub ppx_flags: Option<Vec<OneOrMore<String>>>,
@@ -349,9 +336,16 @@ impl Config {
     /// Try to convert a bsconfig from a certain path to a bsconfig struct
     pub fn new(path: &Path) -> Result<Self> {
         let read = fs::read_to_string(path)?;
-        let parse = serde_json::from_str::<Config>(&read)?;
+        Config::new_from_json_string(&read)
+    }
+
+    /// Try to convert a bsconfig from a string to a bsconfig struct
+    pub fn new_from_json_string(config_str: &str) -> Result<Self> {
+        let mut config = serde_json::from_str::<Config>(config_str)?;
 
-        Ok(parse)
+        config.handle_deprecations()?;
+
+        Ok(config)
     }
 
     pub fn get_namespace(&self) -> packages::Namespace {
@@ -389,6 +383,7 @@ impl Config {
             },
         }
     }
+
     pub fn get_jsx_args(&self) -> Vec<String> {
         match self.jsx.to_owned() {
             Some(jsx) => match jsx.version {
@@ -498,12 +493,70 @@ impl Config {
             .or(self.suffix.clone())
             .unwrap_or(".js".to_string())
     }
+
+    pub fn get_deprecations(&self) -> &[DeprecationWarning] {
+        &self.deprecation_warnings
+    }
+
+    fn handle_deprecations(&mut self) -> Result<()> {
+        if self.dependencies.is_some() && self.bs_dependencies.is_some() {
+            bail!("dependencies and bs-dependencies are mutually exclusive. Please use 'dependencies'.");
+        }
+        if self.dev_dependencies.is_some() && self.bs_dev_dependencies.is_some() {
+            bail!(
+                "dev-dependencies and bs-dev-dependencies are mutually exclusive. Please use 'dev-dependencies'"
+            );
+        }
+
+        if self.bs_dependencies.is_some() {
+            self.dependencies = self.bs_dependencies.take();
+            self.deprecation_warnings.push(DeprecationWarning::BsDependencies);
+        }
+        if self.bs_dev_dependencies.is_some() {
+            self.dev_dependencies = self.bs_dev_dependencies.take();
+            self.deprecation_warnings
+                .push(DeprecationWarning::BsDevDependencies);
+        }
+
+        Ok(())
+    }
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::*;
 
+    pub fn create_config(
+        name: String,
+        bs_deps: Vec<String>,
+        pinned_deps: Vec<String>,
+        build_dev_deps: Vec<String>,
+        allowed_dependents: Option<Vec<String>>,
+    ) -> Config {
+        Config {
+            name: name.clone(),
+            sources: Some(crate::config::OneOrMore::Single(Source::Shorthand(String::from(
+                "Source",
+            )))),
+            package_specs: None,
+            warnings: None,
+            suffix: None,
+            pinned_dependencies: Some(pinned_deps),
+            dependencies: Some(bs_deps),
+            bs_dependencies: None,
+            dev_dependencies: Some(build_dev_deps),
+            bs_dev_dependencies: None,
+            ppx_flags: None,
+            bsc_flags: None,
+            namespace: None,
+            jsx: None,
+            gentype_config: None,
+            namespace_entry: None,
+            deprecation_warnings: vec![],
+            allowed_dependents,
+        }
+    }
+
     #[test]
     fn test_getters() {
         let json = r#"
@@ -718,12 +771,9 @@ mod tests {
         }
         "#;
 
-        let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(
-            config.dependency_info.dependencies.value,
-            Some(vec!["@testrepo/main".to_string()])
-        );
-        assert_eq!(config.dependency_info.dependencies.deprecation_warning, true)
+        let config = Config::new_from_json_string(json).expect("a valid json string");
+        assert_eq!(config.dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(config.get_deprecations(), [DeprecationWarning::BsDependencies]);
     }
 
     #[test]
@@ -746,12 +796,9 @@ mod tests {
         }
         "#;
 
-        let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(
-            config.dependency_info.dependencies.value,
-            Some(vec!["@testrepo/main".to_string()])
-        );
-        assert_eq!(config.dependency_info.dependencies.deprecation_warning, false);
+        let config = Config::new_from_json_string(json).expect("a valid json string");
+        assert_eq!(config.dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(config.get_deprecations().is_empty(), true);
     }
 
     #[test]
@@ -774,12 +821,9 @@ mod tests {
         }
         "#;
 
-        let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(
-            config.dependency_info.dev_dependencies.value,
-            Some(vec!["@testrepo/main".to_string()])
-        );
-        assert_eq!(config.dependency_info.dev_dependencies.deprecation_warning, true);
+        let config = Config::new_from_json_string(json).expect("a valid json string");
+        assert_eq!(config.dev_dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(config.get_deprecations(), [DeprecationWarning::BsDevDependencies]);
     }
 
     #[test]
@@ -802,11 +846,8 @@ mod tests {
         }
         "#;
 
-        let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(
-            config.dependency_info.dev_dependencies.value,
-            Some(vec!["@testrepo/main".to_string()])
-        );
-        assert_eq!(config.dependency_info.dev_dependencies.deprecation_warning, false);
+        let config = Config::new_from_json_string(json).expect("a valid json string");
+        assert_eq!(config.dev_dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(config.get_deprecations().is_empty(), true);
     }
 }
diff --git a/rewatch/src/helpers/deserialize.rs b/rewatch/src/helpers/deserialize.rs
diff --git a/rewatch/src/sourcedirs.rs b/rewatch/src/sourcedirs.rs
