@nx/gradle 23.0.0-beta.0 → 23.0.0-pr.35413.460eeef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "23.0.0-beta.0",
+  "version": "23.0.0-pr.35413.460eeef",
   "private": false,
   "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
   "repository": {
@@ -40,13 +40,13 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "23.0.0-beta.0",
+    "@nx/devkit": "23.0.0-pr.35413.460eeef",
     "toml-eslint-parser": "^0.10.0",
     "tree-kill": "^1.2.2",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "23.0.0-beta.0"
+    "nx": "23.0.0-pr.35413.460eeef"
   },
   "publishConfig": {
     "access": "public"

package/src/executors/gradle/get-exclude-task.d.ts

@@ -1,10 +1,14 @@
-import { ProjectGraphProjectNode, Target } from '@nx/devkit';
+import { ProjectGraphProjectNode, Target, TaskGraph } from '@nx/devkit';
 /**
- * Returns Gradle CLI arguments to exclude dependent tasks
- * that are not part of the current execution set.
+ * Project-graph-based exclude resolver for the single-task executor.
  *
- * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
- * and only `test` is running, this will return: ['lint']
+ * Walks the full transitive dependsOn graph for each task so that
+ * indirect dependencies (e.g. the deps of a direct dep's `jar`)
+ * are also excluded, matching Gradle's own transitive task graph.
+ *
+ * For batch mode, prefer `getExcludeTasksFromTaskGraph` — it uses the
+ * TaskGraph Nx has already computed, which reflects exactly what will
+ * run and picks up cross-project implicit dependencies.
  *
  * @param tasks - Set of Target to process
  * @param nodes - Project graph nodes
@@ -14,5 +18,25 @@ import { ProjectGraphProjectNode, Target } from '@nx/devkit';
  */
 export declare function getExcludeTasks(tasks: Set<Target>, nodes: Record<string, ProjectGraphProjectNode>, runningTasks?: Set<Target>, includeDependsOnTasks?: Set<string>): Set<string>;
 export declare function getGradleTaskName(pt: Target, nodes: Record<string, ProjectGraphProjectNode>): string | null;
-export declare function getAllDependsOn(nodes: Record<string, ProjectGraphProjectNode>, projectName: string, targetName: string): Set<Target>;
+/**
+ * Task-graph-based exclude resolver for batch mode.
+ *
+ * Walks `taskGraph.dependencies` transitively from each starting task id.
+ * Any reachable dependency task that is NOT in `runningTaskIds` has its
+ * Gradle `taskName` (resolved from project graph nodes) added to the
+ * excludes, unless it appears in `includeDependsOnTasks`.
+ *
+ * @param taskIdsToExcludeDepsOf - Task IDs whose dependsOn chain should be excluded
+ * @param runningTaskIds - Task IDs that WILL run and therefore must not be excluded
+ * @param taskGraph - The task graph for the current batch
+ * @param nodes - Project graph nodes, used only to look up each task's `taskName`
+ * @param includeDependsOnTasks - Gradle task names to never exclude (provider-based deps)
+ */
+export declare function getExcludeTasksFromTaskGraph(taskIdsToExcludeDepsOf: Iterable<string>, runningTaskIds: Set<string>, taskGraph: TaskGraph, nodes: Record<string, ProjectGraphProjectNode>, includeDependsOnTasks?: Set<string>): Set<string>;
+/**
+ * Returns the transitive set of dependency task IDs reachable via
+ * `taskGraph.dependencies` from the given starting IDs. The starting
+ * IDs themselves are NOT included in the result. Cycle-safe.
+ */
+export declare function getAllDependsOnFromTaskGraph(startTaskIds: Iterable<string>, taskGraph: TaskGraph): Set<string>;
 //# sourceMappingURL=get-exclude-task.d.ts.map

package/src/executors/gradle/get-exclude-task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-exclude-task.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/get-exclude-task.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,MAAM,EAEP,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,EACrC,qBAAqB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAC7C,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GACjB,GAAG,CAAC,MAAM,CAAC,CAgCb"}
+{"version":3,"file":"get-exclude-task.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/get-exclude-task.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,MAAM,EACN,SAAS,EAEV,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,EACrC,qBAAqB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,GAAG,CAAC,MAAM,CAAC,CAwBb;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAC7C,MAAM,GAAG,IAAI,CAEf;AAwCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,EAC3B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,qBAAqB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC9B,SAAS,EAAE,SAAS,GACnB,GAAG,CAAC,MAAM,CAAC,CA4Bb"}

package/src/executors/gradle/get-exclude-task.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExcludeTasks = getExcludeTasks;
 exports.getGradleTaskName = getGradleTaskName;
-exports.getAllDependsOn = getAllDependsOn;
+exports.getExcludeTasksFromTaskGraph = getExcludeTasksFromTaskGraph;
+exports.getAllDependsOnFromTaskGraph = getAllDependsOnFromTaskGraph;
 const devkit_1 = require("@nx/devkit");
 /**
  * Resolves a dependsOn entry to a Target.
@@ -30,11 +31,15 @@ function resolveDepToTarget(dep, owningProject) {
     return { project: owningProject, target };
 }
 /**
- * Returns Gradle CLI arguments to exclude dependent tasks
- * that are not part of the current execution set.
+ * Project-graph-based exclude resolver for the single-task executor.
  *
- * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
- * and only `test` is running, this will return: ['lint']
+ * Walks the full transitive dependsOn graph for each task so that
+ * indirect dependencies (e.g. the deps of a direct dep's `jar`)
+ * are also excluded, matching Gradle's own transitive task graph.
+ *
+ * For batch mode, prefer `getExcludeTasksFromTaskGraph` — it uses the
+ * TaskGraph Nx has already computed, which reflects exactly what will
+ * run and picks up cross-project implicit dependencies.
  *
  * @param tasks - Set of Target to process
  * @param nodes - Project graph nodes
@@ -46,14 +51,14 @@ function getExcludeTasks(tasks, nodes, runningTasks = new Set(), includeDependsO
     const excludes = new Set();
     const runningKeys = new Set(Array.from(runningTasks).map(devkit_1.targetToTargetString));
     for (const task of tasks) {
-        const taskDeps = nodes[task.project]?.data?.targets?.[task.target]?.dependsOn ?? [];
-        for (const dep of taskDeps) {
-            const depPt = resolveDepToTarget(dep, task.project);
-            if (depPt && !runningKeys.has((0, devkit_1.targetToTargetString)(depPt))) {
-                const gradleTaskName = getGradleTaskName(depPt, nodes);
-                if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
-                    excludes.add(gradleTaskName);
-                }
+        const transitiveDeps = getAllDependsOnFromProjectGraph(nodes, task.project, task.target);
+        for (const depPt of transitiveDeps) {
+            if (runningKeys.has((0, devkit_1.targetToTargetString)(depPt))) {
+                continue;
+            }
+            const gradleTaskName = getGradleTaskName(depPt, nodes);
+            if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
+                excludes.add(gradleTaskName);
             }
         }
     }
@@ -62,8 +67,8 @@ function getExcludeTasks(tasks, nodes, runningTasks = new Set(), includeDependsO
 function getGradleTaskName(pt, nodes) {
     return nodes[pt.project]?.data?.targets?.[pt.target]?.options?.taskName;
 }
-function getAllDependsOn(nodes, projectName, targetName) {
-    const allDependsOn = new Set();
+function getAllDependsOnFromProjectGraph(nodes, projectName, targetName) {
+    const seen = new Set();
     const result = new Set();
     const startKey = (0, devkit_1.targetToTargetString)({
         project: projectName,
@@ -73,18 +78,80 @@ function getAllDependsOn(nodes, projectName, targetName) {
     while (stack.length > 0) {
         const current = stack.pop();
         const key = (0, devkit_1.targetToTargetString)(current);
-        if (!allDependsOn.has(key)) {
-            allDependsOn.add(key);
-            if (key !== startKey) {
-                result.add(current);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        if (key !== startKey) {
+            result.add(current);
+        }
+        const directDependencies = nodes[current.project]?.data?.targets?.[current.target]?.dependsOn ?? [];
+        for (const dep of directDependencies) {
+            const depPt = resolveDepToTarget(dep, current.project);
+            if (depPt && !seen.has((0, devkit_1.targetToTargetString)(depPt))) {
+                stack.push(depPt);
             }
-            const directDependencies = nodes[current.project]?.data?.targets?.[current.target]?.dependsOn ??
-                [];
-            for (const dep of directDependencies) {
-                const depPt = resolveDepToTarget(dep, current.project);
-                if (depPt && !allDependsOn.has((0, devkit_1.targetToTargetString)(depPt))) {
-                    stack.push(depPt);
-                }
+        }
+    }
+    return result;
+}
+/**
+ * Task-graph-based exclude resolver for batch mode.
+ *
+ * Walks `taskGraph.dependencies` transitively from each starting task id.
+ * Any reachable dependency task that is NOT in `runningTaskIds` has its
+ * Gradle `taskName` (resolved from project graph nodes) added to the
+ * excludes, unless it appears in `includeDependsOnTasks`.
+ *
+ * @param taskIdsToExcludeDepsOf - Task IDs whose dependsOn chain should be excluded
+ * @param runningTaskIds - Task IDs that WILL run and therefore must not be excluded
+ * @param taskGraph - The task graph for the current batch
+ * @param nodes - Project graph nodes, used only to look up each task's `taskName`
+ * @param includeDependsOnTasks - Gradle task names to never exclude (provider-based deps)
+ */
+function getExcludeTasksFromTaskGraph(taskIdsToExcludeDepsOf, runningTaskIds, taskGraph, nodes, includeDependsOnTasks = new Set()) {
+    const excludes = new Set();
+    const transitiveDepIds = getAllDependsOnFromTaskGraph(taskIdsToExcludeDepsOf, taskGraph);
+    for (const depTaskId of transitiveDepIds) {
+        if (runningTaskIds.has(depTaskId)) {
+            continue;
+        }
+        const task = taskGraph.tasks[depTaskId];
+        if (!task) {
+            continue;
+        }
+        const gradleTaskName = getGradleTaskName(task.target, nodes);
+        if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
+            excludes.add(gradleTaskName);
+        }
+    }
+    return excludes;
+}
+/**
+ * Returns the transitive set of dependency task IDs reachable via
+ * `taskGraph.dependencies` from the given starting IDs. The starting
+ * IDs themselves are NOT included in the result. Cycle-safe.
+ */
+function getAllDependsOnFromTaskGraph(startTaskIds, taskGraph) {
+    const result = new Set();
+    const seen = new Set();
+    const stack = [];
+    for (const id of startTaskIds) {
+        seen.add(id);
+        for (const dep of taskGraph.dependencies[id] ?? []) {
+            stack.push(dep);
+        }
+    }
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        result.add(current);
+        for (const dep of taskGraph.dependencies[current] ?? []) {
+            if (!seen.has(dep)) {
+                stack.push(dep);
             }
         }
     }

