feat(query): package changes reason

crates/turborepo-lib/src/global_deps_package_change_mapper.rs

@@ -1,7 +1,9 @@
 use thiserror::Error;
 use turbopath::AnchoredSystemPath;
 use turborepo_repository::{
-    change_mapper::{DefaultPackageChangeMapper, PackageChangeMapper, PackageMapping},
+    change_mapper::{
+        AllPackageChangeReason, DefaultPackageChangeMapper, PackageChangeMapper, PackageMapping,
+    },
     package_graph::{PackageGraph, WorkspacePackage},
 };
 use wax::{BuildError, Program};

crates/turborepo-lib/src/query/mod.rs

@@ -476,12 +476,12 @@ impl RepositoryQuery {
             self.run.root_turbo_json(),
         )?
         .into_iter()
-        .map(|package| ChangedPackage {
+        .map(|(package, reason)| ChangedPackage {
             package: Package {
                 run: self.run.clone(),
-                name: package.name,
+                name: package,
             },
-            reason: package.reason.into(),
+            reason: reason.into(),
         })
         .filter(|package| filter.as_ref().map_or(true, |f| f.check(&package.package)))
         .sorted_by(|a, b| a.package.name.cmp(&b.package.name))

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

@@ -1,5 +1,5 @@
 use std::{
-    collections::HashSet,
+    collections::{HashMap, HashSet},
     io::{ErrorKind, IsTerminal},
     sync::Arc,
     time::SystemTime,
@@ -43,10 +43,7 @@ use crate::{
     engine::{Engine, EngineBuilder},
     opts::Opts,
     process::ProcessManager,
-    run::{
-        scope, scope::PackageChange, task_access::TaskAccess, task_id::TaskName, Error, Run,
-        RunCache,
-    },
+    run::{scope, task_access::TaskAccess, task_id::TaskName, Error, Run, RunCache},
     shim::TurboState,
     signal::{SignalHandler, SignalSubscriber},
     turbo_json::{TurboJson, TurboJsonLoader, UIMode},
@@ -152,7 +149,7 @@ impl RunBuilder {
         pkg_dep_graph: &PackageGraph,
         scm: &SCM,
         root_turbo_json: &TurboJson,
-    ) -> Result<HashSet<PackageChange>, Error> {
+    ) -> Result<HashMap<PackageName, PackageChangeReason>, Error> {
         let (mut filtered_pkgs, is_all_packages) = scope::resolve_packages(
             &opts.scope_opts,
             repo_root,
@@ -170,12 +167,12 @@ impl RunBuilder {
                 }
 
                 if root_turbo_json.tasks.contains_key(&task_name) {
-                    filtered_pkgs.insert(PackageChange {
-                        name: PackageName::Root,
-                        reason: PackageChangeReason::RootTask {
+                    filtered_pkgs.insert(
+                        PackageName::Root,
+                        PackageChangeReason::RootTask {
                             task: task_name.to_string(),
                         },
-                    });
+                    );
                     break;
                 }
             }
@@ -420,7 +417,7 @@ impl RunBuilder {
         let mut engine = self.build_engine(
             &pkg_dep_graph,
             &root_turbo_json,
-            &filtered_pkgs,
+            filtered_pkgs.keys(),
             turbo_json_loader.clone(),
         )?;
 
@@ -429,7 +426,7 @@ impl RunBuilder {
             engine = self.build_engine(
                 &pkg_dep_graph,
                 &root_turbo_json,
-                &filtered_pkgs,
+                filtered_pkgs.keys(),
                 turbo_json_loader,
             )?;
         }
@@ -462,7 +459,7 @@ impl RunBuilder {
             api_client: self.api_client,
             api_auth: self.api_auth,
             env_at_execution_start,
-            filtered_pkgs: filtered_pkgs.into_iter().map(|p| p.name).collect(),
+            filtered_pkgs: filtered_pkgs.keys().cloned().collect(),
             pkg_dep_graph: Arc::new(pkg_dep_graph),
             root_turbo_json,
             scm,
@@ -474,11 +471,11 @@ impl RunBuilder {
         })
     }
 
-    fn build_engine(
+    fn build_engine<'a>(
         &self,
         pkg_dep_graph: &PackageGraph,
         root_turbo_json: &TurboJson,
-        filtered_pkgs: &HashSet<PackageChange>,
+        filtered_pkgs: impl Iterator<Item = &'a PackageName>,
         turbo_json_loader: TurboJsonLoader,
     ) -> Result<Engine, Error> {
         let mut builder = EngineBuilder::new(
@@ -489,7 +486,7 @@ impl RunBuilder {
         )
         .with_root_tasks(root_turbo_json.tasks.keys().cloned())
         .with_tasks_only(self.opts.run_opts.only)
-        .with_workspaces(filtered_pkgs.clone().into_iter().map(|p| p.name).collect())
+        .with_workspaces(filtered_pkgs.cloned().collect())
         .with_tasks(self.opts.run_opts.tasks.iter().map(|task| {
             // TODO: Pull span info from command
             Spanned::new(TaskName::from(task.as_str()).into_owned())

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

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 use tracing::debug;
 use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf};
@@ -7,13 +7,13 @@ use turborepo_repository::{
         AllPackageChangeReason, ChangeMapper, DefaultPackageChangeMapper, LockfileChange,
         PackageChangeReason, PackageChanges,
     },
-    package_graph::PackageGraph,
+    package_graph::{PackageGraph, PackageName},
 };
 use turborepo_scm::{git::ChangedFilesResult, SCM};
 
 use crate::{
     global_deps_package_change_mapper::{Error, GlobalDepsPackageChangeMapper},
-    run::scope::{PackageChange, ResolutionError},
+    run::scope::ResolutionError,
 };
 
 /// Given two git refs, determine which packages have changed between them.
@@ -25,7 +25,7 @@ pub trait GitChangeDetector {
         include_uncommitted: bool,
         allow_unknown_objects: bool,
         merge_base: bool,
-    ) -> Result<HashSet<PackageChange>, ResolutionError>;
+    ) -> Result<HashMap<PackageName, PackageChangeReason>, ResolutionError>;
 }
 
 pub struct ScopeChangeDetector<'a> {
@@ -97,7 +97,7 @@ impl<'a> GitChangeDetector for ScopeChangeDetector<'a> {
         include_uncommitted: bool,
         allow_unknown_objects: bool,
         merge_base: bool,
-    ) -> Result<HashSet<PackageChange>, ResolutionError> {
+    ) -> Result<HashMap<PackageName, PackageChangeReason>, ResolutionError> {
         let changed_files = match self.scm.changed_files(
             self.turbo_root,
             from_ref,
@@ -111,12 +111,14 @@ impl<'a> GitChangeDetector for ScopeChangeDetector<'a> {
                 return Ok(self
                     .pkg_graph
                     .packages()
-                    .map(|(name, _)| PackageChange {
-                        name: name.to_owned(),
-                        reason: PackageChangeReason::All(AllPackageChangeReason::GitRefNotFound {
-                            from_ref: from_ref.clone(),
-                            to_ref: to_ref.clone(),
-                        }),
+                    .map(|(name, _)| {
+                        (
+                            name.to_owned(),
+                            PackageChangeReason::All(AllPackageChangeReason::GitRefNotFound {
+                                from_ref: from_ref.clone(),
+                                to_ref: to_ref.clone(),
+                            }),
+                        )
                     })
                     .collect());
             }
@@ -142,10 +144,7 @@ impl<'a> GitChangeDetector for ScopeChangeDetector<'a> {
                 Ok(self
                     .pkg_graph
                     .packages()
-                    .map(|(name, _)| PackageChange {
-                        name: name.to_owned(),
-                        reason: PackageChangeReason::All(reason.clone()),
-                    })
+                    .map(|(name, _)| (name.to_owned(), PackageChangeReason::All(reason.clone())))
                     .collect())
             }
             PackageChanges::Some(packages) => {
@@ -160,10 +159,7 @@ impl<'a> GitChangeDetector for ScopeChangeDetector<'a> {
 
                 Ok(packages
                     .iter()
-                    .map(|(package, reason)| PackageChange {
-                        name: package.name.to_owned(),
-                        reason: reason.clone(),
-                    })
+                    .map(|(package, reason)| (package.name.clone(), reason.clone()))
                     .collect())
             }
         }