Add --recursive option for transitive dependencies

Author: pnezis

workspace/CHANGELOG.md

@@ -19,18 +19,51 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   Example use cases:
 
   - Run tests on affected projects but always include critical services:
+  
     ```bash
     mix workspace.run -t test --affected --include auth --include payment
     ```
 
   - Get all dependencies of a project plus the project itself:
+  
     ```bash
     mix workspace.list --dependent my_api --include my_api --format json
     ```
 
   Note: `--exclude` always has the highest priority - excluded projects cannot
   be re-included with `--include`.
 
+* Add `--recursive` option for transitive dependency filtering
+
+  The `--recursive` option enables deep dependency traversal when used with
+  `--dependency` or `--dependent` flags, allowing you to work with all
+  transitive dependencies instead of just first-level ones.
+
+  Available in `workspace.run` and `workspace.list` tasks.
+
+  Example use cases:
+
+  - Get all projects that transitively depend on a shared library:
+  
+    ```bash
+    mix workspace.list --dependency shared_utils --recursive
+    ```
+
+  - Run tests on all transitive dependencies of an API service:
+  
+    ```bash
+    mix workspace.run -t test --dependent my_api --recursive
+    ```
+
+  - Find all projects affected by changes to a core dependency:
+  
+    ```bash
+    mix workspace.list --dependency core_lib --recursive --format json
+    ```
+
+  By default (without `--recursive`), `--dependency` and `--dependent` only
+  consider direct (first-level) dependencies to maintain backward compatibility.
+
 ## [v0.3.1](https://github.com/sportradar/elixir-workspace/tree/workspace/v0.3.1) (2025-10-24)
 
 ### Fixed

workspace/lib/mix/tasks/workspace.list.ex

@@ -59,6 +59,7 @@ defmodule Mix.Tasks.Workspace.List do
                       :excluded_tags,
                       :dependency,
                       :dependent,
+                      :recursive,
                       :show_status,
                       :affected,
                       :modified,
@@ -114,6 +115,15 @@ defmodule Mix.Tasks.Workspace.List do
 
       $ mix workspace.list --dependent foo
 
+  By default, both `--dependency` and `--dependent` consider only direct (first-level)
+  dependencies. You can use the `--recursive` flag to include all transitive dependencies:
+
+      # Get all projects that transitively depend on foo (direct and indirect)
+      $ mix workspace.list --dependency foo --recursive
+
+      # Get all transitive dependencies of foo (direct and indirect)
+      $ mix workspace.list --dependent foo --recursive
+
   You can also filter by the project's maintainer. The search is case insensitive. The
   maintainers are expected to be defined under `package`:
 
@@ -157,6 +167,8 @@ defmodule Mix.Tasks.Workspace.List do
   >
   > This creates a minimal workspace containing only the projects relevant to `my_api`,
   > making it easier to navigate and work with a specific subset of your monorepo.
+  >
+  > If you want to also include transitive dependencies, you can use the `--recursive` flag.
 
   """
   use Mix.Task

workspace/lib/mix/tasks/workspace.run.ex

@@ -95,7 +95,8 @@ defmodule Mix.Tasks.Workspace.Run do
                       :show_status,
                       :paths,
                       :dependency,
-                      :dependent
+                      :dependent,
+                      :recursive
                     ],
                     opts
                   )

workspace/lib/workspace/cli_options.ex

@@ -69,6 +69,15 @@ defmodule Workspace.CliOptions do
       """,
       doc_section: :filtering
     ],
+    recursive: [
+      type: :boolean,
+      default: false,
+      doc: """
+      If set, when used with `--dependency` or `--dependent`, it will consider all transitive
+      dependencies instead of just first-level ones.
+      """,
+      doc_section: :filtering
+    ],
     excluded_tags: [
       type: :string,
       multiple: true,

workspace/lib/workspace/filtering.ex

@@ -37,6 +37,8 @@ defmodule Workspace.Filtering do
     Only projects located under any of the provided path will be considered.
     * `:dependency` (`t:atom/0`) - keeps only projects that have the given dependency.
     * `:dependent` (`t:atom/0`) - keeps only dependencies of the given project.
+    * `:recursive` (`t:boolean/0`) - if set, when used with `:dependency` or `:dependent`,
+    it will consider all transitive dependencies instead of just first-level ones. Defaults to `false`.
     * `:affected` (`t:boolean/0`) - if set only the affected projects will be
     included and everything else will be skipped. Defaults to `false`.
     * `:modified` (`t:boolean/0`) - if set only the modified projects will be
@@ -86,6 +88,7 @@ defmodule Workspace.Filtering do
       tags: Enum.map(opts[:tags] || [], &maybe_to_tag/1),
       dependency: maybe_to_atom(opts[:dependency]),
       dependent: maybe_to_atom(opts[:dependent]),
+      recursive: opts[:recursive] || false,
       paths: opts[:paths]
     ]
 
