feat(@turbo/repository): add affectedPackages API (#7326)

This API takes a list of files (strings anchored to the root of the
workspace) and returns a set of packages that were affected by that
change. Importantly, this does _not_ include the whole graph of
packages affected by these files changes, so it's a pretty simple
mapping of files to the packages they belong to. If a known global file
changes, all packages are returned.

Co-authored-by: Chris Olszewski <[email protected]>

Author: mehulkar

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

@@ -1,6 +1,14 @@
 import * as path from "node:path";
 import { Workspace, Package, PackageManager } from "../js/dist/index.js";
 
+type PackageReduced = Pick<Package, "name" | "relativePath">;
+
+interface AffectedPackagesTestParams {
+  files: string[];
+  expected: PackageReduced[];
+  description: string;
+}
+
 describe("Workspace", () => {
   it("finds a workspace", async () => {
     const workspace = await Workspace.find();
@@ -29,4 +37,51 @@ describe("Workspace", () => {
       "packages/ui": ["apps/app"],
     });
   });
+
+  describe("affectedPackages", () => {
+    const tests: AffectedPackagesTestParams[] = [
+      {
+        description: "app change",
+        files: ["apps/app/file.txt"],
+        expected: [{ name: "app-a", relativePath: "apps/app" }],
+      },
+      {
+        description: "lib change",
+        files: ["packages/ui/a.txt"],
+        expected: [{ name: "ui", relativePath: "packages/ui" }],
+      },
+      {
+        description: "global change",
+        files: ["package.json"],
+        expected: [
+          { name: "app-a", relativePath: "apps/app" },
+          { name: "ui", relativePath: "packages/ui" },
+        ],
+      },
+      {
+        description: "global change that can be ignored",
+        files: ["README.md"],
+        expected: [],
+      },
+    ];
+
+    test.each(tests)(
+      "$description",
+      async (testParams: AffectedPackagesTestParams) => {
+        const { files, expected } = testParams;
+        const dir = path.resolve(__dirname, "./fixtures/monorepo");
+        const workspace = await Workspace.find(dir);
+        const reduced: PackageReduced[] = (
+          await workspace.affectedPackages(files)
+        ).map((pkg) => {
+          return {
+            name: pkg.name,
+            relativePath: pkg.relativePath,
+          };
+        });
+
+        expect(reduced).toEqual(expected);
+      }
+    );
+  });
 });

packages/turbo-repository/js/index.d.ts

@@ -33,4 +33,11 @@ export class Workspace {
    * dependents (i.e. the packages that depend on each of those packages).
    */
   findPackagesAndDependents(): Promise<Record<string, Array<string>>>;
+  /**
+   * Given a set of "changed" files, returns a set of packages that are
+   * "affected" by the changes. The `files` argument is expected to be a list
+   * of strings relative to the monorepo root and use the current system's
+   * path separator.
+   */
+  affectedPackages(files: Array<string>): Promise<Array<Package>>;
 }

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

@@ -1,11 +1,15 @@
-use std::{collections::HashMap, hash::Hash};
+use std::{
+    collections::{HashMap, HashSet},
+    hash::Hash,
+};
 
 use napi::Error;
 use napi_derive::napi;
-use turbopath::AbsoluteSystemPath;
+use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf};
 use turborepo_repository::{
+    change_mapper::{ChangeMapper, PackageChanges},
     inference::RepoState as WorkspaceState,
-    package_graph::{PackageGraph, PackageNode, WorkspaceName},
+    package_graph::{PackageGraph, PackageNode, WorkspaceName, WorkspacePackage, ROOT_PKG_NAME},
 };
 mod internal;
 
@@ -131,4 +135,60 @@ impl Workspace {
 
         Ok(map)
     }
+
+    /// Given a set of "changed" files, returns a set of packages that are
+    /// "affected" by the changes. The `files` argument is expected to be a list
+    /// of strings relative to the monorepo root and use the current system's
+    /// path separator.
+    #[napi]
+    pub async fn affected_packages(&self, files: Vec<String>) -> Result<Vec<Package>, Error> {
+        let workspace_root = match AbsoluteSystemPath::new(&self.absolute_path) {
+            Ok(path) => path,
+            Err(e) => return Err(Error::from_reason(e.to_string())),
+        };
+
+        let hash_set_of_paths: HashSet<AnchoredSystemPathBuf> = files
+            .into_iter()
+            .filter_map(|path| {
+                let path_components = path.split(std::path::MAIN_SEPARATOR).collect::<Vec<&str>>();
+                let absolute_path = workspace_root.join_components(&path_components);
+                workspace_root.anchor(&absolute_path).ok()
+            })
+            .collect();
+
+        // Create a ChangeMapper with no custom global deps or ignore patterns
+        let mapper = ChangeMapper::new(&self.graph, vec![], vec![]);
+        let package_changes = match mapper.changed_packages(hash_set_of_paths, None) {
+            Ok(changes) => changes,
+            Err(e) => return Err(Error::from_reason(e.to_string())),
+        };
+
+        let packages = match package_changes {
+            PackageChanges::All => self
+                .graph
+                .workspaces()
+                .map(|(name, info)| WorkspacePackage {
+                    name: name.to_owned(),
+                    path: info.package_path().to_owned(),
+                })
+                .collect::<Vec<WorkspacePackage>>(),
+            PackageChanges::Some(packages) => packages.into_iter().collect(),
+        };
+
+        let mut serializable_packages: Vec<Package> = packages
+            .into_iter()
+            .filter(|p| match &p.name {
+                WorkspaceName::Root => false,
+                WorkspaceName::Other(name) => name != ROOT_PKG_NAME,
+            })
+            .map(|p| {
+                let package_path = workspace_root.resolve(&p.path);
+                Package::new(p.name.to_string(), &workspace_root, &package_path)
+            })
+            .collect();
+
+        serializable_packages.sort_by_key(|p| p.name.clone());
+
+        Ok(serializable_packages)
+    }
 }