feat(gradle): excludeDependsOn based on provider relationships (#33923)

<!-- Please make sure you have read the submission guidelines before
posting an PR -->
<!--
https://github.com/nrwl/nx/blob/master/CONTRIBUTING.md#-submitting-a-pr
-->

<!-- Please make sure that your commit message follows our format -->
<!-- Example: `fix(nx): must begin with lowercase` -->

<!-- If this is a particularly complex change or feature addition, you
can request a dedicated Nx release for this pull request branch. Mention
someone from the Nx team or the `@nrwl/nx-pipelines-reviewers` and they
will confirm if the PR warrants its own release for testing purposes,
and generate it for you if appropriate. -->

## Current Behavior
<!-- This is the behavior we have today -->

We have a hard coded list of task targets to not exclude depends on. 

## Expected Behavior
<!-- This is the behavior we should expect with the changes in this PR
-->

We resolve a gradle task such that we can identify if there are provider
dependency relationships involved. If there are, then do not exclude
depends on since Gradle needs the dependsOn tasks to fulfill providers.

## Related Issue(s)
<!-- Please link the issue being fixed so it gets closed when this is
merged. -->

Fixes #

Author: lourw

packages/gradle/project-graph/src/main/kotlin/dev/nx/gradle/NxProjectReportTask.kt

@@ -52,6 +52,7 @@ abstract class NxProjectReportTask @Inject constructor(private val projectLayout
     logger.info("${Date()} Target Name Overrides ${targetNameOverrides.get()}")
     logger.info("${Date()} Target Name Prefix: ${targetNamePrefix.get()}")
     logger.info("${Date()} Atomized: ${atomized.get()}")
+
     val project = projectRef.get() // Get project reference at execution time
     val report =
         createNodeForProject(

packages/gradle/project-graph/src/main/kotlin/dev/nx/gradle/utils/ProjectUtils.kt

@@ -151,7 +151,8 @@ fun processTargetsForProject(
               dependencies,
               targetNameOverrides,
               gitIgnoreClassifier,
-              targetNamePrefix)
+              targetNamePrefix,
+              project)
 
       targets[targetName] = target
 

packages/gradle/project-graph/src/main/kotlin/dev/nx/gradle/utils/TaskUtils.kt

@@ -5,7 +5,13 @@ import dev.nx.gradle.data.Dependency
 import dev.nx.gradle.data.ExternalDepData
 import dev.nx.gradle.data.ExternalNode
 import java.io.File
+import org.gradle.api.Action
+import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.internal.TaskInternal
+import org.gradle.api.internal.provider.ProviderInternal
+import org.gradle.api.internal.tasks.DefaultTaskDependency
+import org.gradle.api.tasks.TaskProvider
 
 /**
  * Process a task and convert it into target Going to populate:
@@ -24,7 +30,8 @@ fun processTask(
     dependencies: MutableSet<Dependency>,
     targetNameOverrides: Map<String, String>,
     gitIgnoreClassifier: GitIgnoreClassifier,
-    targetNamePrefix: String = ""
+    targetNamePrefix: String = "",
+    project: Project,
 ): MutableMap<String, Any?> {
   val logger = task.logger
   logger.info("NxProjectReportTask: process $task for $projectRoot")
@@ -77,15 +84,16 @@ fun processTask(
           task.description ?: "Run ${projectBuildPath}.${task.name}", projectBuildPath, task.name)
   target["metadata"] = metadata
 
-  target["options"] =
-      if (continuous) {
-        mapOf(
-            "taskName" to "${projectBuildPath}:${task.name}",
-            "continuous" to true,
-            "excludeDependsOn" to shouldExcludeDependsOn(task))
-      } else {
-        mapOf("taskName" to "${projectBuildPath}:${task.name}")
-      }
+  target["options"] = buildMap {
+    put("taskName", "${projectBuildPath}:${task.name}")
+    val providerDependencies = findProviderBasedDependencies(task)
+    if (providerDependencies.isNotEmpty()) {
+      put("includeDependsOnTasks", providerDependencies.toList())
+    }
+    if (continuous) {
+      put("continuous", true)
+    }
+  }
 
   return target
 }
@@ -394,12 +402,6 @@ fun getMetadata(
  * Into an external dependency with key: "gradle:commons-lang3-3.13.0" with value: { "type":
  * "gradle", "name": "commons-lang3", "data": { "version": "3.13.0", "packageName":
  * "org.apache.commons.commons-lang3", "hash": "b7263237aa89c1f99b327197c41d0669707a462e",} }
- *
- * @param inputFile Path to the dependency jar.
- * @param externalNodes Map to populate with the resulting ExternalNode.
- * @param logger Gradle logger for warnings and debug info
- * @return The external dependency key (e.g., gradle:commons-lang3-3.13.0), or null if parsing
- *   fails.
  */
 fun getExternalDepFromInputFile(
     inputFile: String,
@@ -470,8 +472,52 @@ fun isCacheable(task: Task): Boolean {
   return !nonCacheableTasks.contains(task.name)
 }
 
-private val tasksWithDependsOn = setOf("bootRun", "bootJar")
+/**
+ * Finds provider-based task dependencies by inspecting lifecycle dependencies without triggering
+ * resolution. Uses Gradle internal APIs to access raw dependency values and check for providers
+ * with known producer tasks.
+ */
+fun findProviderBasedDependencies(task: Task): Set<String> {
+  val logger = task.logger
+  val producerTasks = mutableSetOf<String>()
+
+  try {
+    val taskInternal = task as? TaskInternal ?: return emptySet()
+    val lifecycleDeps = taskInternal.lifecycleDependencies
+
+    if (lifecycleDeps is DefaultTaskDependency) {
+      val rawDeps: Set<Any> = lifecycleDeps.mutableValues
+
+      rawDeps.forEach { dep ->
+        when (dep) {
+          is ProviderInternal<*> -> {
+            try {
+              val producer = dep.producer
+              if (producer.isKnown) {
+                producer.visitProducerTasks(
+                    Action { producerTask -> producerTasks.add(producerTask.path) })
+              }
+            } catch (e: Exception) {
+              logger.debug("Could not get producer from provider: ${e.message}")
+            }
+          }
+          is TaskProvider<*> -> {
+            try {
+              producerTasks.add(dep.name)
+            } catch (e: Exception) {
+              logger.debug("Could not get name from TaskProvider: ${e.message}")
+            }
+          }
+        }
+      }
+    }
+
+    if (producerTasks.isNotEmpty()) {
+      logger.info("Task ${task.path} has provider-based dependencies: $producerTasks")
+    }
+  } catch (e: Exception) {
+    logger.debug("Could not analyze provider dependencies for ${task.path}: ${e.message}")
+  }
 
-fun shouldExcludeDependsOn(task: Task): Boolean {
-  return !tasksWithDependsOn.contains(task.name)
+  return producerTasks
 }

packages/gradle/project-graph/src/test/kotlin/dev/nx/gradle/utils/ProcessTaskUtilsTest.kt

@@ -102,7 +102,8 @@ class ProcessTaskUtilsTest {
             externalNodes = mutableMapOf(),
             dependencies = mutableSetOf(),
             targetNameOverrides = emptyMap(),
-            gitIgnoreClassifier = gitIgnoreClassifier)
+            gitIgnoreClassifier = gitIgnoreClassifier,
+            project = project)
 
     assertEquals(true, result["cache"])
     assertEquals(result["executor"], "@nx/gradle:gradle")
@@ -497,7 +498,8 @@ class ProcessTaskUtilsTest {
             externalNodes = mutableMapOf(),
             dependencies = mutableSetOf(),
             targetNameOverrides = emptyMap(),
-            gitIgnoreClassifier = gitIgnoreClassifier)
+            gitIgnoreClassifier = gitIgnoreClassifier,
+            project = project)
 
     assertNotNull(result)
 
@@ -522,4 +524,75 @@ class ProcessTaskUtilsTest {
           it is Map<*, *> && (it["dependentTasksOutputFiles"] as String) == "build/classes/**/*"
         })
   }