@@ -152,10 +155,10 @@ defmodule Workspace.Filtering do
     |> skip_if(workspace, fn project, _workspace -> not_affected?(project, opts[:affected]) end)
     |> skip_if(workspace, fn project, _workspace -> not_modified?(project, opts[:modified]) end)
     |> skip_if(workspace, fn project, workspace ->
-      not_dependency?(workspace, project, opts[:dependency])
+      not_dependency?(workspace, project, opts[:dependency], opts[:recursive])
     end)
     |> skip_if(workspace, fn project, workspace ->
-      not_dependent?(workspace, project, opts[:dependent])
+      not_dependent?(workspace, project, opts[:dependent], opts[:recursive])
     end)
   end
 
@@ -203,13 +206,29 @@ defmodule Workspace.Filtering do
   defp not_modified?(_project, false), do: false
   defp not_modified?(project, true), do: not Workspace.Project.modified?(project)
 
-  defp not_dependency?(_workspace, _project, nil), do: false
+  defp not_dependency?(_workspace, _project, nil, _recursive), do: false
 
-  defp not_dependency?(workspace, project, dependency),
-    do: dependency not in Workspace.Graph.dependencies(workspace, project.app)
+  defp not_dependency?(workspace, project, dependency, recursive) do
+    deps =
+      if recursive do
+        Workspace.Graph.all_dependencies(workspace, project.app)
+      else
+        Workspace.Graph.dependencies(workspace, project.app)
+      end
+
+    dependency not in deps
+  end
 
-  defp not_dependent?(_workspace, _project, nil), do: false
+  defp not_dependent?(_workspace, _project, nil, _recursive), do: false
 
-  defp not_dependent?(workspace, project, dependent),
-    do: project.app not in Workspace.Graph.dependencies(workspace, dependent)
+  defp not_dependent?(workspace, project, dependent, recursive) do
+    deps =
+      if recursive do
+        Workspace.Graph.all_dependencies(workspace, dependent)
+      else
+        Workspace.Graph.dependencies(workspace, dependent)
+      end
+
+    project.app not in deps
+  end
 end

workspace/lib/workspace/graph.ex

@@ -221,6 +221,33 @@ defmodule Workspace.Graph do
     |> Enum.map(& &1.app)
   end
 
+  @doc """
+  Returns all transitive dependencies of the given `project`
+
+  This includes direct dependencies and all of their dependencies recursively.
+  """
+  @spec all_dependencies(workspace :: Workspace.State.t(), project :: atom()) :: [atom()]
+  def all_dependencies(workspace, project) do
+    node = node_by_app(workspace.graph, project)
+
+    :digraph_utils.reachable_neighbours([node], workspace.graph)
+    |> Enum.map(& &1.app)
+  end
+
+  @doc """
+  Returns all transitive dependents of the given `project`
+
+  This includes direct dependents (projects that depend on this project) and all
+  projects that depend on those, recursively.
+  """
+  @spec all_dependents(workspace :: Workspace.State.t(), project :: atom()) :: [atom()]
+  def all_dependents(workspace, project) do
+    node = node_by_app(workspace.graph, project)
+
+    :digraph_utils.reaching_neighbours([node], workspace.graph)
+    |> Enum.map(& &1.app)
+  end
+
   @doc """
   Returns a subgraph around the given `project` and all nodes within the given `proximity`.
   """

workspace/test/mix/tasks/workspace.list_test.exs

@@ -299,6 +299,68 @@ defmodule Mix.Tasks.Workspace.ListTest do
     )
   end
 
