dnx_core/

catalog.rs

use crate::config::DnxConfig;
use crate::errors::{DnxError, Result};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::Path;

/// Catalog configuration loaded from `dnx.toml` `[catalog]`/`[catalogs.*]`
/// sections, or falling back to `dnx.catalog.toml`.
///
/// Allows centralised version management across workspace members.
/// Members reference versions via `"catalog:"` (default group) or
/// `"catalog:<group>"` (named group).
#[derive(Debug, Clone, Deserialize)]
pub struct CatalogConfig {
    /// Default catalog entries: package name → version range.
    #[serde(default)]
    pub default: HashMap<String, String>,
    /// Named catalog groups: group name → { package name → version range }.
    #[serde(default)]
    pub named: HashMap<String, HashMap<String, String>>,
}

impl CatalogConfig {
    /// Load catalog config, checking multiple sources in order:
    /// 1. `dnx.toml` `[catalog]` and `[catalogs.*]` sections (via DnxConfig)
    /// 2. `dnx.catalog.toml` (legacy)
    ///
    /// Returns `Ok(None)` if no catalog configuration is found.
    pub fn load(root: &Path) -> Result<Option<Self>> {
        // First, try loading from dnx.toml via DnxConfig
        let config = DnxConfig::load(root);
        if !config.catalog_default.is_empty() || !config.catalog_named.is_empty() {
            return Ok(Some(CatalogConfig {
                default: config.catalog_default,
                named: config.catalog_named,
            }));
        }

        // Fallback: dnx.catalog.toml
        Self::load_from_catalog_toml(root)
    }

    /// Load catalog config from `dnx.catalog.toml` only (legacy support).
    /// Returns `Ok(None)` if the file does not exist.
    pub fn load_from_catalog_toml(root: &Path) -> Result<Option<Self>> {
        let path = root.join("dnx.catalog.toml");
        if !path.exists() {
            return Ok(None);
        }

        let content = std::fs::read_to_string(&path)
            .map_err(|e| DnxError::Catalog(format!("Failed to read {}: {}", path.display(), e)))?;

        let config: CatalogConfig = toml::from_str(&content)
            .map_err(|e| DnxError::Catalog(format!("Failed to parse {}: {}", path.display(), e)))?;

        Ok(Some(config))
    }

    /// Create a CatalogConfig directly from default and named maps.
    pub fn from_maps(
        default: HashMap<String, String>,
        named: HashMap<String, HashMap<String, String>>,
    ) -> Self {
        Self { default, named }
    }

    /// Resolve a `catalog:` specifier for the given package name.
    ///
    /// - `"catalog:"` → look up `pkg_name` in `default`
    /// - `"catalog:testing"` → look up `pkg_name` in `named.testing`
    pub fn resolve(&self, pkg_name: &str, spec: &str) -> Result<String> {
        let suffix = spec
            .strip_prefix("catalog:")
            .ok_or_else(|| DnxError::Catalog(format!("Not a catalog specifier: {}", spec)))?;

        if suffix.is_empty() {
            // Default catalog
            self.default.get(pkg_name).cloned().ok_or_else(|| {
                DnxError::Catalog(format!(
                    "Package '{}' not found in default catalog",
                    pkg_name
                ))
            })
        } else {
            // Named catalog group
            let group = self.named.get(suffix).ok_or_else(|| {
                DnxError::Catalog(format!("Catalog group '{}' not found", suffix))
            })?;
            group.get(pkg_name).cloned().ok_or_else(|| {
                DnxError::Catalog(format!(
                    "Package '{}' not found in catalog group '{}'",
                    pkg_name, suffix
                ))
            })
        }
    }
}

/// Resolve all `catalog:` references in a dependency map, returning a new map
/// with catalog references replaced by their resolved version ranges.
pub fn resolve_catalog_deps(
    deps: &HashMap<String, String>,
    catalog: &CatalogConfig,
) -> Result<HashMap<String, String>> {
    let mut resolved = HashMap::with_capacity(deps.len());
    for (name, spec) in deps {
        if spec.starts_with("catalog:") {
            resolved.insert(name.clone(), catalog.resolve(name, spec)?);
        } else {
            resolved.insert(name.clone(), spec.clone());
        }
    }
    Ok(resolved)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_catalog() -> CatalogConfig {
        let mut default = HashMap::new();
        default.insert("react".to_string(), "^18.3.1".to_string());
        default.insert("typescript".to_string(), "^5.4.0".to_string());
        default.insert("lodash".to_string(), "^4.17.21".to_string());

        let mut testing = HashMap::new();
        testing.insert("jest".to_string(), "^29.0.0".to_string());
        testing.insert("vitest".to_string(), "^1.0.0".to_string());

        let mut named = HashMap::new();
        named.insert("testing".to_string(), testing);

        CatalogConfig { default, named }
    }

    #[test]
    fn test_resolve_default_catalog() {
        let catalog = make_catalog();
        assert_eq!(catalog.resolve("react", "catalog:").unwrap(), "^18.3.1");
    }

    #[test]
    fn test_resolve_named_catalog() {
        let catalog = make_catalog();
        assert_eq!(
            catalog.resolve("jest", "catalog:testing").unwrap(),
            "^29.0.0"
        );
    }

    #[test]
    fn test_resolve_missing_package() {
        let catalog = make_catalog();
        assert!(catalog.resolve("nonexistent", "catalog:").is_err());
    }

    #[test]
    fn test_resolve_missing_group() {
        let catalog = make_catalog();
        assert!(catalog.resolve("jest", "catalog:nope").is_err());
    }

    #[test]
    fn test_resolve_catalog_deps() {
        let catalog = make_catalog();
        let mut deps = HashMap::new();
        deps.insert("react".to_string(), "catalog:".to_string());
        deps.insert("jest".to_string(), "catalog:testing".to_string());
        deps.insert("axios".to_string(), "^1.6.0".to_string());

        let resolved = resolve_catalog_deps(&deps, &catalog).unwrap();
        assert_eq!(resolved["react"], "^18.3.1");
        assert_eq!(resolved["jest"], "^29.0.0");
        assert_eq!(resolved["axios"], "^1.6.0");
    }

    #[test]
    fn test_from_maps() {
        let mut default = HashMap::new();
        default.insert("react".to_string(), "^18.0.0".to_string());
        let catalog = CatalogConfig::from_maps(default, HashMap::new());
        assert_eq!(catalog.resolve("react", "catalog:").unwrap(), "^18.0.0");
    }

    #[test]
    fn test_load_missing_file() {
        let result = CatalogConfig::load_from_catalog_toml(Path::new("/nonexistent"));
        assert!(result.unwrap().is_none());
    }
}