+
+  @Nested
+  inner class ProviderBasedDependenciesTests {
+
+    @Test
+    fun `returns empty set when task has no dependencies`() {
+      val task = project.tasks.register("standalone").get()
+      assertTrue(findProviderBasedDependencies(task).isEmpty())
+    }
+
+    @Test
+    fun `identifies TaskProvider dependencies`() {
+      val producerProvider = project.tasks.register("producer")
+      val consumerProvider = project.tasks.register("consumer")
+      consumerProvider.configure { it.dependsOn(producerProvider) }
+
+      val result = findProviderBasedDependencies(consumerProvider.get())
+
+      assertTrue(result.any { it.contains("producer") }, "Found: $result")
+    }
+
+    @Test
+    fun `identifies ProviderInternal from task output files`() {
+      val producerProvider =
+          project.tasks.register("producer") { task ->
+            task.outputs.file(
+                java.io.File(project.layout.buildDirectory.asFile.get(), "output.jar"))
+          }
+      val consumerProvider = project.tasks.register("consumer")
+      consumerProvider.configure { it.dependsOn(producerProvider.map { p -> p.outputs.files }) }
+
+      val result = findProviderBasedDependencies(consumerProvider.get())
+
+      assertTrue(result.any { it.contains("producer") }, "Found: $result")
+    }
+
+    @Test
+    fun `identifies ProviderInternal from task output directory`() {
+      val compileProvider =
+          project.tasks.register("compile") { task ->
+            task.outputs.dir(java.io.File(project.layout.buildDirectory.asFile.get(), "classes"))
+          }
+      val jarProvider = project.tasks.register("jar")
+      jarProvider.configure { it.dependsOn(compileProvider.map { p -> p.outputs.files }) }
+
+      val result = findProviderBasedDependencies(jarProvider.get())
+
+      assertTrue(result.any { it.contains("compile") }, "Found: $result")
+    }
+
+    @Test
+    fun `identifies multiple TaskProvider dependencies`() {
+      val provider1 = project.tasks.register("task1")
+      val provider2 = project.tasks.register("task2")
+      val provider3 = project.tasks.register("task3")
+
+      val consumerProvider = project.tasks.register("consumer")
+      consumerProvider.configure { task ->
+        task.dependsOn(provider1)
+        task.dependsOn(provider2)
+        task.dependsOn(provider3)
+      }
+
+      val result = findProviderBasedDependencies(consumerProvider.get())
+
+      assertEquals(3, result.size)
+      assertTrue(result.any { it.contains("task1") }, "Found: $result")
+      assertTrue(result.any { it.contains("task2") }, "Found: $result")
+      assertTrue(result.any { it.contains("task3") }, "Found: $result")
+    }
+  }
 }