+  @tag :tmp_dir
+  test "filtering by --dependency with --recursive", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        # Without --recursive: only package_c and package_f have package_g as direct dependency
+        # With --recursive: package_a also transitively depends on package_g (through package_b and package_c->package_f)
+        expected = """
+        Found 4 workspace projects matching the given options.
+          * :package_a package_a/mix.exs :shared, area:core
+          * :package_b package_b/mix.exs - a dummy project
+          * :package_c package_c/mix.exs
+          * :package_f package_f/mix.exs
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--dependency",
+                   "package_g",
+                   "--recursive"
+                 ])
+               end) == expected
+      end
+    )
+  end
+
+  @tag :tmp_dir
+  test "filtering by --dependent with --recursive", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        # Without --recursive: package_a depends directly on package_b, package_c, package_d
+        # With --recursive: also includes transitive dependencies like package_e, package_f, package_g
+        expected = """
+        Found 6 workspace projects matching the given options.
+          * :package_b package_b/mix.exs - a dummy project
+          * :package_c package_c/mix.exs
+          * :package_d package_d/mix.exs
+          * :package_e package_e/mix.exs
+          * :package_f package_f/mix.exs
+          * :package_g package_g/mix.exs
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--dependent",
+                   "package_a",
+                   "--recursive"
+                 ])
+               end) == expected
+      end
+    )
+  end
+
   @tag :tmp_dir
   test "filtering by --path", %{tmp_dir: tmp_dir} do
     Workspace.Test.with_workspace(

workspace/test/mix/tasks/workspace.run_test.exs

@@ -890,6 +890,117 @@ defmodule Mix.Tasks.Workspace.RunTest do
     )
   end
 
+  describe "filtering with --recursive option" do
+    @tag :tmp_dir
+    test "with --dependency and --recursive", %{tmp_dir: tmp_dir} do
+      Workspace.Test.with_workspace(
+        tmp_dir,
+        [],
+        :default,
+        fn ->
+          # Without --recursive: only package_b and package_f have package_g as direct dependency
+          # With --recursive: package_a also transitively depends on package_g
+          args = [
+            "--workspace-path",
+            tmp_dir,
+            "--dependency",
+            "package_g",
+            "--recursive",
+            "--dry-run" | @default_run_task
+          ]
+
+          captured =
+            capture_io(fn ->
+              RunTask.run(args)
+            end)
+
+          assert_cli_output_match(captured, [
+            "Running task in 4 workspace projects",
+            "==> :package_a - mix format --check-formatted mix.exs",
+            "==> :package_b - mix format --check-formatted mix.exs",
+            "==> :package_c - mix format --check-formatted mix.exs",
+            "==> :package_f - mix format --check-formatted mix.exs"
+          ])
+        end
+      )
+    end
+
+    @tag :tmp_dir
+    test "with --dependent and --recursive", %{tmp_dir: tmp_dir} do
+      Workspace.Test.with_workspace(
+        tmp_dir,
+        [],
+        :default,
+        fn ->
+          # Without --recursive: package_a depends directly on package_b, package_c, package_d
+          # With --recursive: also includes transitive dependencies
+          args = [
+            "--workspace-path",
+            tmp_dir,
+            "--dependent",
+            "package_a",
+            "--recursive",
+            "--dry-run" | @default_run_task
+          ]
+
+          captured =
+            capture_io(fn ->
+              RunTask.run(args)
+            end)
+
+          assert_cli_output_match(captured, [
+            "Running task in 6 workspace projects",
+            "==> :package_b - mix format --check-formatted mix.exs",
+            "==> :package_c - mix format --check-formatted mix.exs",
+            "==> :package_d - mix format --check-formatted mix.exs",
+            "==> :package_e - mix format --check-formatted mix.exs",
+            "==> :package_f - mix format --check-formatted mix.exs",
+            "==> :package_g - mix format --check-formatted mix.exs"
+          ])
+
+          # Verify package_a itself is not included
+          refute String.contains?(captured, "==> :package_a")
+        end
+      )
+    end
+
+    @tag :tmp_dir
+    test "with --dependency without --recursive only shows direct dependencies", %{
+      tmp_dir: tmp_dir
+    } do
+      Workspace.Test.with_workspace(
+        tmp_dir,
+        [],
+        :default,
+        fn ->
+          # Without --recursive: only direct dependencies (package_b and package_f)
+          args = [
+            "--workspace-path",
+            tmp_dir,
+            "--dependency",
+            "package_g",
+            "--dry-run" | @default_run_task
+          ]
+
+          captured =
+            capture_io(fn ->
+              RunTask.run(args)
+            end)
+
+          assert_cli_output_match(captured, [
+            "Running task in 2 workspace projects",
+            "==> :package_b - mix format --check-formatted mix.exs",
+            "==> :package_f - mix format --check-formatted mix.exs"
+          ])
+
+          # Verify transitive dependents (package_a, package_c) are not included
+          refute String.contains?(captured, "==> :package_a")
+          refute String.contains?(captured, "==> :package_c")
+        end
+      )
+    end
+  end
+
   defp maybe_shell do
     if System.version() |> String.starts_with?("1.19") do
       "--shell"