affected_core/resolvers/

yarn.rs

use anyhow::{Context, Result};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::Path;

use crate::resolvers::{file_to_package, Resolver};
use crate::types::{Ecosystem, Package, PackageId, ProjectGraph};

/// YarnResolver detects Yarn Berry (v2/v3/v4) workspaces via `.yarnrc.yml`.
///
/// Parsing is the same as npm (package.json workspaces) but test commands use `yarn`.
/// Detection: `.yarnrc.yml` exists at root (takes priority over NpmResolver).
pub struct YarnResolver;
impl super::sealed::Sealed for YarnResolver {}

#[derive(Deserialize)]
struct RootPackageJson {
    workspaces: Option<WorkspacesField>,
}

#[derive(Deserialize)]
#[serde(untagged)]
enum WorkspacesField {
    Array(Vec<String>),
    Object { packages: Vec<String> },
}

#[derive(Deserialize)]
struct PackageJson {
    name: Option<String>,
    version: Option<String>,
    dependencies: Option<HashMap<String, String>>,
    #[serde(rename = "devDependencies")]
    dev_dependencies: Option<HashMap<String, String>>,
}

impl Resolver for YarnResolver {
    fn ecosystem(&self) -> Ecosystem {
        Ecosystem::Yarn
    }

    fn detect(&self, root: &Path) -> bool {
        root.join(".yarnrc.yml").exists()
    }

    fn resolve(&self, root: &Path) -> Result<ProjectGraph> {
        let workspace_globs = self.find_workspace_globs(root)?;
        let pkg_dirs = self.expand_globs(root, &workspace_globs)?;

        tracing::debug!(
            "Yarn: found {} workspace globs, {} package directories",
            workspace_globs.len(),
            pkg_dirs.len()
        );

        // Parse all workspace packages
        let mut packages = HashMap::new();
        let mut name_to_id = HashMap::new();

        for dir in &pkg_dirs {
            let pkg_json_path = dir.join("package.json");
            if !pkg_json_path.exists() {
                continue;
            }

            let content = std::fs::read_to_string(&pkg_json_path)
                .with_context(|| format!("Failed to read {}", pkg_json_path.display()))?;
            let pkg: PackageJson = serde_json::from_str(&content)
                .with_context(|| format!("Failed to parse {}", pkg_json_path.display()))?;

            let name = match &pkg.name {
                Some(n) => n.clone(),
                None => continue,
            };

            tracing::debug!("Yarn: discovered package '{}'", name);

            let pkg_id = PackageId(name.clone());
            name_to_id.insert(name.clone(), pkg_id.clone());
            packages.insert(
                pkg_id.clone(),
                Package {
                    id: pkg_id,
                    name: name.clone(),
                    version: pkg.version.clone(),
                    path: dir.clone(),
                    manifest_path: pkg_json_path,
                },
            );
        }

        // Build dependency edges
        let mut edges = Vec::new();
        let workspace_names: std::collections::HashSet<&str> =
            name_to_id.keys().map(|s| s.as_str()).collect();

        for dir in &pkg_dirs {
            let pkg_json_path = dir.join("package.json");
            if !pkg_json_path.exists() {
                continue;
            }

            let content = std::fs::read_to_string(&pkg_json_path)?;
            let pkg: PackageJson = serde_json::from_str(&content)?;

            let from_name = match &pkg.name {
                Some(n) => n.clone(),
                None => continue,
            };

            // Check both dependencies and devDependencies
            let all_deps: Vec<&str> = pkg
                .dependencies
                .iter()
                .flat_map(|d| d.keys())
                .chain(pkg.dev_dependencies.iter().flat_map(|d| d.keys()))
                .map(|s| s.as_str())
                .collect();

            for dep_name in all_deps {
                if workspace_names.contains(dep_name) {
                    edges.push((
                        PackageId(from_name.clone()),
                        PackageId(dep_name.to_string()),
                    ));
                }
            }
        }

        Ok(ProjectGraph {
            packages,
            edges,
            root: root.to_path_buf(),
        })
    }

