dnx_core/

workspace.rs

use crate::catalog::{resolve_catalog_deps, CatalogConfig};
use crate::errors::{DnxError, Result};
use crate::package_json::PackageJson;
use std::collections::{HashMap, VecDeque};
use std::path::{Path, PathBuf};

/// A single workspace member (a package within the monorepo).
#[derive(Debug, Clone)]
pub struct WorkspaceMember {
    /// Absolute path to the member directory.
    pub path: PathBuf,
    /// Parsed package.json for this member.
    pub package_json: PackageJson,
    /// Package name (from package.json `name` field).
    pub name: String,
    /// Package version (from package.json `version` field).
    pub version: String,
}

/// Represents a discovered workspace (monorepo).
#[derive(Debug)]
pub struct Workspace {
    /// Absolute path to the workspace root directory.
    pub root: PathBuf,
    /// Root-level package.json.
    pub root_package_json: PackageJson,
    /// Glob patterns that define workspace members.
    pub patterns: Vec<String>,
    /// Discovered members keyed by package name.
    pub members: HashMap<String, WorkspaceMember>,
    /// Topologically sorted member names (dependencies before dependents).
    pub topo_order: Vec<String>,
}

/// Config loaded from `dnx-workspace.toml` as a fallback when the root
/// `package.json` does not contain a `workspaces` field.
#[derive(Debug, serde::Deserialize)]
struct WorkspaceToml {
    packages: Vec<String>,
}

impl Workspace {
    /// Discover workspace members starting from the given root directory.
    ///
    /// Returns `Ok(None)` if this is a plain (non-workspace) project.
    pub fn discover(root: &Path) -> Result<Option<Self>> {
        let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());

        let pkg_path = root.join("package.json");
        if !pkg_path.exists() {
            return Ok(None);
        }

        let root_pkg = PackageJson::read(&pkg_path)?;

        // Determine workspace patterns — priority: dnx.toml > package.json > dnx-workspace.toml
        let config = crate::config::DnxConfig::load(&root);
        let patterns = if let Some(ref ws_patterns) = config.workspace_patterns {
            if !ws_patterns.is_empty() {
                ws_patterns.clone()
            } else if let Some(ref ws) = root_pkg.workspaces {
                ws.clone()
            } else {
                return Ok(None);
            }
        } else if let Some(ref ws) = root_pkg.workspaces {
            ws.clone()
        } else {
            // Fallback: check dnx-workspace.toml
            let toml_path = root.join("dnx-workspace.toml");
            if toml_path.exists() {
                let content = std::fs::read_to_string(&toml_path).map_err(|e| {
                    DnxError::Workspace(format!("Failed to read {}: {}", toml_path.display(), e))
                })?;
                let ws_toml: WorkspaceToml = toml::from_str(&content).map_err(|e| {
                    DnxError::Workspace(format!("Failed to parse {}: {}", toml_path.display(), e))
                })?;
                ws_toml.packages
            } else {
                // Not a workspace project
                return Ok(None);
            }
        };

        if patterns.is_empty() {
            return Ok(None);
        }

        // Expand glob patterns and discover members
        let mut members = HashMap::new();

        for pattern in &patterns {
            // Convert the pattern to an absolute glob
            let abs_pattern = root.join(pattern).to_string_lossy().to_string();
            // On Windows, glob needs forward slashes
            let abs_pattern = abs_pattern.replace('\\', "/");

            let entries = glob::glob(&abs_pattern).map_err(|e| {
                DnxError::Workspace(format!("Invalid glob pattern '{}': {}", pattern, e))
            })?;

            for entry in entries {
                let member_dir =
                    entry.map_err(|e| DnxError::Workspace(format!("Glob error: {}", e)))?;

                if !member_dir.is_dir() {
                    continue;
                }

                let member_pkg_path = member_dir.join("package.json");
                if !member_pkg_path.exists() {
                    continue;
                }

                let member_pkg = PackageJson::read(&member_pkg_path)?;
                let name = member_pkg.name.clone().ok_or_else(|| {
                    DnxError::Workspace(format!(
                        "Workspace member at {} has no 'name' field in package.json",
                        member_dir.display()
                    ))
                })?;

                let version = member_pkg
                    .version
                    .clone()
                    .unwrap_or_else(|| "0.0.0".to_string());

                // Check for duplicate names
                if members.contains_key(&name) {
                    return Err(DnxError::Workspace(format!(
                        "Duplicate workspace member name '{}' at {}",
                        name,
                        member_dir.display()
                    )));
                }

                let abs_member_dir = member_dir
                    .canonicalize()
                    .unwrap_or_else(|_| member_dir.clone());

                members.insert(
                    name.clone(),
                    WorkspaceMember {
                        path: abs_member_dir,
                        package_json: member_pkg,
                        name: name.clone(),
                        version,
                    },
                );
            }
        }

