feat: deprecation warnings for 'bs-' prefixes

Author: Bushuo

rewatch/src/build/compile.rs

@@ -507,15 +507,19 @@ 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()

rewatch/src/build/deps.rs

@@ -37,11 +37,22 @@ 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.dev_dependencies.as_ref().unwrap_or(&vec![]).iter())
+        .chain(
+            package
+                .config
+                .dependency_info
+                .dev_dependencies
+                .value
+                .as_ref()
+                .unwrap_or(&vec![])
+                .iter(),
+        )
         .cloned()
         .collect();
 

rewatch/src/build/packages.rs

@@ -4,6 +4,7 @@ use super::packages;
 use crate::config;
 use crate::helpers;
 use crate::helpers::StrippedVerbatimPath;
+use crate::helpers::deprecation_registry;
 use crate::helpers::emojis::*;
 use ahash::{AHashMap, AHashSet};
 use anyhow::{Result, anyhow};
@@ -231,11 +232,24 @@ pub fn read_config(package_dir: &Path) -> Result<config::Config> {
     let rescript_json_path = package_dir.join("rescript.json");
     let bsconfig_json_path = package_dir.join("bsconfig.json");
 
-    if Path::new(&rescript_json_path).exists() {
-        config::read(&rescript_json_path)
+    let (config, config_path) = if Path::new(&rescript_json_path).exists() {
+        (config::Config::new(&rescript_json_path), rescript_json_path)
     } else {
-        config::read(&bsconfig_json_path)
-    }
+        (config::Config::new(&bsconfig_json_path), bsconfig_json_path)
+    };
+
+    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",
+                "devDependencies",
+                &config_path,
+            );
+        }
+    })
 }
 
 pub fn read_dependency(
@@ -298,9 +312,8 @@ fn read_dependencies(
     workspace_root: &Option<PathBuf>,
     show_progress: bool,
 ) -> Vec<Dependency> {
-    return parent_config
-        .dependencies
-        .to_owned()
+    return parent_config.dependency_info.dependencies
+        .to_owned().value
         .unwrap_or_default()
         .iter()
         .filter_map(|package_name| {
@@ -888,9 +901,21 @@ 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.dependencies.to_owned().unwrap_or(vec![]);
+        let bs_dependencies = &package
+            .config
+            .dependency_info
+            .dependencies
+            .to_owned()
+            .value
+            .unwrap_or(vec![]);
         let pinned_dependencies = &package.config.pinned_dependencies.to_owned().unwrap_or(vec![]);
-        let dev_dependencies = &package.config.dev_dependencies.to_owned().unwrap_or(vec![]);
+        let dev_dependencies = &package
+            .config
+            .dependency_info
+            .dev_dependencies
+            .to_owned()
+            .value
+            .unwrap_or(vec![]);
 
         [
             ("bs-dependencies", bs_dependencies),
@@ -957,7 +982,7 @@ pub fn validate_packages_dependencies(packages: &AHashMap<String, Package>) -> b
 #[cfg(test)]
 mod test {
     use super::{Namespace, Package};
-    use crate::config::Source;
+    use crate::config::{Dependencies, DependencyInfo, Source};
     use ahash::{AHashMap, AHashSet};
     use std::path::PathBuf;
 
@@ -979,8 +1004,16 @@ mod test {
                 warnings: None,
                 suffix: None,
                 pinned_dependencies: Some(pinned_deps),
-                dependencies: Some(bs_deps),
-                dev_dependencies: Some(build_dev_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,

rewatch/src/config.rs

@@ -180,6 +180,34 @@ 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,
+}
+
 /// # bsconfig.json representation
 /// This is tricky, there is a lot of ambiguity. This is probably incomplete.
 #[derive(Deserialize, Debug, Clone)]
@@ -195,19 +223,8 @@ pub struct Config {
     #[serde(rename = "pinned-dependencies")]
     pub pinned_dependencies: Option<Vec<String>>,
 
-    #[serde(
-        default,
-        alias = "bs-dependencies",
-        deserialize_with = "deserialize_dependencies"
-    )]
-    pub dependencies: Option<Vec<String>>,
-    #[serde(
-        default,
-        rename = "dev-dependencies",
-        alias = "bs-dev-dependencies",
-        deserialize_with = "deserialize_dev_dependencies"
-    )]
-    pub dev_dependencies: Option<Vec<String>>,
+    #[serde(flatten, deserialize_with = "deserialize_dependencies")]
+    pub dependency_info: DependencyInfo,
 
     #[serde(rename = "ppx-flags")]
     pub ppx_flags: Option<Vec<OneOrMore<String>>>,
@@ -243,8 +260,8 @@ pub fn flatten_flags(flags: &Option<Vec<OneOrMore<String>>>) -> Vec<String> {
     }
 }
 
-/// Since ppx-flags could be one or more, and could be nested potentiall, this function takes the
-/// flags and flattens them outright.
+/// Since ppx-flags could be one or more, and could potentially be nested, this function takes the
+/// flags and flattens them.
 pub fn flatten_ppx_flags(
     node_modules_dir: &Path,
     flags: &Option<Vec<OneOrMore<String>>>,
@@ -299,14 +316,6 @@ pub fn flatten_ppx_flags(
     }
 }
 
-/// Try to convert a bsconfig from a certain path to a bsconfig struct
-pub fn read(path: &Path) -> Result<Config> {
-    let read = fs::read_to_string(path)?;
-    let parse = serde_json::from_str::<Config>(&read)?;
-
-    Ok(parse)
-}
-
 fn namespace_from_package_name(package_name: &str) -> String {
     let len = package_name.len();
     let mut buf = String::with_capacity(len);
@@ -337,6 +346,14 @@ fn namespace_from_package_name(package_name: &str) -> String {
 }
 
 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)?;
+
+        Ok(parse)
+    }
+
     pub fn get_namespace(&self) -> packages::Namespace {
         let namespace_from_package = namespace_from_package_name(&self.name);
         match (self.namespace.as_ref(), self.namespace_entry.as_ref()) {
@@ -682,7 +699,7 @@ mod tests {
     }
 
     #[test]
-    fn test_dependencies() {
+    fn test_dependencies_deprecation() {
         let json = r#"
         {
             "name": "testrepo",
@@ -702,11 +719,15 @@ mod tests {
         "#;
 
         let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(config.dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(
+            config.dependency_info.dependencies.value,
+            Some(vec!["@testrepo/main".to_string()])
+        );
+        assert_eq!(config.dependency_info.dependencies.deprecation_warning, true)
     }
 
     #[test]
-    fn test_dependencies_alias() {
+    fn test_dependencies() {
         let json = r#"
         {
             "name": "testrepo",
@@ -726,11 +747,15 @@ mod tests {
         "#;
 
         let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(config.dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(
+            config.dependency_info.dependencies.value,
+            Some(vec!["@testrepo/main".to_string()])
+        );
+        assert_eq!(config.dependency_info.dependencies.deprecation_warning, false);
     }
 
     #[test]
-    fn test_dev_dependencies() {
+    fn test_dev_dependencies_deprecation() {
         let json = r#"
         {
             "name": "testrepo",
@@ -750,11 +775,15 @@ mod tests {
         "#;
 
         let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(config.dev_dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(
+            config.dependency_info.dev_dependencies.value,
+            Some(vec!["@testrepo/main".to_string()])
+        );
+        assert_eq!(config.dependency_info.dev_dependencies.deprecation_warning, true);
     }
 
     #[test]
-    fn test_dev_dependencies_alias() {
+    fn test_dev_dependencies() {
         let json = r#"
         {
             "name": "testrepo",
@@ -774,6 +803,10 @@ mod tests {
         "#;
 
         let config = serde_json::from_str::<Config>(json).unwrap();
-        assert_eq!(config.dev_dependencies, Some(vec!["@testrepo/main".to_string()]));
+        assert_eq!(
+            config.dependency_info.dev_dependencies.value,
+            Some(vec!["@testrepo/main".to_string()])
+        );
+        assert_eq!(config.dependency_info.dev_dependencies.deprecation_warning, false);
     }
 }

rewatch/src/helpers.rs

@@ -9,6 +9,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 pub type StdErr = String;
 
+pub mod deprecation_registry;
 pub mod deserialize;
 
 pub mod emojis {

rewatch/src/helpers/deprecation_registry.rs

@@ -0,0 +1,44 @@
+use std::{
+    path::PathBuf,
+    sync::{Mutex, OnceLock},
+};
+
+use ahash::AHashSet;
+
+use super::StrippedVerbatimPath;
+
+type DeprecationKey = (String, PathBuf);
+
+static DEPRECATION_REGISTRY: OnceLock<Mutex<AHashSet<DeprecationKey>>> = OnceLock::new();
+
+fn get_registry() -> &'static Mutex<AHashSet<DeprecationKey>> {
+    DEPRECATION_REGISTRY.get_or_init(|| Mutex::new(AHashSet::new()))
+}
+
+pub fn log_deprecated_field(field_name: &str, replacement_field_name: &str, file_path: &PathBuf) {
+    let mut registry = match get_registry().lock() {
+        Ok(lock) => lock,
+        Err(e) => {
+            log::error!(
+                "Thread panicked while holding deprecation registry. This should never happen. Please report this as a bug."
+            );
+            e.into_inner()
+        }
+    };
+
+    let abs_path = file_path
+        .canonicalize()
+        .map(StrippedVerbatimPath::to_stripped_verbatim_path)
+        .unwrap_or_else(|_| file_path.to_path_buf())
+        .to_path_buf();
+
+    let key = (field_name.to_string(), abs_path);
+
+    if registry.insert(key) {
+        log::warn!(
+            "Deprecated use of field '{field_name}' found in {}.\n\
+            Use '{replacement_field_name}' instead. This field will be removed in a future version.",
+            file_path.display()
+        );
+    }
+}