packages/gradle/src/executors/gradle/get-exclude-task.spec.ts

@@ -87,6 +87,33 @@ describe('getExcludeTasks', () => {
     const excludes = getExcludeTasks(targets, nodes, runningTaskIds);
     expect(excludes).toEqual(new Set(['testApp1']));
   });
+
+  it('should not exclude tasks that are in includeDependsOnTasks', () => {
+    const targets = new Set<string>(['app1:test']);
+    const runningTaskIds = new Set<string>(['app1:test']);
+    const includeDependsOnTasks = new Set<string>(['lintApp1']);
+    const excludes = getExcludeTasks(
+      targets,
+      nodes,
+      runningTaskIds,
+      includeDependsOnTasks
+    );
+    // lintApp1 should not be excluded because it's in includeDependsOnTasks
+    expect(excludes).toEqual(new Set(['buildApp2']));
+  });
+
+  it('should not exclude any tasks if all are in includeDependsOnTasks', () => {
+    const targets = new Set<string>(['app1:test']);
+    const runningTaskIds = new Set<string>(['app1:test']);
+    const includeDependsOnTasks = new Set<string>(['lintApp1', 'buildApp2']);
+    const excludes = getExcludeTasks(
+      targets,
+      nodes,
+      runningTaskIds,
+      includeDependsOnTasks
+    );
+    expect(excludes).toEqual(new Set());
+  });
 });
 
 describe('getAllDependsOn', () => {

packages/gradle/src/executors/gradle/get-exclude-task.ts

@@ -9,11 +9,18 @@ import {
  *
  * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
  * and only `test` is running, this will return: ['lint']
+ *
+ * @param taskIds - Set of Nx task IDs to process
+ * @param nodes - Project graph nodes
+ * @param runningTaskIds - Set of task IDs that are currently running (won't be excluded)
+ * @param includeDependsOnTasks - Set of Gradle task names that should be included (not excluded)
+ *   (typically provider-based dependencies that Gradle must resolve)
  */
 export function getExcludeTasks(
   taskIds: Set<string>,
   nodes: Record<string, ProjectGraphProjectNode>,
-  runningTaskIds: Set<string> = new Set()
+  runningTaskIds: Set<string> = new Set(),
+  includeDependsOnTasks: Set<string> = new Set()
 ): Set<string> {
   const excludes = new Set<string>();
 
@@ -25,7 +32,7 @@ export function getExcludeTasks(
       const taskId = typeof dep === 'string' ? dep : dep?.target;
       if (taskId && !runningTaskIds.has(taskId)) {
         const gradleTaskName = getGradleTaskNameWithNxTaskId(taskId, nodes);
-        if (gradleTaskName) {
+        if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
           excludes.add(gradleTaskName);
         }
       }

packages/gradle/src/executors/gradle/gradle-batch.impl.ts

@@ -119,13 +119,21 @@ export function getGradlewTasksToRun(
   const testTaskIdsWithExclude: Set<string> = new Set([]);
   const taskIdsWithoutExclude: Set<string> = new Set([]);
   const gradlewTasksToRun: Record<string, GradleExecutorSchema> = {};
+  const includeDependsOnTasks: Set<string> = new Set();
 
   for (const taskId of taskIds) {
     const task = taskGraph.tasks[taskId];
     const input = inputs[task.id];
 
     gradlewTasksToRun[taskId] = input;
 
+    // Collect tasks that should be included (not excluded) - typically provider-based dependencies
+    if (input.includeDependsOnTasks) {
+      for (const task of input.includeDependsOnTasks) {
+        includeDependsOnTasks.add(task);
+      }
+    }
+
     if (input.excludeDependsOn) {
       if (input.testClassName) {
         testTaskIdsWithExclude.add(taskId);
@@ -144,7 +152,12 @@ export function getGradlewTasksToRun(
     dependencies.forEach((dep) => allDependsOn.add(dep));
   }
 
-  const excludeTasks = getExcludeTasks(taskIdsWithExclude, nodes, allDependsOn);
+  const excludeTasks = getExcludeTasks(
+    taskIdsWithExclude,
+    nodes,
+    allDependsOn,
+    includeDependsOnTasks
+  );
 
   const allTestsDependsOn = new Set<string>();
   for (const taskId of testTaskIdsWithExclude) {

packages/gradle/src/executors/gradle/gradle.impl.ts

@@ -40,6 +40,7 @@ export default async function gradleExecutor(
     'testClassName',
     'args',
     'excludeDependsOn',
+    'includeDependsOnTasks',
     '__unparsed__',
   ]);
   Object.entries(options).forEach(([key, value]) => {
@@ -55,9 +56,12 @@ export default async function gradleExecutor(
   });
 
   if (options.excludeDependsOn) {
+    const includeDependsOnTasks = new Set(options.includeDependsOnTasks ?? []);
     getExcludeTasks(
       new Set([`${context.projectName}:${context.targetName}`]),
-      context.projectGraph.nodes
+      context.projectGraph.nodes,
+      new Set(),
+      includeDependsOnTasks
     ).forEach((task) => {
       if (task) {
         args.push('--exclude-task', task);

packages/gradle/src/executors/gradle/schema.d.ts

@@ -3,5 +3,6 @@ export interface GradleExecutorSchema {
   testClassName?: string;
   args?: string[] | string;
   excludeDependsOn: boolean;
+  includeDependsOnTasks?: string[];
   __unparsed__?: string[];
 }

packages/gradle/src/executors/gradle/schema.json

@@ -34,6 +34,14 @@
       "default": true,
       "x-priority": "internal"
     },
+    "includeDependsOnTasks": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of Gradle task paths that should be included (not excluded) even when excludeDependsOn is true. These are typically provider-based dependencies that Gradle must resolve.",
+      "x-priority": "internal"
+    },
     "__unparsed__": {
       "type": "array",
       "items": {