package/src/executors/gradle/gradle-batch.impl.d.ts

@@ -5,9 +5,15 @@ import { GradleExecutorSchema } from './schema';
 export declare const batchRunnerPath: string;
 export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): Promise<BatchResults>;
 /**
- * Get the gradlew task ids to run
+ * Get the gradlew task ids to run.
+ *
+ * `taskGraph` is the batch's task graph (only tasks running in this batch
+ * invocation). `fullTaskGraph` is the full task graph for the whole `nx`
+ * command (defaults to `taskGraph`); transitive dependency walks use it so
+ * that deps filtered out of the batch — cached tasks, tasks scheduled in
+ * other batches — are still resolved when computing excludes.
  */
-export declare function getGradlewTasksToRun(taskIds: string[], taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, nodes: Record<string, ProjectGraphProjectNode>): {
+export declare function getGradlewTasksToRun(taskIds: string[], taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, nodes: Record<string, ProjectGraphProjectNode>, fullTaskGraph?: TaskGraph): {
     gradlewTasksToRun: Record<string, GradleExecutorSchema>;
     excludeTasks: Set<string>;
     excludeTestTasks: Set<string>;

package/src/executors/gradle/gradle-batch.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradle-batch.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle-batch.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,uBAAuB,EAEvB,SAAS,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,kBAAkB,EACnB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAchD,eAAO,MAAM,eAAe,QAG3B,CAAC;AAEF,wBAA8B,WAAW,CACvC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAkEvB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC;;;;EAuE/C"}
+{"version":3,"file":"gradle-batch.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle-batch.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,uBAAuB,EACvB,SAAS,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,kBAAkB,EACnB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAchD,eAAO,MAAM,eAAe,QAG3B,CAAC;AAEF,wBAA8B,WAAW,CACvC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAmEvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,aAAa,GAAE,SAAqB;;;;EAuErC"}

package/src/executors/gradle/gradle-batch.impl.js

@@ -28,7 +28,7 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
             args.push(...overrides.__overrides_unparsed__);
         }
         const taskIds = Object.keys(taskGraph.tasks);
-        const { gradlewTasksToRun, excludeTasks, excludeTestTasks } = getGradlewTasksToRun(taskIds, taskGraph, inputs, context.projectGraph.nodes);
+        const { gradlewTasksToRun, excludeTasks, excludeTestTasks } = getGradlewTasksToRun(taskIds, taskGraph, inputs, context.projectGraph.nodes, context.taskGraph ?? taskGraph);
         const batchResults = await runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root);
         taskIds.forEach((taskId) => {
             if (!batchResults[taskId]) {
@@ -52,21 +52,22 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
     }
 }
 /**
- * Get the gradlew task ids to run
+ * Get the gradlew task ids to run.
+ *
+ * `taskGraph` is the batch's task graph (only tasks running in this batch
+ * invocation). `fullTaskGraph` is the full task graph for the whole `nx`
+ * command (defaults to `taskGraph`); transitive dependency walks use it so
+ * that deps filtered out of the batch — cached tasks, tasks scheduled in
+ * other batches — are still resolved when computing excludes.
  */
-function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes) {
-    const tasksWithExclude = new Set();
-    const testTasksWithExclude = new Set();
-    const tasksWithoutExclude = new Set();
+function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes, fullTaskGraph = taskGraph) {
+    const tasksWithExcludeIds = new Set();
+    const testTasksWithExcludeIds = new Set();
+    const tasksWithoutExcludeIds = new Set();
     const gradlewTasksToRun = {};
     const includeDependsOnTasks = new Set();
     for (const taskId of taskIds) {
-        const task = taskGraph.tasks[taskId];
-        const input = inputs[task.id];
-        const taskTarget = {
-            project: task.target.project,
-            target: task.target.target,
-        };
+        const input = inputs[taskId];
         gradlewTasksToRun[taskId] = input;
         if (input.includeDependsOnTasks) {
             for (const t of input.includeDependsOnTasks) {
@@ -75,33 +76,33 @@ function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes) {
         }
         if (input.excludeDependsOn) {
             if (input.testClassName) {
-                testTasksWithExclude.add(taskTarget);
+                testTasksWithExcludeIds.add(taskId);
             }
             else {
-                tasksWithExclude.add(taskTarget);
+                tasksWithExcludeIds.add(taskId);
             }
         }
         else {
-            tasksWithoutExclude.add(taskTarget);
+            tasksWithoutExcludeIds.add(taskId);
         }
     }
-    const allRunning = new Set(taskIds.map((id) => ({
-        project: taskGraph.tasks[id].target.project,
-        target: taskGraph.tasks[id].target.target,
-    })));
-    for (const task of tasksWithoutExclude) {
-        const dependencies = (0, get_exclude_task_1.getAllDependsOn)(nodes, task.project, task.target);
-        dependencies.forEach((dep) => allRunning.add(dep));
-    }
-    const excludeTasks = (0, get_exclude_task_1.getExcludeTasks)(tasksWithExclude, nodes, allRunning, includeDependsOnTasks);
-    const allTestsDependsOn = new Set();
-    for (const task of testTasksWithExclude) {
-        const taskDependsOn = (0, get_exclude_task_1.getAllDependsOn)(nodes, task.project, task.target);
-        taskDependsOn.forEach((dep) => allTestsDependsOn.add(dep));
+    const runningTaskIds = new Set(taskIds);
+    const batchTaskIds = new Set(taskIds);
+    const nonExcludeDeps = (0, get_exclude_task_1.getAllDependsOnFromTaskGraph)(tasksWithoutExcludeIds, fullTaskGraph);
+    for (const depId of nonExcludeDeps) {
+        if (batchTaskIds.has(depId)) {
+            runningTaskIds.add(depId);
+        }
     }
+    const excludeTasks = (0, get_exclude_task_1.getExcludeTasksFromTaskGraph)(tasksWithExcludeIds, runningTaskIds, fullTaskGraph, nodes, includeDependsOnTasks);
     const excludeTestTasks = new Set();
-    for (const task of allTestsDependsOn) {
-        const gradleTaskName = (0, get_exclude_task_1.getGradleTaskName)(task, nodes);
+    const testDepIds = (0, get_exclude_task_1.getAllDependsOnFromTaskGraph)(testTasksWithExcludeIds, fullTaskGraph);
+    for (const depTaskId of testDepIds) {
+        const task = fullTaskGraph.tasks[depTaskId];
+        if (!task) {
+            continue;
+        }
+        const gradleTaskName = (0, get_exclude_task_1.getGradleTaskName)(task.target, nodes);
         if (gradleTaskName) {
             excludeTestTasks.add(gradleTaskName);
         }