@nx/gradle 23.2.0-beta.10 → 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/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

@@ -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

@@ -67,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, internal_1.hashObject)(options);
-        const cachePath = (0, node_path_1.join)(internal_1.workspaceDataDirectory, `gradle-${optionsHash}.hash`);
-        const pluginCache = new internal_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

@@ -118,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')) {
@@ -149,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

@@ -7,6 +7,17 @@ const devkit_1 = require("@nx/devkit");
 const exec_gradle_1 = require("../../utils/exec-gradle");
 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/utils/exec-gradle.js

@@ -42,6 +42,8 @@ function execGradleAsync(gradleBinaryPath, args, execOptions = {}) {
             env: process.env,
             ...restOptions,
         });
+        // 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

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.10",
+  "version": "23.2.0-beta.11",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -77,10 +77,10 @@
   "dependencies": {
     "toml-eslint-parser": "^0.10.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-beta.10"
+    "@nx/devkit": "23.2.0-beta.11"
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.10"
+    "nx": "23.2.0-beta.11"
   },
   "publishConfig": {
     "access": "public"