        // Compute topological order
        let topo_order = compute_topo_order(&members)?;

        Ok(Some(Workspace {
            root,
            root_package_json: root_pkg,
            patterns,
            members,
            topo_order,
        }))
    }

    /// Return all external dependencies across all workspace members,
    /// filtering out `workspace:` and `catalog:` references.
    /// Deduplicates by keeping the first seen version range for each package.
    pub fn all_external_deps(&self) -> HashMap<String, String> {
        let mut deps = HashMap::new();
        for member in self.members.values() {
            let all = member.package_json.all_dependencies();
            for (name, spec) in all {
                if spec.starts_with("workspace:") || spec.starts_with("catalog:") {
                    continue;
                }
                // Skip deps that are workspace members
                if self.members.contains_key(&name) {
                    continue;
                }
                deps.entry(name).or_insert(spec);
            }
        }
        // Also include root-level deps (if any)
        let root_deps = self.root_package_json.all_dependencies();
        for (name, spec) in root_deps {
            if spec.starts_with("workspace:") || spec.starts_with("catalog:") {
                continue;
            }
            if self.members.contains_key(&name) {
                continue;
            }
            deps.entry(name).or_insert(spec);
        }
        deps
    }

    /// Return all external dependencies for all members, resolving
    /// `catalog:` references using the provided catalog config.
    pub fn all_external_deps_with_catalog(
        &self,
        catalog: Option<&CatalogConfig>,
    ) -> Result<HashMap<String, String>> {
        let mut deps = HashMap::new();

        for member in self.members.values() {
            let all = member.package_json.all_dependencies();
            let resolved = if let Some(cat) = catalog {
                resolve_catalog_deps(&all, cat)?
            } else {
                all
            };

            for (name, spec) in resolved {
                if spec.starts_with("workspace:") {
                    continue;
                }
                if self.members.contains_key(&name) {
                    continue;
                }
                deps.entry(name).or_insert(spec);
            }
        }

        // Root-level deps
        let root_deps = self.root_package_json.all_dependencies();
        let resolved_root = if let Some(cat) = catalog {
            resolve_catalog_deps(&root_deps, cat)?
        } else {
            root_deps
        };
        for (name, spec) in resolved_root {
            if spec.starts_with("workspace:") {
                continue;
            }
            if self.members.contains_key(&name) {
                continue;
            }
            deps.entry(name).or_insert(spec);
        }

        Ok(deps)
    }

    /// Build the internal dependency graph: adjacency list of
    /// workspace member name → list of workspace member names it depends on.
    pub fn internal_dep_graph(&self) -> HashMap<String, Vec<String>> {
        let mut graph: HashMap<String, Vec<String>> = HashMap::new();
        for (name, member) in &self.members {
            let mut internal_deps = Vec::new();
            let all = member.package_json.all_dependencies();
            for (dep_name, spec) in &all {
                if spec.starts_with("workspace:") || self.members.contains_key(dep_name) {
                    internal_deps.push(dep_name.clone());
                }
            }
            graph.insert(name.clone(), internal_deps);
        }
        graph
    }

    /// Filter workspace members by a glob pattern matched against their
    /// relative path from the root.
    pub fn filter(&self, pattern: &str) -> Result<Vec<String>> {
        let glob_pattern = glob::Pattern::new(pattern).map_err(|e| {
            DnxError::Workspace(format!("Invalid filter pattern '{}': {}", pattern, e))
        })?;

        let mut matched = Vec::new();
        for (name, member) in &self.members {
            let relative = member.path.strip_prefix(&self.root).unwrap_or(&member.path);
            let relative_str = relative.to_string_lossy().replace('\\', "/");
            if glob_pattern.matches(&relative_str) || glob_pattern.matches(name) {
                matched.push(name.clone());
            }
        }
        Ok(matched)
    }

    /// Return resolved external deps for a single member.
    /// Workspace refs are resolved to the member's version, catalog refs
    /// are resolved via the catalog config.
    pub fn member_external_deps(
        &self,
        member_name: &str,
        catalog: Option<&CatalogConfig>,
    ) -> Result<HashMap<String, String>> {
        let member = self
            .members
            .get(member_name)
            .ok_or_else(|| DnxError::Workspace(format!("Member '{}' not found", member_name)))?;

        let all = member.package_json.all_dependencies();
        let resolved = if let Some(cat) = catalog {
            resolve_catalog_deps(&all, cat)?
        } else {
            all
        };

        let mut external = HashMap::new();
        for (name, spec) in resolved {
            if spec.starts_with("workspace:") {
                continue;
            }
            if self.members.contains_key(&name) {
                continue;
            }
            external.insert(name, spec);
        }
        Ok(external)
    }

    /// Build a map of workspace package name → (version, path) for resolver.
    pub fn workspace_packages_map(&self) -> HashMap<String, (String, PathBuf)> {
        self.members
            .iter()
            .map(|(name, m)| (name.clone(), (m.version.clone(), m.path.clone())))
            .collect()
    }
}

