@nx/gradle 23.2.0-beta.1 → 23.2.0-beta.11

package/README.md

@@ -7,9 +7,9 @@
 
 <div style="text-align: center;">
 
-[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)](<>)
 [![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
-[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
 [![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)

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

@@ -1,7 +1,6 @@
 import { ExecutorContext, ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
-import { RunCommandsOptions } from 'nx/src/executors/run-commands/run-commands.impl';
-import { TaskResult } from 'nx/src/config/misc-interfaces';
 import { GradleExecutorSchema } from './schema';
+import { RunCommandsOptions, TaskResult } from '@nx/devkit/internal';
 export declare const batchRunnerPath: string;
 export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): AsyncGenerator<{
     task: string;

package/dist/src/executors/gradle/gradle.impl.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = gradleExecutor;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const exec_gradle_1 = require("../../utils/exec-gradle");
 const node_path_1 = require("node:path");
-const run_commands_impl_1 = tslib_1.__importDefault(require("nx/src/executors/run-commands/run-commands.impl"));
+const internal_1 = require("@nx/devkit/internal");
 const get_exclude_task_1 = require("./get-exclude-task");
 async function gradleExecutor(options, context) {
     let projectRoot = context.projectGraph.nodes[context.projectName]?.data?.root ?? context.root;
@@ -56,7 +55,7 @@ async function gradleExecutor(options, context) {
         });
     }
     try {
-        const { success } = await (0, run_commands_impl_1.default)({
+        const { success } = await (0, internal_1.runCommandsExecutor)({
             command: `${gradlewPath} ${options.taskName}`,
             cwd: (0, node_path_1.dirname)(gradlewPath),
             args: args,

package/dist/src/generators/ci-workflow/generator.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ciWorkflowGenerator = ciWorkflowGenerator;
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
-const nx_cloud_utils_1 = require("nx/src/utils/nx-cloud-utils");
-const default_base_1 = require("nx/src/utils/default-base");
+const internal_1 = require("@nx/devkit/internal");
 function getCiCommands(ci) {
     switch (ci) {
         case 'circleci': {
@@ -54,13 +53,13 @@ function getTemplateData(tree, options) {
     const { name: workflowName, fileName: workflowFileName } = (0, devkit_1.names)(options.name);
     let nxCloudHost = 'nx.app';
     try {
-        const nxCloudUrl = (0, nx_cloud_utils_1.getNxCloudUrl)((0, devkit_1.readNxJson)(tree));
+        const nxCloudUrl = (0, internal_1.getNxCloudUrl)((0, devkit_1.readNxJson)(tree));
         nxCloudHost = new URL(nxCloudUrl).host;
     }
     catch { }
-    const mainBranch = (0, default_base_1.deduceDefaultBase)();
+    const mainBranch = (0, internal_1.deduceDefaultBase)();
     const commands = options.commands ?? getCiCommands(options.ci);
-    const connectedToCloud = (0, nx_cloud_utils_1.isNxCloudUsed)((0, devkit_1.readNxJson)(tree));
+    const connectedToCloud = (0, internal_1.isNxCloudUsed)((0, devkit_1.readNxJson)(tree));
     return {
         workflowName,
         workflowFileName,

package/dist/src/generators/init/gradle-project-graph-plugin-utils.js

@@ -205,14 +205,15 @@ async function addNxProjectGraphPluginToBuildGradle(gradleFilePath, buildGradleC
     if (!hasPluginViaAlias) {
         const applyPluginPattern = versionCatalogPluginAccessor
             ? new RegExp(`\\s*plugin\\(${versionCatalogPluginAccessor.replace(/\./g, '\\.')}\\)`)
-            : new RegExp(`\\s*plugin\\(["']${versions_1.gradleProjectGraphPluginName}["']\\)`);
+            : // Both DSL forms, so a re-run doesn't append a duplicate apply.
+                new RegExp(`\\s*plugin\\s*[:(]\\s*["']${versions_1.gradleProjectGraphPluginName.replace(/\./g, '\\.')}["']`);
         if (buildGradleContent.includes('allprojects {')) {
             if (!applyPluginPattern.test(buildGradleContent)) {
                 const applyPlugin = versionCatalogPluginAccessor
                     ? `plugin(${versionCatalogPluginAccessor})`
                     : isKotlinDsl
                         ? `plugin("${versions_1.gradleProjectGraphPluginName}")`
-                        : `plugin "${versions_1.gradleProjectGraphPluginName}"`;
+                        : `plugin: "${versions_1.gradleProjectGraphPluginName}"`;
                 buildGradleContent = buildGradleContent.replace(/allprojects\s*\{/, `allprojects {\n    apply ${applyPlugin}`);
             }
         }

package/dist/src/migrations/23-2-0/change-plugin-version-0-1-25.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/dist/src/migrations/23-2-0/change-plugin-version-0-1-25.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
+const gradle_project_graph_plugin_utils_1 = require("../../generators/init/gradle-project-graph-plugin-utils");
+const version_catalog_ast_utils_1 = require("../../utils/version-catalog-ast-utils");
+/* Change the plugin version to 0.1.25
+ */
+async function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    if (!(0, has_gradle_plugin_1.hasGradlePlugin)(tree)) {
+        return;
+    }
+    const gradlePluginVersionToUpdate = '0.1.25';
+    // Update version in version catalogs using AST-based approach to preserve formatting
+    await (0, version_catalog_ast_utils_1.updateNxPluginVersionInCatalogsAst)(tree, gradlePluginVersionToUpdate);
+    // Then update in build.gradle(.kts) files
+    await (0, gradle_project_graph_plugin_utils_1.addNxProjectGraphPlugin)(tree, gradlePluginVersionToUpdate);
+}

package/dist/src/migrations/23-2-0/change-plugin-version-0-1-25.md

@@ -0,0 +1,21 @@
+#### Change dev.nx.gradle.project-graph to version 0.1.25
+
+Change dev.nx.gradle.project-graph to version 0.1.25 in build file
+
+#### Sample Code Changes
+
+##### Before
+
+```text title="build.gradle"
+plugins {
+id "dev.nx.gradle.project-graph" version "0.1.24"
+}
+```
+
+##### After
+
+```text title="build.gradle"
+plugins {
+id "dev.nx.gradle.project-graph" version "0.1.25"
+}
+```

package/dist/src/plugin/dependencies.js

@@ -5,10 +5,10 @@ const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
 const get_project_graph_from_gradle_plugin_1 = require("./utils/get-project-graph-from-gradle-plugin");
 const split_config_files_1 = require("../utils/split-config-files");
-const workspace_context_1 = require("nx/src/utils/workspace-context");
 const node_fs_1 = require("node:fs");
+const internal_1 = require("@nx/devkit/internal");
 const createDependencies = async (options, context) => {
-    const files = await (0, workspace_context_1.globWithWorkspaceContext)(devkit_1.workspaceRoot, Array.from(split_config_files_1.GRADLEW_FILES));
+    const files = await (0, internal_1.globWithWorkspaceContext)(devkit_1.workspaceRoot, Array.from(split_config_files_1.GRADLEW_FILES));
     const { gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(files);
     await (0, get_project_graph_from_gradle_plugin_1.populateProjectGraph)(context.workspaceRoot, gradlewFiles.map((file) => (0, node_path_1.join)(devkit_1.workspaceRoot, file)), options);
     const { dependencies: dependenciesFromReport } = (0, get_project_graph_from_gradle_plugin_1.getCurrentProjectGraphReport)();
@@ -16,7 +16,8 @@ const createDependencies = async (options, context) => {
     dependenciesFromReport.forEach((dependencyFromPlugin) => {
         try {
             // Report paths are workspace-relative with `/` separators
-            const sourceProjectName = Object.values(context.projects).find((project) => dependencyFromPlugin.source === project.root)?.name ?? dependencyFromPlugin.source;
+            const sourceProject = Object.values(context.projects).find((project) => dependencyFromPlugin.source === project.root);
+            const sourceProjectName = sourceProject?.name ?? dependencyFromPlugin.source;
             const targetProjectName = Object.values(context.projects).find((project) => dependencyFromPlugin.target === project.root)?.name ?? dependencyFromPlugin.target;
             const sourceFile = dependencyFromPlugin.sourceFile;
             if (!sourceProjectName ||
@@ -24,12 +25,21 @@ const createDependencies = async (options, context) => {
                 !(0, node_fs_1.existsSync)((0, node_path_1.join)(devkit_1.workspaceRoot, sourceFile))) {
                 return;
             }
-            const dependency = {
-                source: sourceProjectName,
-                target: targetProjectName,
-                type: devkit_1.DependencyType.static,
-                sourceFile,
-            };
+            // An ancestor-configured project's build file lies outside it, and Nx rejects a foreign
+            // sourceFile — record implicit rather than drop.
+            const ownsSourceFile = !!sourceProject && (0, node_path_1.dirname)(sourceFile) === sourceProject.root;
+            const dependency = ownsSourceFile
+                ? {
+                    source: sourceProjectName,
+                    target: targetProjectName,
+                    type: devkit_1.DependencyType.static,
+                    sourceFile,
+                }
+                : {
+                    source: sourceProjectName,
+                    target: targetProjectName,
+                    type: devkit_1.DependencyType.implicit,
+                };
             (0, devkit_1.validateDependency)(dependency, context);
             dependencies.push(dependency);
         }

package/dist/src/plugin/nodes.js

@@ -4,9 +4,6 @@ exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = exports.cre
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
-const plugin_cache_utils_1 = require("nx/src/utils/plugin-cache-utils");
-const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const split_config_files_1 = require("../utils/split-config-files");
 const get_project_graph_from_gradle_plugin_1 = require("./utils/get-project-graph-from-gradle-plugin");
 const gradle_plugin_options_1 = require("./utils/gradle-plugin-options");
@@ -70,68 +67,54 @@ function extractNxConfigOnly(project) {
 exports.createNodes = [
     split_config_files_1.gradleConfigAndTestGlob,
     async (files, options, context) => {
-        const { buildFiles: buildFilesFromSplitConfigFiles, gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(files);
-        const optionsHash = (0, file_hasher_1.hashObject)(options);
-        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `gradle-${optionsHash}.hash`);
-        const pluginCache = new plugin_cache_utils_1.PluginCache(cachePath);
+        const { gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(files);
         await (0, get_project_graph_from_gradle_plugin_1.populateProjectGraph)(context.workspaceRoot, gradlewFiles.map((f) => (0, node_path_1.join)(context.workspaceRoot, f)), options);
         const report = (0, get_project_graph_from_gradle_plugin_1.getCurrentProjectGraphReport)();
-        const { nodes, externalNodes = {}, buildFiles = [] } = report;
-        // Combine buildFilesFromSplitConfigFiles and buildFiles, making each value distinct
-        const allBuildFiles = Array.from(new Set([...buildFilesFromSplitConfigFiles, ...buildFiles]));
-        try {
-            const results = [];
-            const normalizedOptions = (0, gradle_plugin_options_1.normalizeOptions)(options);
-            const buildFileProjectRoots = allBuildFiles.map((f) => (0, node_path_1.dirname)(f));
-            const buildFileHashes = await (0, internal_1.calculateHashesForCreateNodes)(buildFileProjectRoots, normalizedOptions ?? {}, context);
-            for (let i = 0; i < allBuildFiles.length; i++) {
-                const gradleFilePath = allBuildFiles[i];
-                const projectRoot = buildFileProjectRoots[i];
-                const hash = buildFileHashes[i];
-                // Get project from cache or nodes (report keys are workspace-relative
-                // with `/` separators)
-                if (!pluginCache.has(hash)) {
-                    const nodeProject = nodes[(0, devkit_1.normalizePath)(projectRoot)];
-                    if (nodeProject) {
-                        pluginCache.set(hash, nodeProject);
-                    }
-                }
-                const project = pluginCache.get(hash);
-                if (!project) {
-                    continue;
-                }
-                const normalizedProjectRoot = (0, devkit_1.normalizePath)(projectRoot);
-                // Result 1: Gradle-detected configuration (without nxConfig)
-                const gradleConfig = stripNxConfig(project);
-                gradleConfig.root = normalizedProjectRoot;
+        const { nodes, externalNodes = {}, buildFileByProjectRoot = {} } = report;
+        const results = [];
+        // Roots outside the workspace stay absolute in the report and cannot become Nx projects.
+        const projectRoots = Object.keys(nodes)
+            .map((root) => (0, devkit_1.normalizePath)(root))
+            .filter((root) => !(0, node_path_1.isAbsolute)(root) && !root.startsWith('../'));
+        for (const normalizedProjectRoot of projectRoots) {
+            const gradleFilePath = buildFileByProjectRoot[normalizedProjectRoot];
+            if (!gradleFilePath) {
+                // No build file anywhere up the ancestry, or an ancestor configures it and the plugin
+                // predates effectiveBuildFile.
+                devkit_1.logger.verbose(`[@nx/gradle] no build file reported for "${normalizedProjectRoot}"; skipping it. Add a build file (or run @nx/gradle:init), or upgrade dev.nx.gradle.project-graph if projects are missing.`);
+                continue;
+            }
+            const project = nodes[normalizedProjectRoot];
+            if (!project) {
+                continue;
+            }
+            // Result 1: Gradle-detected configuration (without nxConfig)
+            const gradleConfig = stripNxConfig(project);
+            gradleConfig.root = normalizedProjectRoot;
+            results.push([
+                gradleFilePath,
+                {
+                    projects: {
+                        [normalizedProjectRoot]: gradleConfig,
+                    },
+                    externalNodes: externalNodes,
+                },
+            ]);
+            // Result 2: nxConfig-only configuration (if exists)
+            const nxConfigOnly = extractNxConfigOnly(project);
+            if (nxConfigOnly) {
+                nxConfigOnly.root = normalizedProjectRoot;
                 results.push([
                     gradleFilePath,
                     {
                         projects: {
-                            [normalizedProjectRoot]: gradleConfig,
+                            [normalizedProjectRoot]: nxConfigOnly,
                         },
-                        externalNodes: externalNodes,
                     },
                 ]);
-                // Result 2: nxConfig-only configuration (if exists)
-                const nxConfigOnly = extractNxConfigOnly(project);
-                if (nxConfigOnly) {
-                    nxConfigOnly.root = normalizedProjectRoot;
-                    results.push([
-                        gradleFilePath,
-                        {
-                            projects: {
-                                [normalizedProjectRoot]: nxConfigOnly,
-                            },
-                        },
-                    ]);
-                }
             }
-            return results;
-        }
-        finally {
-            pluginCache.writeToDisk();
         }
+        return results;
     },
 ];
 /**

package/dist/src/plugin/utils/get-project-graph-from-gradle-plugin.d.ts

@@ -7,6 +7,11 @@ export interface ProjectGraphReport {
     dependencies: Array<StaticDependency>;
     externalNodes?: Record<string, ProjectGraphExternalNode>;
     buildFiles?: string[];
+    /**
+     * Project root -> the build file that configures it, derived here (not plugin-reported). Flat
+     * `buildFiles` loses the pairing; no entry means the report named no build file.
+     */
+    buildFileByProjectRoot?: Record<string, string>;
 }
 export interface ProjectGraphReportCache extends ProjectGraphReport {
     hash: string;

package/dist/src/plugin/utils/get-project-graph-from-gradle-plugin.js

@@ -8,13 +8,11 @@ exports.processNxProjectGraph = processNxProjectGraph;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const devkit_1 = require("@nx/devkit");
-const workspace_context_1 = require("nx/src/utils/workspace-context");
 const split_config_files_1 = require("../../utils/split-config-files");
 const versions_1 = require("../../utils/versions");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
 const get_project_graph_lines_1 = require("./get-project-graph-lines");
 const gradle_plugin_options_1 = require("./gradle-plugin-options");
-const devkit_internals_1 = require("nx/src/devkit-internals");
+const internal_1 = require("@nx/devkit/internal");
 function readProjectGraphReportCache(cachePath, hash) {
     const projectGraphReportCache = (0, node_fs_1.existsSync)(cachePath)
         ? (0, devkit_1.readJsonFile)(cachePath)
@@ -43,7 +41,7 @@ function writeProjectGraphReportToCache(cachePath, results, hash) {
     }
 }
 let projectGraphReportCache;
-let projectGraphReportCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'gradle-nodes.hash');
+let projectGraphReportCachePath = (0, node_path_1.join)(internal_1.workspaceDataDirectory, 'gradle-nodes.hash');
 function getCurrentProjectGraphReport() {
     if (!projectGraphReportCache) {
         throw new devkit_1.AggregateCreateNodesError([
@@ -72,8 +70,8 @@ function getCurrentBuildFiles() {
 async function populateProjectGraph(workspaceRoot, gradlewFiles, options) {
     const normalizedOptions = (0, gradle_plugin_options_1.normalizeOptions)(options);
     const gradleConfigHash = (0, devkit_1.hashArray)([
-        await (0, workspace_context_1.hashWithWorkspaceContext)(workspaceRoot, [split_config_files_1.gradleConfigAndTestGlob]),
-        (0, devkit_internals_1.hashObject)(normalizedOptions),
+        await (0, internal_1.hashWithWorkspaceContext)(workspaceRoot, [split_config_files_1.gradleConfigAndTestGlob]),
+        (0, internal_1.hashObject)(normalizedOptions),
         process.env.CI,
     ]);
     const cached = readProjectGraphReportCache(projectGraphReportCachePath, gradleConfigHash);
@@ -120,6 +118,7 @@ function processNxProjectGraph(projectGraphLines) {
         externalNodes: {},
     };
     const allBuildFiles = new Set();
+    const buildFileByProjectRoot = {};
     while (index < projectGraphLines.length) {
         const line = projectGraphLines[index].trim();
         if (line.startsWith('> Task ') && line.endsWith(':nxProjectGraph')) {
@@ -151,11 +150,20 @@ function processNxProjectGraph(projectGraphLines) {
             }
             if (projectGraphReportJson.buildFiles) {
                 projectGraphReportJson.buildFiles.forEach((buildFile) => allBuildFiles.add(buildFile));
+                // One report describes one project, so its single build file is that project's.
+                const [buildFile] = projectGraphReportJson.buildFiles;
+                if (buildFile) {
+                    for (const projectRoot of Object.keys(projectGraphReportJson.nodes ?? {})) {
+                        buildFileByProjectRoot[projectRoot] = buildFile;
+                    }
+                }
             }
         }
         index++;
     }
     // Convert Set to array for the final result
     projectGraphReportForAllProjects.buildFiles = Array.from(allBuildFiles);
+    projectGraphReportForAllProjects.buildFileByProjectRoot =
+        buildFileByProjectRoot;
     return projectGraphReportForAllProjects;
 }

package/dist/src/plugin/utils/get-project-graph-lines.js

@@ -4,9 +4,20 @@ exports.cancelPendingProjectGraphRequest = cancelPendingProjectGraphRequest;
 exports.getGraphTimeoutMs = getGraphTimeoutMs;
 exports.getNxProjectGraphLines = getNxProjectGraphLines;
 const devkit_1 = require("@nx/devkit");
-const devkit_internals_1 = require("nx/src/devkit-internals");
 const exec_gradle_1 = require("../../utils/exec-gradle");
-const DEFAULT_GRAPH_TIMEOUT_SECONDS = (0, devkit_internals_1.isCI)() ? 600 : 120;
+const internal_1 = require("@nx/devkit/internal");
+const DEFAULT_GRAPH_TIMEOUT_SECONDS = (0, internal_1.isCI)() ? 600 : 120;
+// setTimeout silently clamps a delay past the 32-bit signed max to 1ms, which
+// would abort immediately — the opposite of what a large value asks for.
+const MAX_TIMEOUT_MS = 2 ** 31 - 1;
+const GRADLE_LOCK_TIMEOUT_MESSAGE = 'Timeout waiting to lock';
+// Gradle gives up on a contended lock (e.g. buildLogic.lock held by another
+// build in the same project) after ~60s, so at the 120s local default one wait
+// consumes the budget and the deadline guard below refuses a retry; retries
+// engage on CI (600s) or a raised NX_GRADLE_PROJECT_GRAPH_TIMEOUT. Do not relax
+// that `>=` to `>` — it refuses the borderline attempt rather than letting the
+// abort fire mid-retry and replace the lock message with a generic timeout.
+const MAX_LOCK_TIMEOUT_RETRIES = 2;
 let currentAbortController;
 /**
  * Cancel any in-flight Gradle project graph process.
@@ -23,35 +34,65 @@ function getGraphTimeoutMs() {
     if (envTimeout) {
         const parsed = Number(envTimeout);
         if (!Number.isNaN(parsed) && parsed > 0) {
-            return parsed * 1000;
+            return Math.min(parsed * 1000, MAX_TIMEOUT_MS);
         }
     }
     return DEFAULT_GRAPH_TIMEOUT_SECONDS * 1000;
 }
+function isGradleLockTimeout(e) {
+    return String(e).includes(GRADLE_LOCK_TIMEOUT_MESSAGE);
+}
+async function execGradleWithLockRetry(gradlewFile, args, signal, deadline) {
+    for (let attempt = 0;; attempt++) {
+        const attemptStart = Date.now();
+        try {
+            return await (0, exec_gradle_1.execGradleAsync)(gradlewFile, args, { signal });
+        }
+        catch (e) {
+            if (signal.aborted ||
+                attempt >= MAX_LOCK_TIMEOUT_RETRIES ||
+                !isGradleLockTimeout(e)) {
+                throw e;
+            }
+            // Retry only if another full lock wait still fits in the graph timeout.
+            // Otherwise the timeout aborts mid-attempt and its generic message
+            // replaces the lock guidance the user actually needs.
+            const lockWaitMs = Date.now() - attemptStart;
+            if (Date.now() + lockWaitMs >= deadline) {
+                throw e;
+            }
+            devkit_1.output.warn({
+                title: `Gradle lock is held by another build; retrying 'nxProjectGraph' (${attempt + 1}/${MAX_LOCK_TIMEOUT_RETRIES})`,
+            });
+        }
+    }
+}
 async function getNxProjectGraphLines(gradlewFile, gradleConfigHash, gradlePluginOptions) {
     let nxProjectGraphBuffer;
     const gradlePluginOptionsArgs = Object.entries(gradlePluginOptions ?? {})?.map(([key, value]) => `-P${key}=${value}`) ?? [];
     const timeoutMs = getGraphTimeoutMs();
     const timeoutSeconds = timeoutMs / 1000;
+    const deadline = Date.now() + timeoutMs;
     // Cancel any in-flight Gradle process from a previous call, then create a fresh controller.
     cancelPendingProjectGraphRequest();
     const controller = new AbortController();
     currentAbortController = controller;
     const signal = controller.signal;
     const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const args = [
+        'nxProjectGraph',
+        `-Phash=${gradleConfigHash}`,
+        '--no-configuration-cache', // disable configuration cache
+        '--parallel', // add parallel to improve performance
+        '--build-cache', // enable build cache
+        '--warning-mode',
+        'none',
+        ...gradlePluginOptionsArgs,
+        `-PworkspaceRoot=${devkit_1.workspaceRoot}`,
+        process.env.NX_GRADLE_VERBOSE_LOGGING ? '--info' : '',
+    ];
     try {
-        nxProjectGraphBuffer = await (0, exec_gradle_1.execGradleAsync)(gradlewFile, [
-            'nxProjectGraph',
-            `-Phash=${gradleConfigHash}`,
-            '--no-configuration-cache', // disable configuration cache
-            '--parallel', // add parallel to improve performance
-            '--build-cache', // enable build cache
-            '--warning-mode',
-            'none',
-            ...gradlePluginOptionsArgs,
-            `-PworkspaceRoot=${devkit_1.workspaceRoot}`,
-            process.env.NX_GRADLE_VERBOSE_LOGGING ? '--info' : '',
-        ], { signal });
+        nxProjectGraphBuffer = await execGradleWithLockRetry(gradlewFile, args, signal, deadline);
     }
     catch (e) {
         // Cancelled by a newer populateProjectGraph call — let the caller handle it
@@ -77,6 +118,15 @@ async function getNxProjectGraphLines(gradlewFile, gradleConfigHash, gradlePlugi
                 ],
             ], []);
         }
+        else if (isGradleLockTimeout(e)) {
+            throw new devkit_1.AggregateCreateNodesError([
+                [
+                    gradlewFile,
+                    new Error(`Could not run 'nxProjectGraph' Gradle task because another Gradle build is holding a lock on the project.\n` +
+                        `  Wait for the other build to finish, or run "gradlew --stop" to stop stale Gradle daemons, then try again.\n\r${e.toString()}`),
+                ],
+            ], []);
+        }
         else if (e.toString()?.includes(`Task 'nxProjectGraph' not found`)) {
             throw new devkit_1.AggregateCreateNodesError([
                 [

package/dist/src/plugin-v1/nodes.d.ts

@@ -1,5 +1,5 @@
+import { PluginCache } from '@nx/devkit/internal';
 import { CreateNodes, CreateNodesContext, ProjectConfiguration } from '@nx/devkit';
-import { PluginCache } from 'nx/src/utils/plugin-cache-utils';
 import { GradleReport } from './utils/get-gradle-report';
 export interface GradlePluginOptions {
     includeSubprojectsTasks?: boolean;

package/dist/src/plugin-v1/nodes.js

@@ -4,11 +4,7 @@ exports.createNodes = exports.makeCreateNodesForGradleConfigFile = exports.creat
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
-const plugin_cache_utils_1 = require("nx/src/utils/plugin-cache-utils");
-const devkit_internals_1 = require("nx/src/devkit-internals");
 const get_gradle_report_1 = require("./utils/get-gradle-report");
-const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const split_config_files_1 = require("../utils/split-config-files");
 const exec_gradle_1 = require("../utils/exec-gradle");
 const cacheableTaskType = new Set(['Build', 'Verification']);
@@ -33,9 +29,9 @@ exports.createNodesV2 = [
     split_config_files_1.gradleConfigAndTestGlob,
     async (files, options, context) => {
         const { buildFiles, projectRoots, gradlewFiles, testFiles } = (0, split_config_files_1.splitConfigFiles)(files);
-        const optionsHash = (0, file_hasher_1.hashObject)(options);
-        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `gradle-${optionsHash}.hash`);
-        const pluginCache = new plugin_cache_utils_1.PluginCache(cachePath);
+        const optionsHash = (0, internal_1.hashObject)(options);
+        const cachePath = (0, node_path_1.join)(internal_1.workspaceDataDirectory, `gradle-${optionsHash}.hash`);
+        const pluginCache = new internal_1.PluginCache(cachePath);
         await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot, gradlewFiles.map((f) => (0, node_path_1.join)(context.workspaceRoot, f)));
         const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
         const gradleProjectRootToTestFilesMap = getGradleProjectRootToTestFilesMap(testFiles, projectRoots);
@@ -257,7 +253,7 @@ function getGradleProjectRootToTestFilesMap(testFiles, projectRoots) {
     const roots = new Map(projectRoots.map((root) => [root, root]));
     const testFilesToGradleProjectMap = {};
     testFiles.forEach((testFile) => {
-        const projectRoot = (0, devkit_internals_1.findProjectForPath)(testFile, roots);
+        const projectRoot = (0, internal_1.findProjectForPath)(testFile, roots);
         if (projectRoot) {
             if (!testFilesToGradleProjectMap[projectRoot]) {
                 testFilesToGradleProjectMap[projectRoot] = [];

package/dist/src/plugin-v1/utils/get-gradle-report.js

@@ -8,12 +8,11 @@ exports.processGradleDependencies = processGradleDependencies;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const devkit_1 = require("@nx/devkit");
-const workspace_context_1 = require("nx/src/utils/workspace-context");
 const path_1 = require("path");
 const split_config_files_1 = require("../../utils/split-config-files");
 const get_project_report_lines_1 = require("./get-project-report-lines");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
 const exec_gradle_1 = require("../../utils/exec-gradle");
+const internal_1 = require("@nx/devkit/internal");
 function readGradleReportCache(cachePath, hash) {
     const gradleReportJson = (0, node_fs_1.existsSync)(cachePath)
         ? (0, devkit_1.readJsonFile)(cachePath)
@@ -65,7 +64,7 @@ function writeGradleReportToCache(cachePath, results, hash) {
     }
 }
 let gradleReportCache;
-let gradleReportCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'gradle-report-v1.hash');
+let gradleReportCachePath = (0, node_path_1.join)(internal_1.workspaceDataDirectory, 'gradle-report-v1.hash');
 function getCurrentGradleReport() {
     if (!gradleReportCache) {
         throw new devkit_1.AggregateCreateNodesError([
@@ -88,7 +87,7 @@ function getCurrentGradleReport() {
  * @returns Promise<void>
  */
 async function populateGradleReport(workspaceRoot, gradlewFiles) {
-    const gradleConfigHash = await (0, workspace_context_1.hashWithWorkspaceContext)(workspaceRoot, [
+    const gradleConfigHash = await (0, internal_1.hashWithWorkspaceContext)(workspaceRoot, [
         split_config_files_1.gradleConfigAndTestGlob,
     ]);
     const cached = readGradleReportCache(gradleReportCachePath, gradleConfigHash);

package/dist/src/utils/exec-gradle.d.ts

@@ -1,5 +1,5 @@
 import { NxJsonConfiguration } from '@nx/devkit';
-import { ExecFileOptions } from 'node:child_process';
+import { SpawnOptions } from 'node:child_process';
 export declare const fileSeparator: string;
 export declare const newLineSeparator: string;
 /**
@@ -14,7 +14,7 @@ export declare function getGradleExecFile(): string;
  * @param execOptions exec options
  * @returns promise with the stdout buffer
  */
-export declare function execGradleAsync(gradleBinaryPath: string, args: ReadonlyArray<string>, execOptions?: ExecFileOptions): Promise<Buffer>;
+export declare function execGradleAsync(gradleBinaryPath: string, args: ReadonlyArray<string>, execOptions?: Omit<SpawnOptions, 'shell'>): Promise<Buffer>;
 export declare function getCustomGradleExecutableDirectoryFromPlugin(nxJson: NxJsonConfiguration): string | undefined;
 /**
  * This function recursively finds the nearest gradlew file in the workspace

package/dist/src/utils/exec-gradle.js

@@ -7,14 +7,10 @@ exports.getCustomGradleExecutableDirectoryFromPlugin = getCustomGradleExecutable
 exports.findGradlewFile = findGradlewFile;
 exports.findGradlewUsingFilePathTraversal = findGradlewUsingFilePathTraversal;
 exports.findGradlewUsingCustomExecutableDirectory = findGradlewUsingCustomExecutableDirectory;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
-const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const run_commands_impl_1 = require("nx/src/executors/run-commands/run-commands.impl");
-const exit_codes_1 = require("nx/src/utils/exit-codes");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const internal_1 = require("@nx/devkit/internal");
 exports.fileSeparator = process.platform.startsWith('win')
     ? 'file:///'
     : 'file://';
@@ -36,37 +32,45 @@ function getGradleExecFile() {
  * @returns promise with the stdout buffer
  */
 function execGradleAsync(gradleBinaryPath, args, execOptions = {}) {
-    // Extract signal so we can handle cancellation with tree-kill
+    // Extract signal so we can handle cancellation with a process-tree kill
     // instead of Node's default which only kills the immediate child.
     const { signal, ...restOptions } = execOptions;
     return new Promise((res, rej) => {
-        const cp = (0, node_child_process_1.execFile)(gradleBinaryPath, args, {
+        // Without the filter, empty args reach gradle as literal empty arguments.
+        const cp = (0, internal_1.safeSpawn)(gradleBinaryPath, args.filter(Boolean), {
             cwd: (0, node_path_1.dirname)(gradleBinaryPath),
-            shell: true,
-            windowsHide: true,
             env: process.env,
-            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
             ...restOptions,
-        }, undefined);
-        // Use tree-kill on abort to kill the entire process tree
-        // (cmd.exe → gradlew.bat → java.exe), not just the shell.
+        });
+        // A plugin worker torn down by `nx reset` would otherwise orphan the build.
+        (0, internal_1.killChildOnHostExit)(cp);
+        let stdout = Buffer.from('');
+        // On abort, kill the entire process tree (gradlew spawns java) and settle
+        // immediately — a wedged JVM that outlives the kill signal would otherwise
+        // keep this promise pending and the abort error would never surface.
         const onAbort = () => {
             if (cp.pid) {
-                (0, tree_kill_1.default)(cp.pid);
+                (0, internal_1.killProcessTreeGraceful)(cp.pid).catch(() => { });
             }
+            rej(stdout);
         };
         signal?.addEventListener('abort', onAbort, { once: true });
-        let stdout = Buffer.from('');
         cp.stdout?.on('data', (data) => {
             stdout += data;
         });
         cp.stderr?.on('data', (data) => {
             stdout += data;
         });
+        // Without a shell the child is gradlew itself, so spawn can fail outright —
+        // Node then emits `error` and never `exit`.
+        cp.on('error', (err) => {
+            signal?.removeEventListener('abort', onAbort);
+            rej(err);
+        });
         cp.on('exit', (code, s) => {
             signal?.removeEventListener('abort', onAbort);
             if (code === null)
-                code = (0, exit_codes_1.signalToCode)(s);
+                code = (0, internal_1.signalToCode)(s);
             if (code === 0) {
                 res(stdout);
             }

package/dist/src/utils/split-config-files.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gradleConfigAndTestGlob = exports.gradleConfigGlob = exports.GRADLE_TEST_FILES = exports.GRADLE_VERSION_CATALOG_GLOB = exports.GRADLEW_FILES = exports.GRADLE_BUILD_FILES = void 0;
 exports.splitConfigFiles = splitConfigFiles;
-const globs_1 = require("nx/src/utils/globs");
 const node_path_1 = require("node:path");
+const internal_1 = require("@nx/devkit/internal");
 exports.GRADLE_BUILD_FILES = new Set(['build.gradle', 'build.gradle.kts']);
 exports.GRADLEW_FILES = new Set(['gradlew', 'gradlew.bat']);
 exports.GRADLE_VERSION_CATALOG_GLOB = '**/gradle/*.versions.toml';
@@ -15,7 +15,7 @@ exports.GRADLE_TEST_FILES = [
     '**/src/test/groovy/**/*Test.groovy',
     '**/src/test/groovy/**/*Tests.groovy',
 ];
-exports.gradleConfigGlob = (0, globs_1.combineGlobPatterns)(...Array.from(exports.GRADLE_BUILD_FILES).map((file) => `**/${file}`));
+exports.gradleConfigGlob = (0, internal_1.combineGlobPatterns)(...Array.from(exports.GRADLE_BUILD_FILES).map((file) => `**/${file}`));
 // Files that influence Gradle's configuration phase and therefore the project
 // graph report: any *.gradle(.kts) script (build, settings, script plugins),
 // gradle.properties, the wrapper pin, and buildSrc build logic.
@@ -28,7 +28,7 @@ const GRADLE_CONFIG_FILE_PATTERNS = [
     'buildSrc/**/*.java',
     'buildSrc/**/*.groovy',
 ];
-exports.gradleConfigAndTestGlob = (0, globs_1.combineGlobPatterns)(...GRADLE_CONFIG_FILE_PATTERNS, ...GRADLE_CONFIG_FILE_PATTERNS.map((pattern) => `**/${pattern}`), ...Array.from(exports.GRADLEW_FILES), ...Array.from(exports.GRADLEW_FILES).map((file) => `**/${file}`), ...exports.GRADLE_TEST_FILES, exports.GRADLE_VERSION_CATALOG_GLOB);
+exports.gradleConfigAndTestGlob = (0, internal_1.combineGlobPatterns)(...GRADLE_CONFIG_FILE_PATTERNS, ...GRADLE_CONFIG_FILE_PATTERNS.map((pattern) => `**/${pattern}`), ...Array.from(exports.GRADLEW_FILES), ...Array.from(exports.GRADLEW_FILES).map((file) => `**/${file}`), ...exports.GRADLE_TEST_FILES, exports.GRADLE_VERSION_CATALOG_GLOB);
 /**
  * This function split config files into build files, settings files, test files and project roots
  * @param files list of files to split

package/dist/src/utils/versions.d.ts

@@ -1,3 +1,3 @@
 export declare const nxVersion: any;
 export declare const gradleProjectGraphPluginName = "dev.nx.gradle.project-graph";
-export declare const gradleProjectGraphVersion = "0.1.24";
+export declare const gradleProjectGraphVersion = "0.1.25";

package/dist/src/utils/versions.js

@@ -4,4 +4,4 @@ exports.gradleProjectGraphVersion = exports.gradleProjectGraphPluginName = expor
 const path_1 = require("path");
 exports.nxVersion = require((0, path_1.join)('@nx/gradle', 'package.json')).version;
 exports.gradleProjectGraphPluginName = 'dev.nx.gradle.project-graph';
-exports.gradleProjectGraphVersion = '0.1.24';
+exports.gradleProjectGraphVersion = '0.1.25';

package/migrations.json

@@ -180,6 +180,12 @@
       "description": "Change dev.nx.gradle.project-graph to version 0.1.24 in build file",
       "factory": "./dist/src/migrations/23-1-0/change-plugin-version-0-1-24",
       "documentation": "./dist/src/migrations/23-1-0/change-plugin-version-0-1-24.md"
+    },
+    "change-plugin-version-0-1-25": {
+      "version": "23.2.0-beta.11",
+      "description": "Change dev.nx.gradle.project-graph to version 0.1.25 in build file",
+      "implementation": "./dist/src/migrations/23-2-0/change-plugin-version-0-1-25",
+      "documentation": "./dist/src/migrations/23-2-0/change-plugin-version-0-1-25.md"
     }
   },
   "packageJsonUpdates": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "23.2.0-beta.1",
+  "version": "23.2.0-beta.11",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -76,12 +76,11 @@
   },
   "dependencies": {
     "toml-eslint-parser": "^0.10.0",
-    "tree-kill": "^1.2.2",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-beta.1"
+    "@nx/devkit": "23.2.0-beta.11"
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.1"
+    "nx": "23.2.0-beta.11"
   },
   "publishConfig": {
     "access": "public"