chore(turbo): rename WorkspaceNode to PackageNode (#7351)

crates/turborepo-lib/src/commands/info.rs

@@ -6,7 +6,7 @@
 use serde::Serialize;
 use turbopath::AnchoredSystemPath;
 use turborepo_repository::{
-    package_graph::{PackageGraph, WorkspaceName, WorkspaceNode},
+    package_graph::{PackageGraph, PackageNode, WorkspaceName},
     package_json::PackageJson,
     package_manager::PackageManager,
 };
@@ -150,22 +150,22 @@ impl<'a> RepositoryDetails<'a> {
 impl<'a> WorkspaceDetails<'a> {
     fn new(package_graph: &'a PackageGraph, workspace_name: &'a str) -> Self {
         let workspace_node = match workspace_name {
-            "//" => WorkspaceNode::Root,
-            name => WorkspaceNode::Workspace(WorkspaceName::Other(name.to_string())),
+            "//" => PackageNode::Root,
+            name => PackageNode::Workspace(WorkspaceName::Other(name.to_string())),
         };
 
         let transitive_dependencies = package_graph.transitive_closure(Some(&workspace_node));
 
         let mut workspace_dep_names: Vec<&str> = transitive_dependencies
             .into_iter()
             .filter_map(|dependency| match dependency {
-                WorkspaceNode::Root | WorkspaceNode::Workspace(WorkspaceName::Root) => Some("root"),
-                WorkspaceNode::Workspace(WorkspaceName::Other(dep_name))
+                PackageNode::Root | PackageNode::Workspace(WorkspaceName::Root) => Some("root"),
+                PackageNode::Workspace(WorkspaceName::Other(dep_name))
                     if dep_name == workspace_name =>
                 {
                     None
                 }
-                WorkspaceNode::Workspace(WorkspaceName::Other(dep_name)) => Some(dep_name.as_str()),
+                PackageNode::Workspace(WorkspaceName::Other(dep_name)) => Some(dep_name.as_str()),
             })
             .collect();
         workspace_dep_names.sort();

crates/turborepo-lib/src/commands/prune.rs

@@ -8,7 +8,7 @@ use turbopath::{
     AbsoluteSystemPathBuf, AnchoredSystemPath, AnchoredSystemPathBuf, RelativeUnixPath,
 };
 use turborepo_repository::{
-    package_graph::{self, PackageGraph, WorkspaceName, WorkspaceNode},
+    package_graph::{self, PackageGraph, PackageNode, WorkspaceName},
     package_json::PackageJson,
 };
 use turborepo_telemetry::events::command::CommandEventBuilder;
@@ -404,18 +404,18 @@ impl<'a> Prune<'a> {
 
     fn internal_dependencies(&self) -> Vec<WorkspaceName> {
         let workspaces =
-            std::iter::once(WorkspaceNode::Workspace(WorkspaceName::Root))
+            std::iter::once(PackageNode::Workspace(WorkspaceName::Root))
                 .chain(self.scope.iter().map(|workspace| {
-                    WorkspaceNode::Workspace(WorkspaceName::Other(workspace.clone()))
+                    PackageNode::Workspace(WorkspaceName::Other(workspace.clone()))
                 }))
                 .collect::<Vec<_>>();
         let nodes = self.package_graph.transitive_closure(workspaces.iter());
 
         let mut names: Vec<_> = nodes
             .into_iter()
             .filter_map(|node| match node {
-                WorkspaceNode::Root => None,
-                WorkspaceNode::Workspace(workspace) => Some(workspace.clone()),
+                PackageNode::Root => None,
+                PackageNode::Workspace(workspace) => Some(workspace.clone()),
             })
             .collect();
         names.sort();

crates/turborepo-lib/src/engine/builder.rs

@@ -5,7 +5,7 @@ use miette::Diagnostic;
 use turbopath::AbsoluteSystemPath;
 use turborepo_graph_utils as graph;
 use turborepo_repository::package_graph::{
-    PackageGraph, WorkspaceName, WorkspaceNode, ROOT_PKG_NAME,
+    PackageGraph, PackageNode, WorkspaceName, ROOT_PKG_NAME,
 };
 
 use super::Engine;
@@ -221,7 +221,7 @@ impl<'a> EngineBuilder<'a> {
 
             let dep_pkgs = self
                 .package_graph
-                .immediate_dependencies(&WorkspaceNode::Workspace(to_task_id.package().into()));
+                .immediate_dependencies(&PackageNode::Workspace(to_task_id.package().into()));
 
             let mut has_deps = false;
             let mut has_topo_deps = false;
@@ -231,7 +231,7 @@ impl<'a> EngineBuilder<'a> {
                 .cartesian_product(dep_pkgs.iter().flatten())
                 .for_each(|(from, dependency_workspace)| {
                     // We don't need to add an edge from the root node if we're in this branch
-                    if let WorkspaceNode::Workspace(dependency_workspace) = dependency_workspace {
+                    if let PackageNode::Workspace(dependency_workspace) = dependency_workspace {
                         has_topo_deps = true;
                         let from_task_id = TaskId::from_graph(dependency_workspace, from);
                         let from_task_index = engine.get_index(&from_task_id);

crates/turborepo-lib/src/run/scope/filter.rs

@@ -261,7 +261,7 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
             }
 
             for package in selector_packages {
-                let node = package_graph::WorkspaceNode::Workspace(package.clone());
+                let node = package_graph::PackageNode::Workspace(package.clone());
 
                 if selector.include_dependencies {
                     let dependencies = self.pkg_graph.immediate_dependencies(&node);
@@ -283,7 +283,7 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
                         // get the dependent's dependencies
                         if selector.include_dependencies {
                             let dependent_node =
-                                package_graph::WorkspaceNode::Workspace(dependent.to_owned());
+                                package_graph::PackageNode::Workspace(dependent.to_owned());
 
                             let dependent_dependencies =
                                 self.pkg_graph.immediate_dependencies(&dependent_node);
@@ -380,7 +380,7 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
                 continue;
             }
 
-            let workspace_node = package_graph::WorkspaceNode::Workspace(package.clone());
+            let workspace_node = package_graph::PackageNode::Workspace(package.clone());
             let dependencies = self.pkg_graph.immediate_dependencies(&workspace_node);
 
             for changed_package in &changed_packages {
@@ -390,7 +390,7 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
                 }
 
                 let changed_node =
-                    package_graph::WorkspaceNode::Workspace(changed_package.to_owned());
+                    package_graph::PackageNode::Workspace(changed_package.to_owned());
 
                 if dependencies
                     .as_ref()

crates/turborepo-repository/src/package_graph/builder.rs

@@ -13,7 +13,7 @@ use turbopath::{
 use turborepo_graph_utils as graph;
 use turborepo_lockfiles::Lockfile;
 
-use super::{PackageGraph, WorkspaceInfo, WorkspaceName, WorkspaceNode};
+use super::{PackageGraph, PackageNode, WorkspaceInfo, WorkspaceName};
 use crate::{
     discovery::{
         self, CachingPackageDiscovery, LocalPackageDiscoveryBuilder, PackageDiscovery,
@@ -145,8 +145,8 @@ struct BuildState<'a, S, T> {
     repo_root: &'a AbsoluteSystemPath,
     single: bool,
     workspaces: HashMap<WorkspaceName, WorkspaceInfo>,
-    workspace_graph: Graph<WorkspaceNode, ()>,
-    node_lookup: HashMap<WorkspaceNode, NodeIndex>,
+    workspace_graph: Graph<PackageNode, ()>,
+    node_lookup: HashMap<PackageNode, NodeIndex>,
     lockfile: Option<Box<dyn Lockfile>>,
     package_jsons: Option<HashMap<AbsoluteSystemPathBuf, PackageJson>>,
     state: std::marker::PhantomData<S>,
@@ -163,15 +163,15 @@ enum ResolvedWorkspaces {}
 enum ResolvedLockfile {}
 
 impl<'a, S, T> BuildState<'a, S, T> {
-    fn add_node(&mut self, node: WorkspaceNode) -> NodeIndex {
+    fn add_node(&mut self, node: PackageNode) -> NodeIndex {
         let idx = self.workspace_graph.add_node(node.clone());
         self.node_lookup.insert(node, idx);
         idx
     }
 
     fn add_root_workspace(&mut self) {
-        let root_index = self.add_node(WorkspaceNode::Root);
-        let root_workspace = self.add_node(WorkspaceNode::Workspace(WorkspaceName::Root));
+        let root_index = self.add_node(PackageNode::Root);
+        let root_workspace = self.add_node(PackageNode::Workspace(WorkspaceName::Root));
         self.workspace_graph
             .add_edge(root_workspace, root_index, ());
     }
@@ -256,7 +256,7 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedPackageManager, T> {
                 existing_path: existing.package_json_path.to_string(),
             });
         }
-        self.add_node(WorkspaceNode::Workspace(name));
+        self.add_node(PackageNode::Workspace(name));
         Ok(())
     }
 
@@ -369,19 +369,19 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedWorkspaces, T> {
             let Dependencies { internal, external } = deps;
             let node_idx = self
                 .node_lookup
-                .get(&WorkspaceNode::Workspace(name))
+                .get(&PackageNode::Workspace(name))
                 .expect("unable to find workspace node index");
             if internal.is_empty() {
                 let root_idx = self
                     .node_lookup
-                    .get(&WorkspaceNode::Root)
+                    .get(&PackageNode::Root)
                     .expect("root node should have index");
                 self.workspace_graph.add_edge(*node_idx, *root_idx, ());
             }
             for dependency in internal {
                 let dependency_idx = self
                     .node_lookup
-                    .get(&WorkspaceNode::Workspace(dependency))
+                    .get(&PackageNode::Workspace(dependency))
                     .expect("unable to find workspace node index");
                 self.workspace_graph
                     .add_edge(*node_idx, *dependency_idx, ());

crates/turborepo-repository/src/package_graph/mod.rs

@@ -22,9 +22,9 @@ pub const ROOT_PKG_NAME: &str = "//";
 
 #[derive(Debug)]
 pub struct PackageGraph {
-    workspace_graph: petgraph::Graph<WorkspaceNode, ()>,
+    workspace_graph: petgraph::Graph<PackageNode, ()>,
     #[allow(dead_code)]
-    node_lookup: HashMap<WorkspaceNode, petgraph::graph::NodeIndex>,
+    node_lookup: HashMap<PackageNode, petgraph::graph::NodeIndex>,
     workspaces: HashMap<WorkspaceName, WorkspaceInfo>,
     package_manager: PackageManager,
     lockfile: Option<Box<dyn Lockfile>>,
@@ -103,16 +103,16 @@ impl Serialize for WorkspaceName {
 }
 
 #[derive(Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
-pub enum WorkspaceNode {
+pub enum PackageNode {
     Root,
     Workspace(WorkspaceName),
 }
 
-impl WorkspaceNode {
+impl PackageNode {
     pub fn as_workspace(&self) -> &WorkspaceName {
         match self {
-            WorkspaceNode::Workspace(name) => name,
-            WorkspaceNode::Root => &WorkspaceName::Root,
+            PackageNode::Workspace(name) => name,
+            PackageNode::Root => &WorkspaceName::Root,
         }
     }
 }
@@ -133,7 +133,7 @@ impl PackageGraph {
     pub fn remove_workspace_dependencies(&mut self) {
         let root_index = self
             .node_lookup
-            .get(&WorkspaceNode::Root)
+            .get(&PackageNode::Root)
             .expect("graph should have root workspace node");
         self.workspace_graph.retain_edges(|graph, index| {
             let Some((_src, dst)) = graph.edge_endpoints(index) else {
@@ -197,10 +197,7 @@ impl PackageGraph {
     /// a -> b -> c
     ///
     /// immediate_dependencies(a) -> {b}
-    pub fn immediate_dependencies(
-        &self,
-        workspace: &WorkspaceNode,
-    ) -> Option<HashSet<&WorkspaceNode>> {
+    pub fn immediate_dependencies(&self, workspace: &PackageNode) -> Option<HashSet<&PackageNode>> {
         let index = self.node_lookup.get(workspace)?;
         Some(
             self.workspace_graph
@@ -223,10 +220,7 @@ impl PackageGraph {
     ///
     /// immediate_ancestors(c) -> {b}
     #[allow(dead_code)]
-    pub fn immediate_ancestors(
-        &self,
-        workspace: &WorkspaceNode,
-    ) -> Option<HashSet<&WorkspaceNode>> {
+    pub fn immediate_ancestors(&self, workspace: &PackageNode) -> Option<HashSet<&PackageNode>> {
         let index = self.node_lookup.get(workspace)?;
         Some(
             self.workspace_graph
@@ -249,7 +243,7 @@ impl PackageGraph {
     ///
     /// dependencies(a) = {b, c}
     #[allow(dead_code)]
-    pub fn dependencies<'a>(&'a self, node: &WorkspaceNode) -> HashSet<&'a WorkspaceNode> {
+    pub fn dependencies<'a>(&'a self, node: &PackageNode) -> HashSet<&'a PackageNode> {
         let mut dependencies =
             self.transitive_closure_inner(Some(node), petgraph::Direction::Outgoing);
         dependencies.remove(node);
@@ -264,7 +258,7 @@ impl PackageGraph {
     /// a -> b -> c (external)
     ///
     /// ancestors(c) = {a, b}
-    pub fn ancestors(&self, node: &WorkspaceNode) -> HashSet<&WorkspaceNode> {
+    pub fn ancestors(&self, node: &PackageNode) -> HashSet<&PackageNode> {
         let mut dependents =
             self.transitive_closure_inner(Some(node), petgraph::Direction::Incoming);
         dependents.remove(node);
@@ -276,18 +270,18 @@ impl PackageGraph {
     /// the dependencies, or the dependents, use `dependencies` or `ancestors`.
     /// Alternatively, if you need just direct dependents, use
     /// `immediate_dependents`.
-    pub fn transitive_closure<'a, 'b, I: IntoIterator<Item = &'b WorkspaceNode>>(
+    pub fn transitive_closure<'a, 'b, I: IntoIterator<Item = &'b PackageNode>>(
         &'a self,
         nodes: I,
-    ) -> HashSet<&'a WorkspaceNode> {
+    ) -> HashSet<&'a PackageNode> {
         self.transitive_closure_inner(nodes, petgraph::Direction::Outgoing)
     }
 
-    fn transitive_closure_inner<'a, 'b, I: IntoIterator<Item = &'b WorkspaceNode>>(
+    fn transitive_closure_inner<'a, 'b, I: IntoIterator<Item = &'b PackageNode>>(
         &'a self,
         nodes: I,
         direction: petgraph::Direction,
-    ) -> HashSet<&'a WorkspaceNode> {
+    ) -> HashSet<&'a PackageNode> {
         let indices = nodes
             .into_iter()
             .filter_map(|node| self.node_lookup.get(node))
@@ -418,11 +412,11 @@ impl fmt::Display for WorkspaceName {
     }
 }
 
-impl fmt::Display for WorkspaceNode {
+impl fmt::Display for PackageNode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            WorkspaceNode::Root => f.write_str("___ROOT___"),
-            WorkspaceNode::Workspace(workspace) => workspace.fmt(f),
+            PackageNode::Root => f.write_str("___ROOT___"),
+            PackageNode::Workspace(workspace) => workspace.fmt(f),
         }
     }
 }
@@ -484,8 +478,8 @@ mod test {
             .unwrap();
 
         let closure =
-            pkg_graph.transitive_closure(Some(&WorkspaceNode::Workspace(WorkspaceName::Root)));
-        assert!(closure.contains(&WorkspaceNode::Root));
+            pkg_graph.transitive_closure(Some(&PackageNode::Workspace(WorkspaceName::Root)));
+        assert!(closure.contains(&PackageNode::Root));
         assert!(pkg_graph.validate().is_ok());
     }
 
@@ -527,13 +521,13 @@ mod test {
         .unwrap();
 
         assert!(pkg_graph.validate().is_ok());
-        let closure = pkg_graph.transitive_closure(Some(&WorkspaceNode::Workspace("a".into())));
+        let closure = pkg_graph.transitive_closure(Some(&PackageNode::Workspace("a".into())));
         assert_eq!(
             closure,
             [
-                WorkspaceNode::Root,
-                WorkspaceNode::Workspace("a".into()),
-                WorkspaceNode::Workspace("b".into())
+                PackageNode::Root,
+                PackageNode::Workspace("a".into()),
+                PackageNode::Workspace("b".into())
             ]
             .iter()
             .collect::<HashSet<_>>()

packages/turbo-repository/rust/src/lib.rs

@@ -5,7 +5,7 @@ use napi_derive::napi;
 use turbopath::AbsoluteSystemPath;
 use turborepo_repository::{
     inference::RepoState as WorkspaceState,
-    package_graph::{PackageGraph, WorkspaceName, WorkspaceNode},
+    package_graph::{PackageGraph, PackageNode, WorkspaceName},
 };
 mod internal;
 
@@ -68,7 +68,7 @@ impl Package {
         graph: &PackageGraph,
         workspace_path: &AbsoluteSystemPath,
     ) -> Vec<Package> {
-        let node = WorkspaceNode::Workspace(WorkspaceName::Other(self.name.clone()));
+        let node = PackageNode::Workspace(WorkspaceName::Other(self.name.clone()));
         let ancestors = match graph.immediate_ancestors(&node) {
             Some(ancestors) => ancestors,
             None => return vec![],