/// Compute topological order of workspace members using Kahn's algorithm.
/// Detects cycles and returns an error if one is found.
fn compute_topo_order(members: &HashMap<String, WorkspaceMember>) -> Result<Vec<String>> {
    // Build adjacency list using owned strings to avoid lifetime issues.
    let mut in_degree: HashMap<String, usize> = HashMap::new();
    let mut dependents: HashMap<String, Vec<String>> = HashMap::new();

    for name in members.keys() {
        in_degree.insert(name.clone(), 0);
        dependents.entry(name.clone()).or_default();
    }

    for (name, member) in members {
        let all = member.package_json.all_dependencies();
        for (dep_name, spec) in &all {
            let is_workspace_dep = spec.starts_with("workspace:") || members.contains_key(dep_name);
            if is_workspace_dep && members.contains_key(dep_name) {
                *in_degree.entry(name.clone()).or_insert(0) += 1;
                dependents
                    .entry(dep_name.clone())
                    .or_default()
                    .push(name.clone());
            }
        }
    }

    let mut queue: VecDeque<String> = VecDeque::new();
    for (name, &degree) in &in_degree {
        if degree == 0 {
            queue.push_back(name.clone());
        }
    }

    let mut order = Vec::with_capacity(members.len());

    while let Some(name) = queue.pop_front() {
        let deps_to_process = dependents.get(&name).cloned().unwrap_or_default();
        order.push(name);
        for dep in deps_to_process {
            let degree = in_degree.get_mut(&dep).unwrap();
            *degree -= 1;
            if *degree == 0 {
                queue.push_back(dep);
            }
        }
    }

    if order.len() != members.len() {
        let remaining: Vec<_> = members
            .keys()
            .filter(|n| !order.contains(n))
            .cloned()
            .collect();
        return Err(DnxError::Workspace(format!(
            "Circular dependency detected among workspace members: {}",
            remaining.join(", ")
        )));
    }

    Ok(order)
}

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

    fn make_member(name: &str, version: &str, deps: HashMap<String, String>) -> WorkspaceMember {
        WorkspaceMember {
            path: PathBuf::from(format!("/workspace/packages/{}", name)),
            package_json: PackageJson {
                name: Some(name.to_string()),
                version: Some(version.to_string()),
                description: None,
                main: None,
                license: None,
                dependencies: if deps.is_empty() { None } else { Some(deps) },
                dev_dependencies: None,
                peer_dependencies: None,
                optional_dependencies: None,
                scripts: None,
                bin: None,
                engines: None,
                private: None,
                overrides: None,
                resolutions: None,
                workspaces: None,
            },
            name: name.to_string(),
            version: version.to_string(),
        }
    }

    #[test]
    fn test_topo_order_simple() {
        let mut members = HashMap::new();

        let mut b_deps = HashMap::new();
        b_deps.insert("a".to_string(), "workspace:*".to_string());

        members.insert("a".to_string(), make_member("a", "1.0.0", HashMap::new()));
        members.insert("b".to_string(), make_member("b", "1.0.0", b_deps));

        let order = compute_topo_order(&members).unwrap();
        let a_idx = order.iter().position(|n| n == "a").unwrap();
        let b_idx = order.iter().position(|n| n == "b").unwrap();
        assert!(a_idx < b_idx, "a should come before b");
    }

    #[test]
    fn test_topo_order_cycle() {
        let mut members = HashMap::new();

        let mut a_deps = HashMap::new();
        a_deps.insert("b".to_string(), "workspace:*".to_string());
        let mut b_deps = HashMap::new();
        b_deps.insert("a".to_string(), "workspace:*".to_string());

        members.insert("a".to_string(), make_member("a", "1.0.0", a_deps));
        members.insert("b".to_string(), make_member("b", "1.0.0", b_deps));

        let result = compute_topo_order(&members);
        assert!(result.is_err());
        let err = result.unwrap_err().to_string();
        assert!(err.contains("Circular dependency"));
    }

    #[test]
    fn test_topo_order_diamond() {
        // d depends on b and c, both depend on a
        let mut members = HashMap::new();

        let mut b_deps = HashMap::new();
        b_deps.insert("a".to_string(), "workspace:*".to_string());
        let mut c_deps = HashMap::new();
        c_deps.insert("a".to_string(), "workspace:*".to_string());
        let mut d_deps = HashMap::new();
        d_deps.insert("b".to_string(), "workspace:*".to_string());
        d_deps.insert("c".to_string(), "workspace:*".to_string());

        members.insert("a".to_string(), make_member("a", "1.0.0", HashMap::new()));
        members.insert("b".to_string(), make_member("b", "1.0.0", b_deps));
        members.insert("c".to_string(), make_member("c", "1.0.0", c_deps));
        members.insert("d".to_string(), make_member("d", "1.0.0", d_deps));

        let order = compute_topo_order(&members).unwrap();
        assert_eq!(order.len(), 4);
        let a_idx = order.iter().position(|n| n == "a").unwrap();
        let b_idx = order.iter().position(|n| n == "b").unwrap();
        let c_idx = order.iter().position(|n| n == "c").unwrap();
        let d_idx = order.iter().position(|n| n == "d").unwrap();
        assert!(a_idx < b_idx);
        assert!(a_idx < c_idx);
        assert!(b_idx < d_idx);
        assert!(c_idx < d_idx);
    }

    #[test]
    fn test_all_external_deps() {
        let mut members = HashMap::new();

        let mut a_deps = HashMap::new();
        a_deps.insert("react".to_string(), "^18.0.0".to_string());
        a_deps.insert("b".to_string(), "workspace:*".to_string());

        let mut b_deps = HashMap::new();
        b_deps.insert("lodash".to_string(), "^4.17.21".to_string());
        b_deps.insert("react".to_string(), "^18.0.0".to_string());

        members.insert("a".to_string(), make_member("a", "1.0.0", a_deps));
        members.insert("b".to_string(), make_member("b", "1.0.0", b_deps));

        let ws = Workspace {
            root: PathBuf::from("/workspace"),
            root_package_json: PackageJson {
                name: Some("root".to_string()),
                version: Some("1.0.0".to_string()),
                description: None,
                main: None,
                license: None,
                dependencies: None,
                dev_dependencies: None,
                peer_dependencies: None,
                optional_dependencies: None,
                scripts: None,
                bin: None,
                engines: None,
                private: None,
                overrides: None,
                resolutions: None,
                workspaces: Some(vec!["packages/*".to_string()]),
            },
            patterns: vec!["packages/*".to_string()],
            members,
            topo_order: vec!["b".to_string(), "a".to_string()],
        };

        let external = ws.all_external_deps();
        assert!(external.contains_key("react"));
        assert!(external.contains_key("lodash"));
        assert!(!external.contains_key("a"));
        assert!(!external.contains_key("b"));
    }

    #[test]
    fn test_internal_dep_graph() {
        let mut members = HashMap::new();

        let mut a_deps = HashMap::new();
        a_deps.insert("b".to_string(), "workspace:*".to_string());

        members.insert("a".to_string(), make_member("a", "1.0.0", a_deps));
        members.insert("b".to_string(), make_member("b", "1.0.0", HashMap::new()));

        let ws = Workspace {
            root: PathBuf::from("/workspace"),
            root_package_json: PackageJson {
                name: Some("root".to_string()),
                version: Some("1.0.0".to_string()),
                description: None,
                main: None,
                license: None,
                dependencies: None,
                dev_dependencies: None,
                peer_dependencies: None,
                optional_dependencies: None,
                scripts: None,
                bin: None,
                engines: None,
                private: None,
                overrides: None,
                resolutions: None,
                workspaces: Some(vec!["packages/*".to_string()]),
            },
            patterns: vec!["packages/*".to_string()],
            members,
            topo_order: vec!["b".to_string(), "a".to_string()],
        };

        let graph = ws.internal_dep_graph();
        assert_eq!(graph["a"], vec!["b".to_string()]);
        assert!(graph["b"].is_empty());
    }

    #[test]
    fn test_filter_by_path() {
        let mut members = HashMap::new();

        members.insert(
            "app".to_string(),
            WorkspaceMember {
                path: PathBuf::from("/workspace/apps/app"),
                package_json: PackageJson {
                    name: Some("app".to_string()),
                    version: Some("1.0.0".to_string()),
                    description: None,
                    main: None,
                    license: None,
                    dependencies: None,
                    dev_dependencies: None,
                    peer_dependencies: None,
                    optional_dependencies: None,
                    scripts: None,
                    bin: None,
                    engines: None,
                    private: None,
                    overrides: None,
                    resolutions: None,
                    workspaces: None,
                },
                name: "app".to_string(),
                version: "1.0.0".to_string(),
            },
        );
        members.insert(
            "lib".to_string(),
            WorkspaceMember {
                path: PathBuf::from("/workspace/packages/lib"),
                package_json: PackageJson {
                    name: Some("lib".to_string()),
                    version: Some("1.0.0".to_string()),
                    description: None,
                    main: None,
                    license: None,
                    dependencies: None,
                    dev_dependencies: None,
                    peer_dependencies: None,
                    optional_dependencies: None,
                    scripts: None,
                    bin: None,
                    engines: None,
                    private: None,
                    overrides: None,
                    resolutions: None,
                    workspaces: None,
                },
                name: "lib".to_string(),
                version: "1.0.0".to_string(),
            },
        );

        let ws = Workspace {
            root: PathBuf::from("/workspace"),
            root_package_json: PackageJson {
                name: Some("root".to_string()),
                version: Some("1.0.0".to_string()),
                description: None,
                main: None,
                license: None,
                dependencies: None,
                dev_dependencies: None,
                peer_dependencies: None,
                optional_dependencies: None,
                scripts: None,
                bin: None,
                engines: None,
                private: None,
                overrides: None,
                resolutions: None,
                workspaces: None,
            },
            patterns: vec![],
            members,
            topo_order: vec!["lib".to_string(), "app".to_string()],
        };

        let matched = ws.filter("apps/*").unwrap();
        assert_eq!(matched, vec!["app".to_string()]);

        let matched = ws.filter("packages/*").unwrap();
        assert_eq!(matched, vec!["lib".to_string()]);
    }
}