fix(repository): still assume files not belonging to a package result in a global change (#10047)

### Description

Make sure we keep as much of the default behavior as possible.

We now have a nesting doll sorta structure for change mappers:
```
Most conservative > Least Conservative
Default > DefaultWLockfile > Global
```

Author: chris-olszewski

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

@@ -7,8 +7,8 @@ use std::{
 };
 
 pub use package::{
-    DefaultPackageChangeMapper, Error, GlobalDepsPackageChangeMapper, PackageChangeMapper,
-    PackageMapping,
+    DefaultPackageChangeMapper, DefaultPackageChangeMapperWithLockfile, Error,
+    GlobalDepsPackageChangeMapper, PackageChangeMapper, PackageMapping,
 };
 use tracing::debug;
 use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf};

crates/turborepo-repository/src/change_mapper/package.rs

@@ -86,6 +86,43 @@ impl PackageChangeMapper for DefaultPackageChangeMapper<'_> {
     }
 }
 
+pub struct DefaultPackageChangeMapperWithLockfile<'a> {
+    base: DefaultPackageChangeMapper<'a>,
+}
+
+impl<'a> DefaultPackageChangeMapperWithLockfile<'a> {
+    pub fn new(pkg_dep_graph: &'a PackageGraph) -> Self {
+        Self {
+            base: DefaultPackageChangeMapper::new(pkg_dep_graph),
+        }
+    }
+}
+
+impl PackageChangeMapper for DefaultPackageChangeMapperWithLockfile<'_> {
+    fn detect_package(&self, path: &AnchoredSystemPath) -> PackageMapping {
+        // If we have a lockfile change, we consider this as a root package change,
+        // since there's a chance that the root package uses a workspace package
+        // dependency (this is cursed behavior but sadly possible). There's a chance
+        // that we can make this more accurate by checking which package
+        // manager, since not all package managers may permit root pulling from
+        // workspace package dependencies
+        if PackageManager::supported_managers()
+            .iter()
+            .any(|pm| pm.lockfile_name() == path.as_str())
+        {
+            PackageMapping::Package((
+                WorkspacePackage {
+                    name: PackageName::Root,
+                    path: AnchoredSystemPathBuf::from_raw("").unwrap(),
+                },
+                PackageInclusionReason::ConservativeRootLockfileChanged,
+            ))
+        } else {
+            self.base.detect_package(path)
+        }
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum Error {
     #[error(transparent)]
@@ -101,7 +138,7 @@ pub enum Error {
 /// changes all packages. Since we have a list of global deps,
 /// we can check against that and avoid invalidating in unnecessary cases.
 pub struct GlobalDepsPackageChangeMapper<'a> {
-    pkg_dep_graph: &'a PackageGraph,
+    base: DefaultPackageChangeMapperWithLockfile<'a>,
     global_deps_matcher: wax::Any<'a>,
 }
 
@@ -110,36 +147,19 @@ impl<'a> GlobalDepsPackageChangeMapper<'a> {
         pkg_dep_graph: &'a PackageGraph,
         global_deps: I,
     ) -> Result<Self, Error> {
+        let base = DefaultPackageChangeMapperWithLockfile::new(pkg_dep_graph);
         let global_deps_matcher = wax::any(global_deps)?;
 
         Ok(Self {
-            pkg_dep_graph,
+            base,
             global_deps_matcher,
         })
     }
 }
 
 impl PackageChangeMapper for GlobalDepsPackageChangeMapper<'_> {
     fn detect_package(&self, path: &AnchoredSystemPath) -> PackageMapping {
-        // If we have a lockfile change, we consider this as a root package change,
-        // since there's a chance that the root package uses a workspace package
-        // dependency (this is cursed behavior but sadly possible). There's a chance
-        // that we can make this more accurate by checking which package
-        // manager, since not all package managers may permit root pulling from
-        // workspace package dependencies
-        if PackageManager::supported_managers()
-            .iter()
-            .any(|pm| pm.lockfile_name() == path.as_str())
-        {
-            return PackageMapping::Package((
-                WorkspacePackage {
-                    name: PackageName::Root,
-                    path: AnchoredSystemPathBuf::from_raw("").unwrap(),
-                },
-                PackageInclusionReason::ConservativeRootLockfileChanged,
-            ));
-        }
-        match DefaultPackageChangeMapper::new(self.pkg_dep_graph).detect_package(path) {
+        match self.base.detect_package(path) {
             // Since `DefaultPackageChangeMapper` is overly conservative, we can check here if
             // the path is actually in globalDeps and if not, return it as
             // PackageDetection::Package(WorkspacePackage::root()).

packages/turbo-repository/__tests__/affected-packages.test.ts

@@ -68,5 +68,28 @@ describe("affectedPackages", () => {
         workspace.affectedPackages(["pnpm-lock.yaml"], null, true)
       );
     });
+
+    it("still considers root file changes as global", async () => {
+      const dir = path.resolve(__dirname, "./fixtures/monorepo");
+      const workspace = await Workspace.find(dir);
+
+      const reduced: PackageReduced[] = (
+        await workspace.affectedPackages(
+          ["file-we-do-not-understand.txt"],
+          "HEAD",
+          true
+        )
+      ).map((pkg) => {
+        return {
+          name: pkg.name,
+          relativePath: pkg.relativePath,
+        };
+      });
+
+      assert.deepEqual(reduced, [
+        { name: "app-a", relativePath: "apps/app" },
+        { name: "ui", relativePath: "packages/ui" },
+      ]);
+    });
   });
 });

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

@@ -10,8 +10,8 @@ use tracing::debug;
 use turbopath::{AbsoluteSystemPath, AnchoredSystemPath, AnchoredSystemPathBuf};
 use turborepo_repository::{
     change_mapper::{
-        ChangeMapper, DefaultPackageChangeMapper, GlobalDepsPackageChangeMapper, LockfileContents,
-        PackageChanges,
+        ChangeMapper, DefaultPackageChangeMapper, DefaultPackageChangeMapperWithLockfile,
+        LockfileContents, PackageChanges,
     },
     inference::RepoState as WorkspaceState,
     package_graph::{PackageGraph, PackageName, PackageNode, WorkspacePackage, ROOT_PKG_NAME},
@@ -246,12 +246,7 @@ impl Workspace {
         // Create a ChangeMapper with no ignore patterns
         let change_detector = comparison
             .is_some()
-            .then(|| {
-                Either::Left(
-                    GlobalDepsPackageChangeMapper::new(&self.graph, std::iter::empty::<&str>())
-                        .unwrap(),
-                )
-            })
+            .then(|| Either::Left(DefaultPackageChangeMapperWithLockfile::new(&self.graph)))
             .unwrap_or_else(|| Either::Right(DefaultPackageChangeMapper::new(&self.graph)));
         let mapper = ChangeMapper::new(&self.graph, vec![], change_detector);