    fn package_for_file(&self, graph: &ProjectGraph, file: &Path) -> Option<PackageId> {
        file_to_package(graph, file)
    }

    fn test_command(&self, package_id: &PackageId) -> Vec<String> {
        vec![
            "yarn".into(),
            "workspace".into(),
            package_id.0.clone(),
            "run".into(),
            "test".into(),
        ]
    }
}

impl YarnResolver {
    fn find_workspace_globs(&self, root: &Path) -> Result<Vec<String>> {
        let pkg_path = root.join("package.json");
        let content = std::fs::read_to_string(&pkg_path)
            .context("No package.json found for Yarn workspace")?;
        let root_pkg: RootPackageJson =
            serde_json::from_str(&content).context("Failed to parse root package.json")?;

        match root_pkg.workspaces {
            Some(WorkspacesField::Array(globs)) => Ok(globs),
            Some(WorkspacesField::Object { packages }) => Ok(packages),
            None => anyhow::bail!("No workspaces field found in package.json"),
        }
    }

    fn expand_globs(&self, root: &Path, globs: &[String]) -> Result<Vec<std::path::PathBuf>> {
        let mut dirs = Vec::new();

        for pattern in globs {
            let full_pattern = root.join(pattern).join("package.json");
            let pattern_str = full_pattern.to_str().unwrap_or("");

            match glob::glob(pattern_str) {
                Ok(paths) => {
                    for entry in paths.filter_map(|p| p.ok()) {
                        if let Some(parent) = entry.parent() {
                            dirs.push(parent.to_path_buf());
                        }
                    }
                }
                Err(_) => continue,
            }
        }

        Ok(dirs)
    }
}

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

    fn create_yarn_workspace(dir: &std::path::Path) {
        // .yarnrc.yml to mark it as a Yarn Berry project
        std::fs::write(
            dir.join(".yarnrc.yml"),
            "nodeLinker: node-modules\nyarnPath: .yarn/releases/yarn-4.0.0.cjs\n",
        )
        .unwrap();

        // Root package.json with workspaces
        std::fs::write(
            dir.join("package.json"),
            r#"{"name": "root", "workspaces": ["packages/*"]}"#,
        )
        .unwrap();

        // Package A depends on Package B
        std::fs::create_dir_all(dir.join("packages/pkg-a")).unwrap();
        std::fs::write(
            dir.join("packages/pkg-a/package.json"),
            r#"{"name": "@scope/pkg-a", "version": "1.0.0", "dependencies": {"@scope/pkg-b": "workspace:*"}}"#,
        )
        .unwrap();

        // Package B (no deps)
        std::fs::create_dir_all(dir.join("packages/pkg-b")).unwrap();
        std::fs::write(
            dir.join("packages/pkg-b/package.json"),
            r#"{"name": "@scope/pkg-b", "version": "1.0.0"}"#,
        )
        .unwrap();
    }

    #[test]
    fn test_detect_yarn_workspace() {
        let dir = tempfile::tempdir().unwrap();
        create_yarn_workspace(dir.path());
        assert!(YarnResolver.detect(dir.path()));
    }

    #[test]
    fn test_detect_no_yarnrc() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("package.json"),
            r#"{"name": "root", "workspaces": ["packages/*"]}"#,
        )
        .unwrap();
        assert!(!YarnResolver.detect(dir.path()));
    }

    #[test]
    fn test_detect_empty_dir() {
        let dir = tempfile::tempdir().unwrap();
        assert!(!YarnResolver.detect(dir.path()));
    }

    #[test]
    fn test_resolve_yarn_workspace() {
        let dir = tempfile::tempdir().unwrap();
        create_yarn_workspace(dir.path());

        let graph = YarnResolver.resolve(dir.path()).unwrap();
        assert_eq!(graph.packages.len(), 2);
        assert!(graph
            .packages
            .contains_key(&PackageId("@scope/pkg-a".into())));
        assert!(graph
            .packages
            .contains_key(&PackageId("@scope/pkg-b".into())));

        // pkg-a depends on pkg-b
        assert!(graph.edges.contains(&(
            PackageId("@scope/pkg-a".into()),
            PackageId("@scope/pkg-b".into()),
        )));
    }

    #[test]
    fn test_resolve_yarn_no_edges_when_no_internal_deps() {
        let dir = tempfile::tempdir().unwrap();

        std::fs::write(dir.path().join(".yarnrc.yml"), "nodeLinker: node-modules\n").unwrap();

        std::fs::write(
            dir.path().join("package.json"),
            r#"{"name": "root", "workspaces": ["packages/*"]}"#,
        )
        .unwrap();

        std::fs::create_dir_all(dir.path().join("packages/foo")).unwrap();
        std::fs::write(
            dir.path().join("packages/foo/package.json"),
            r#"{"name": "foo", "version": "1.0.0"}"#,
        )
        .unwrap();

        std::fs::create_dir_all(dir.path().join("packages/bar")).unwrap();
        std::fs::write(
            dir.path().join("packages/bar/package.json"),
            r#"{"name": "bar", "version": "1.0.0"}"#,
        )
        .unwrap();

        let graph = YarnResolver.resolve(dir.path()).unwrap();
        assert_eq!(graph.packages.len(), 2);
        assert!(graph.edges.is_empty());
    }

    #[test]
    fn test_resolve_yarn_dev_dependencies_create_edges() {
        let dir = tempfile::tempdir().unwrap();

        std::fs::write(dir.path().join(".yarnrc.yml"), "nodeLinker: node-modules\n").unwrap();

        std::fs::write(
            dir.path().join("package.json"),
            r#"{"name": "root", "workspaces": ["packages/*"]}"#,
        )
        .unwrap();

        std::fs::create_dir_all(dir.path().join("packages/lib")).unwrap();
        std::fs::write(
            dir.path().join("packages/lib/package.json"),
            r#"{"name": "lib", "version": "1.0.0"}"#,
        )
        .unwrap();

        std::fs::create_dir_all(dir.path().join("packages/app")).unwrap();
        std::fs::write(
            dir.path().join("packages/app/package.json"),
            r#"{"name": "app", "version": "1.0.0", "devDependencies": {"lib": "workspace:*"}}"#,
        )
        .unwrap();

        let graph = YarnResolver.resolve(dir.path()).unwrap();
        assert!(graph
            .edges
            .contains(&(PackageId("app".into()), PackageId("lib".into()),)));
    }

    #[test]
    fn test_test_command() {
        let cmd = YarnResolver.test_command(&PackageId("my-pkg".into()));
        assert_eq!(cmd, vec!["yarn", "workspace", "my-pkg", "run", "test"]);
    }

    #[test]
    fn test_expand_globs() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(dir.path().join("packages/a")).unwrap();
        std::fs::write(dir.path().join("packages/a/package.json"), "{}").unwrap();
        std::fs::create_dir_all(dir.path().join("packages/b")).unwrap();
        std::fs::write(dir.path().join("packages/b/package.json"), "{}").unwrap();

        let globs = vec!["packages/*".to_string()];
        let dirs = YarnResolver.expand_globs(dir.path(), &globs).unwrap();
        assert_eq!(dirs.len(), 2);
    }

    #[test]
    fn test_workspaces_object_form() {
        let dir = tempfile::tempdir().unwrap();

        std::fs::write(dir.path().join(".yarnrc.yml"), "nodeLinker: node-modules\n").unwrap();

        std::fs::write(
            dir.path().join("package.json"),
            r#"{"name": "root", "workspaces": {"packages": ["packages/*"]}}"#,
        )
        .unwrap();

        std::fs::create_dir_all(dir.path().join("packages/a")).unwrap();
        std::fs::write(
            dir.path().join("packages/a/package.json"),
            r#"{"name": "a", "version": "1.0.0"}"#,
        )
        .unwrap();

        let graph = YarnResolver.resolve(dir.path()).unwrap();
        assert_eq!(graph.packages.len(), 1);
        assert!(graph.packages.contains_key(&PackageId("a".into())));
    }
}