@nx/gradle 21.1.2 → 21.2.0-beta.2

package/README.md

@@ -1,7 +1,7 @@
 <p style="text-align: center;">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
-    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
   </picture>
 </p>
 
@@ -22,9 +22,9 @@
 
 > Note: this plugin is currently experimental.
 
-# Nx: Smart Monorepos · Fast CI
+# Nx: Smart Repos · Fast Builds
 
-Nx is a build system, optimized for monorepos, with plugins for popular frameworks and tools and advanced CI capabilities including caching and distribution.
+An AI-first build platform that connects everything from your editor to CI. Helping you deliver fast, without breaking things.
 
 This package is a [Gradle plugin for Nx](https://nx.dev/gradle/overview).
 
@@ -66,5 +66,5 @@ npx nx@latest init
 - [Blog Posts About Nx](https://nx.dev/blog)
 
 <p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
 

package/migrations.json

@@ -29,6 +29,12 @@
       "cli": "nx",
       "description": "Change @nx/gradle option from ciTargetName to ciTestTargetName",
       "factory": "./src/migrations/21-0-0/change-ciTargetName-to-ciTestTargetName"
+    },
+    "change-plugin-version-0-1-0": {
+      "version": "21.1.2-beta.1",
+      "cli": "nx",
+      "description": "Change dev.nx.gradle.project-graph to version 0.1.0 in build file",
+      "factory": "./src/migrations/21-1-2/change-plugin-version-0-1-0"
     }
   },
   "packageJsonUpdates": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "21.1.2",
+  "version": "21.2.0-beta.2",
   "private": false,
   "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
   "repository": {
@@ -35,7 +35,7 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "21.1.2"
+    "@nx/devkit": "21.2.0-beta.2"
   },
   "publishConfig": {
     "access": "public"

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

@@ -0,0 +1,14 @@
+import { ProjectGraph } from 'nx/src/config/project-graph';
+/**
+ * Returns Gradle CLI arguments to exclude dependent tasks
+ * that are not part of the current execution set.
+ *
+ * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
+ * and only `test` is running, this will return: ['lint']
+ */
+export declare function getExcludeTasks(projectGraph: ProjectGraph, targets: {
+    project: string;
+    target: string;
+    excludeDependsOn: boolean;
+}[], runningTaskIds?: Set<string>): Set<string>;
+export declare function getAllDependsOn(projectGraph: ProjectGraph, projectName: string, targetName: string, visited?: Set<string>): string[];

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExcludeTasks = getExcludeTasks;
+exports.getAllDependsOn = getAllDependsOn;
+/**
+ * Returns Gradle CLI arguments to exclude dependent tasks
+ * that are not part of the current execution set.
+ *
+ * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
+ * and only `test` is running, this will return: ['lint']
+ */
+function getExcludeTasks(projectGraph, targets, runningTaskIds = new Set()) {
+    const excludes = new Set();
+    for (const { project, target, excludeDependsOn } of targets) {
+        if (!excludeDependsOn) {
+            continue;
+        }
+        const taskDeps = projectGraph.nodes[project]?.data?.targets?.[target]?.dependsOn ?? [];
+        for (const dep of taskDeps) {
+            const taskId = typeof dep === 'string' ? dep : dep?.target;
+            if (taskId && !runningTaskIds.has(taskId)) {
+                const [projectName, targetName] = taskId.split(':');
+                const taskName = projectGraph.nodes[projectName]?.data?.targets?.[targetName]?.options
+                    ?.taskName;
+                if (taskName) {
+                    excludes.add(taskName);
+                }
+            }
+        }
+    }
+    return excludes;
+}
+function getAllDependsOn(projectGraph, projectName, targetName, visited = new Set()) {
+    const dependsOn = projectGraph[projectName]?.data?.targets?.[targetName]?.dependsOn ?? [];
+    const allDependsOn = [];
+    for (const dependency of dependsOn) {
+        if (!visited.has(dependency)) {
+            visited.add(dependency);
+            const [depProjectName, depTargetName] = dependency.split(':');
+            allDependsOn.push(dependency);
+            // Recursively get dependencies of the current dependency
+            allDependsOn.push(...getAllDependsOn(projectGraph, depProjectName, depTargetName, visited));
+        }
+    }
+    return allDependsOn;
+}

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

@@ -1,6 +1,6 @@
 import { ExecutorContext, TaskGraph } from '@nx/devkit';
 import { RunCommandsOptions } from 'nx/src/executors/run-commands/run-commands.impl';
 import { BatchResults } from 'nx/src/tasks-runner/batch/batch-messages';
-import { gradleExecutorSchema } from './schema';
+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>;
+export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): Promise<BatchResults>;

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

@@ -8,13 +8,15 @@ const exec_gradle_1 = require("../../utils/exec-gradle");
 const path_1 = require("path");
 const child_process_1 = require("child_process");
 const pseudo_terminal_1 = require("nx/src/tasks-runner/pseudo-terminal");
+const get_exclude_task_1 = require("./get-exclude-task");
 exports.batchRunnerPath = (0, path_1.join)(__dirname, '../../../batch-runner/build/libs/batch-runner-all.jar');
 async function gradleBatch(taskGraph, inputs, overrides, context) {
     try {
         const projectName = taskGraph.tasks[taskGraph.roots[0]]?.target?.project;
         let projectRoot = context.projectGraph.nodes[projectName]?.data?.root ?? '';
-        const gradlewPath = (0, exec_gradle_1.findGradlewFile)((0, path_1.join)(projectRoot, 'project.json')); // find gradlew near project root
-        const root = (0, path_1.join)(context.root, (0, path_1.dirname)(gradlewPath));
+        let gradlewPath = (0, exec_gradle_1.findGradlewFile)((0, path_1.join)(projectRoot, 'project.json')); // find gradlew near project root
+        gradlewPath = (0, path_1.join)(context.root, gradlewPath);
+        const root = (0, path_1.dirname)(gradlewPath);
         // set args with passed in args and overrides in command line
         const input = inputs[taskGraph.roots[0]];
         let args = typeof input.args === 'string'
@@ -25,7 +27,25 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
         if (overrides.__overrides_unparsed__.length) {
             args.push(...overrides.__overrides_unparsed__);
         }
-        const gradlewTasksToRun = Object.entries(taskGraph.tasks).reduce((gradlewTasksToRun, [taskId, task]) => {
+        const taskIdsWithExclude = [];
+        const taskIdsWithoutExclude = [];
+        const taskIds = Object.keys(taskGraph.tasks);
+        for (const taskId of taskIds) {
+            if (inputs[taskId].excludeDependsOn) {
+                taskIdsWithExclude.push(taskId);
+            }
+            else {
+                taskIdsWithoutExclude.push(taskId);
+            }
+        }
+        const allDependsOn = new Set(taskIds);
+        taskIdsWithoutExclude.forEach((taskId) => {
+            const [projectName, targetName] = taskId.split(':');
+            const dependencies = (0, get_exclude_task_1.getAllDependsOn)(context.projectGraph, projectName, targetName);
+            dependencies.forEach((dep) => allDependsOn.add(dep));
+        });
+        const gradlewTasksToRun = taskIds.reduce((gradlewTasksToRun, taskId) => {
+            const task = taskGraph.tasks[taskId];
             const gradlewTaskName = inputs[task.id].taskName;
             const testClassName = inputs[task.id].testClassName;
             gradlewTasksToRun[taskId] = {
@@ -34,48 +54,24 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
             };
             return gradlewTasksToRun;
         }, {});
-        const gradlewBatchStart = performance.mark(`gradlew-batch:start`);
-        const usePseudoTerminal = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-            pseudo_terminal_1.PseudoTerminal.isSupported();
-        const command = `java -jar ${exports.batchRunnerPath} --tasks='${JSON.stringify(gradlewTasksToRun)}' --workspaceRoot=${root} --args='${args
-            .join(' ')
-            .replaceAll("'", '"')}' ${process.env.NX_VERBOSE_LOGGING === 'true' ? '' : '--quiet'}`;
-        let batchResults;
-        if (usePseudoTerminal) {
-            const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
-            await terminal.init();
-            const cp = terminal.runCommand(command, {
-                cwd: devkit_1.workspaceRoot,
-                jsEnv: process.env,
-                quiet: process.env.NX_VERBOSE_LOGGING !== 'true',
-            });
-            const results = await cp.getResults();
-            batchResults = results.terminalOutput;
-            batchResults = batchResults.replace(command, '');
-            const startIndex = batchResults.indexOf('{');
-            const endIndex = batchResults.lastIndexOf('}');
-            batchResults = batchResults.substring(startIndex, endIndex + 1);
-        }
-        else {
-            batchResults = (0, child_process_1.execSync)(command, {
-                cwd: devkit_1.workspaceRoot,
-                windowsHide: true,
-                env: process.env,
-                maxBuffer: run_commands_impl_1.LARGE_BUFFER,
-            }).toString();
-        }
-        const gradlewBatchEnd = performance.mark(`gradlew-batch:end`);
-        performance.measure(`gradlew-batch`, gradlewBatchStart.name, gradlewBatchEnd.name);
-        const gradlewBatchResults = JSON.parse(batchResults.toString());
-        Object.keys(taskGraph.tasks).forEach((taskId) => {
-            if (!gradlewBatchResults[taskId]) {
-                gradlewBatchResults[taskId] = {
+        const excludeTasks = (0, get_exclude_task_1.getExcludeTasks)(context.projectGraph, taskIdsWithExclude.map((taskId) => {
+            const task = taskGraph.tasks[taskId];
+            return {
+                project: task?.target?.project,
+                target: task?.target?.target,
+                excludeDependsOn: inputs[taskId]?.excludeDependsOn,
+            };
+        }), allDependsOn);
+        const batchResults = await runTasksInBatch(gradlewTasksToRun, excludeTasks, args, root);
+        taskIds.forEach((taskId) => {
+            if (!batchResults[taskId]) {
+                batchResults[taskId] = {
                     success: false,
                     terminalOutput: `Gradlew batch failed`,
                 };
             }
         });
-        return gradlewBatchResults;
+        return batchResults;
     }
     catch (e) {
         devkit_1.output.error({
@@ -88,3 +84,41 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
         }, {});
     }
 }
+async function runTasksInBatch(gradlewTasksToRun, excludeTasks, args, root) {
+    const gradlewBatchStart = performance.mark(`gradlew-batch:start`);
+    const usePseudoTerminal = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+        pseudo_terminal_1.PseudoTerminal.isSupported();
+    const command = `java -jar ${exports.batchRunnerPath} --tasks='${JSON.stringify(gradlewTasksToRun)}' --workspaceRoot=${root} --args='${args
+        .join(' ')
+        .replaceAll("'", '"')}' --excludeTasks='${Array.from(excludeTasks).join(',')}' ${process.env.NX_VERBOSE_LOGGING === 'true' ? '' : '--quiet'}`;
+    let batchResults;
+    if (usePseudoTerminal && process.env.NX_VERBOSE_LOGGING !== 'true') {
+        const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+        await terminal.init();
+        const cp = terminal.runCommand(command, {
+            cwd: devkit_1.workspaceRoot,
+            jsEnv: process.env,
+            quiet: true,
+        });
+        const results = await cp.getResults();
+        terminal.shutdown(0);
+        batchResults = results.terminalOutput;
+        batchResults = batchResults.replace(command, '');
+        const startIndex = batchResults.indexOf('{');
+        const endIndex = batchResults.lastIndexOf('}');
+        // only keep the json part
+        batchResults = batchResults.substring(startIndex, endIndex + 1);
+    }
+    else {
+        batchResults = (0, child_process_1.execSync)(command, {
+            cwd: devkit_1.workspaceRoot,
+            windowsHide: true,
+            env: process.env,
+            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+        }).toString();
+    }
+    const gradlewBatchEnd = performance.mark(`gradlew-batch:end`);
+    performance.measure(`gradlew-batch`, gradlewBatchStart.name, gradlewBatchEnd.name);
+    const gradlewBatchResults = JSON.parse(batchResults);
+    return gradlewBatchResults;
+}

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

@@ -1,5 +1,5 @@
 import { ExecutorContext } from '@nx/devkit';
-import { gradleExecutorSchema } from './schema';
-export default function gradleExecutor(options: gradleExecutorSchema, context: ExecutorContext): Promise<{
+import { GradleExecutorSchema } from './schema';
+export default function gradleExecutor(options: GradleExecutorSchema, context: ExecutorContext): Promise<{
     success: boolean;
 }>;

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

@@ -4,6 +4,7 @@ exports.default = gradleExecutor;
 const exec_gradle_1 = require("../../utils/exec-gradle");
 const node_path_1 = require("node:path");
 const run_commands_impl_1 = require("nx/src/executors/run-commands/run-commands.impl");
+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;
     let gradlewPath = (0, exec_gradle_1.findGradlewFile)((0, node_path_1.join)(projectRoot, 'project.json')); // find gradlew near project root
@@ -16,6 +17,17 @@ async function gradleExecutor(options, context) {
     if (options.testClassName) {
         args.push(`--tests`, options.testClassName);
     }
+    (0, get_exclude_task_1.getExcludeTasks)(context.projectGraph, [
+        {
+            project: context.projectName,
+            target: context.targetName,
+            excludeDependsOn: options.excludeDependsOn,
+        },
+    ]).forEach((task) => {
+        if (task) {
+            args.push('--exclude-task', task);
+        }
+    });
     try {
         const { success } = await (0, run_commands_impl_1.default)({
             command: `${gradlewPath} ${options.taskName}`,

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

@@ -1,5 +1,6 @@
-export interface gradleExecutorSchema {
+export interface GradleExecutorSchema {
   taskName: string;
   testClassName?: string;
   args?: string[] | string;
+  excludeDependsOn: boolean;
 }

package/src/executors/gradle/schema.json

@@ -27,6 +27,12 @@
       ],
       "description": "The arguments to pass to the Gradle task.",
       "examples": [["--warning-mode", "all"], "--stracktrace"]
+    },
+    "excludeDependsOn": {
+      "type": "boolean",
+      "description": "If true, the tasks will not execute its dependsOn tasks (e.g. pass --exclude-task args to gradle command). If false, the task will execute its dependsOn tasks.",
+      "default": true,
+      "x-priority": "internal"
     }
   },
   "required": ["taskName"]

package/src/generators/init/gradle-project-graph-plugin-utils.d.ts

@@ -0,0 +1,21 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Adds a `build.gradle(.kts)` file next to each `settings.gradle(.kts)` file found in the workspace.
+ * If the build.gradle file already exists, it reads its contents.
+ */
+export declare function addBuildGradleFileNextToSettingsGradle(tree: Tree): Promise<{
+    filePath: string;
+    content: string;
+}[]>;
+/**
+ * Extract gradle plugin version from build.gradle file
+ */
+export declare function extractNxPluginVersion(gradleFilePath: string, gradleContent: string): Promise<string | null>;
+/**
+ * Updates the plugin version in the given Gradle file content.
+ */
+export declare function updateNxPluginVersion(content: string, newVersion: string): string;
+/**
+ * Ensures all build.gradle(.kts) files use the expected version of dev.nx.gradle.project-graph.
+ */
+export declare function addNxProjectGraphPlugin(tree: Tree, expectedVersion?: string): Promise<void>;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildGradleFileNextToSettingsGradle = addBuildGradleFileNextToSettingsGradle;
+exports.extractNxPluginVersion = extractNxPluginVersion;
+exports.updateNxPluginVersion = updateNxPluginVersion;
+exports.addNxProjectGraphPlugin = addNxProjectGraphPlugin;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+const exec_gradle_1 = require("../../utils/exec-gradle");
+/**
+ * Adds a `build.gradle(.kts)` file next to each `settings.gradle(.kts)` file found in the workspace.
+ * If the build.gradle file already exists, it reads its contents.
+ */
+async function addBuildGradleFileNextToSettingsGradle(tree) {
+    const settingsGradleFiles = await (0, devkit_1.globAsync)(tree, [
+        '**/settings.gradle',
+        '**/settings.gradle.kts',
+    ]);
+    return settingsGradleFiles.map((settingsGradlePath) => {
+        return ensureBuildGradleFile(tree, settingsGradlePath);
+    });
+}
+/**
+ * Determines the appropriate build.gradle file path based on the settings file
+ * and ensures it exists in the tree. Returns the path and contents.
+ */
+function ensureBuildGradleFile(tree, settingsGradlePath) {
+    const isKotlinDsl = settingsGradlePath.endsWith('.kts');
+    const buildGradleFile = (0, path_1.join)((0, path_1.dirname)(settingsGradlePath), isKotlinDsl ? 'build.gradle.kts' : 'build.gradle');
+    let content = '';
+    if (tree.exists(buildGradleFile)) {
+        content = tree.read(buildGradleFile, 'utf-8');
+    }
+    else {
+        tree.write(buildGradleFile, content);
+    }
+    return { filePath: buildGradleFile, content };
+}
+// a regex to get the version in build file in format `id "dev.nx.gradle.project-graph" version "x"`
+const regex = /(id\s*\(?["']dev\.nx\.gradle\.project-graph["']\)?\s*version\s*\(?["'])([^"']+)(["']\)?)/;
+/**
+ * Extract gradle plugin version from build.gradle file
+ */
+async function extractNxPluginVersion(gradleFilePath, gradleContent) {
+    const match = gradleContent.match(regex);
+    let version = match ? match[2] : null;
+    if (!version) {
+        try {
+            const gradlewFile = (0, exec_gradle_1.findGradlewFile)(gradleFilePath, devkit_1.workspaceRoot);
+            const buildEnvironment = (await (0, exec_gradle_1.execGradleAsync)((0, path_1.join)(devkit_1.workspaceRoot, gradlewFile), [
+                'buildEnvironment',
+                '--quiet',
+            ])).toString();
+            version = getPluginVersion(buildEnvironment);
+        }
+        catch (e) { } // Silently ignore error, fallback remains null
+    }
+    return version;
+}
+function getPluginVersion(dependencyTree) {
+    const lines = dependencyTree.split('\n');
+    for (const line of lines) {
+        // line is dev.nx.gradle.project-graph:dev.nx.gradle.project-graph.gradle.plugin:version
+        const match = line.match(/dev\.nx\.gradle\.project-graph:dev\.nx\.gradle\.project-graph\.gradle\.plugin:([^\s\\]+)/);
+        if (match) {
+            return match[1]; // returns the version part
+        }
+    }
+    return null; // not found
+}
+/**
+ * Updates the plugin version in the given Gradle file content.
+ */
+function updateNxPluginVersion(content, newVersion) {
+    if (regex.test(content)) {
+        return content.replace(regex, `$1${newVersion}$3`);
+    }
+    else {
+        devkit_1.logger.warn(`Please update plugin dev.nx.gradle.project-graph to ${newVersion}`);
+    }
+    return content;
+}
+/**
+ * Ensures all build.gradle(.kts) files use the expected version of dev.nx.gradle.project-graph.
+ */
+async function addNxProjectGraphPlugin(tree, expectedVersion = versions_1.gradleProjectGraphVersion) {
+    const files = await addBuildGradleFileNextToSettingsGradle(tree);
+    files.forEach(({ filePath, content }) => {
+        addNxProjectGraphPluginToBuildGradle(filePath, content, expectedVersion, tree);
+    });
+}
+/**
+ * Adds or updates the Nx Project Graph plugin in the build.gradle(.kts) file.
+ * Ensures the correct version and applies the plugin to all projects.
+ * Returns the updated build.gradle content.
+ */
+async function addNxProjectGraphPluginToBuildGradle(gradleFilePath, buildGradleContent, expectedVersion = versions_1.gradleProjectGraphVersion, tree) {
+    const isKotlinDsl = gradleFilePath.endsWith('.kts');
+    const nxProjectGraphReportPlugin = isKotlinDsl
+        ? `id(\"${versions_1.gradleProjectGraphPluginName}\") version(\"${expectedVersion}\")`
+        : `id \"${versions_1.gradleProjectGraphPluginName}\" version \"${expectedVersion}\"`;
+    // Helper to add plugin to plugins block
+    function addPluginToPluginsBlock(content) {
+        return content.replace(/plugins\s*\{/, `plugins {\n    ${nxProjectGraphReportPlugin}`);
+    }
+    // Helper to add plugins block if missing
+    function addPluginsBlock(content) {
+        return `plugins {\n    ${nxProjectGraphReportPlugin}\n}\n${content}`;
+    }
+    // Helper to add plugin application to allprojects
+    function addPluginToAllProjects(content) {
+        const applyPlugin = isKotlinDsl
+            ? `plugin(\"${versions_1.gradleProjectGraphPluginName}\")`
+            : `plugin(\"${versions_1.gradleProjectGraphPluginName}\")`;
+        return `${content}\nallprojects {\n    apply {\n        ${applyPlugin}\n    }\n}`;
+    }
+    // 1. Ensure plugins block and correct plugin version
+    if (buildGradleContent.includes('plugins {')) {
+        if (buildGradleContent.includes(versions_1.gradleProjectGraphPluginName)) {
+            // Update version if needed
+            const currentVersion = await extractNxPluginVersion(gradleFilePath, buildGradleContent);
+            if (currentVersion && currentVersion !== expectedVersion) {
+                buildGradleContent = updateNxPluginVersion(buildGradleContent, expectedVersion);
+            }
+        }
+        else {
+            // Add plugin to plugins block
+            buildGradleContent = addPluginToPluginsBlock(buildGradleContent);
+        }
+    }
+    else {
+        // Add plugins block if missing
+        buildGradleContent = addPluginsBlock(buildGradleContent);
+    }
+    // 2. Ensure plugin is applied to all projects
+    const applyPluginPattern = new RegExp(`\\s*plugin\\(["']${versions_1.gradleProjectGraphPluginName}["']\\)`);
+    if (buildGradleContent.includes('allprojects {')) {
+        if (!applyPluginPattern.test(buildGradleContent)) {
+            devkit_1.logger.warn(`Please add the ${versions_1.gradleProjectGraphPluginName} plugin to your ${gradleFilePath}:\nallprojects {\n  apply {\n      plugin(\"${versions_1.gradleProjectGraphPluginName}\")\n  }\n}`);
+        }
+    }
+    else {
+        buildGradleContent = addPluginToAllProjects(buildGradleContent);
+    }
+    // 3. Write and return updated content
+    tree.write(gradleFilePath, buildGradleContent);
+    return buildGradleContent;
+}

package/src/generators/init/init.d.ts

@@ -1,9 +1,5 @@
 import { GeneratorCallback, Tree } from '@nx/devkit';
 import { InitGeneratorSchema } from './schema';
 export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
-/**
- * This function creates and populate build.gradle file next to the settings.gradle file.
- */
-export declare function addBuildGradleFileNextToSettingsGradle(tree: Tree): Promise<void>;
 export declare function updateNxJsonConfiguration(tree: Tree): void;
 export default initGenerator;

package/src/generators/init/init.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initGenerator = initGenerator;
-exports.addBuildGradleFileNextToSettingsGradle = addBuildGradleFileNextToSettingsGradle;
 exports.updateNxJsonConfiguration = updateNxJsonConfiguration;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../utils/versions");
 const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
-const path_1 = require("path");
+const gradle_project_graph_plugin_utils_1 = require("./gradle-project-graph-plugin-utils");
 async function initGenerator(tree, options) {
     const tasks = [];
     if (!options.skipPackageJson && tree.exists('package.json')) {
@@ -14,7 +13,7 @@ async function initGenerator(tree, options) {
             '@nx/gradle': versions_1.nxVersion,
         }, undefined, options.keepExistingVersions));
     }
-    await addBuildGradleFileNextToSettingsGradle(tree);
+    await (0, gradle_project_graph_plugin_utils_1.addNxProjectGraphPlugin)(tree);
     addPlugin(tree);
     updateNxJsonConfiguration(tree);
     if (!options.skipFormat) {
@@ -37,70 +36,6 @@ function addPlugin(tree) {
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
 }
-/**
- * This function creates and populate build.gradle file next to the settings.gradle file.
- */
-async function addBuildGradleFileNextToSettingsGradle(tree) {
-    const settingsGradleFiles = await (0, devkit_1.globAsync)(tree, [
-        '**/settings.gradle?(.kts)',
-    ]);
-    settingsGradleFiles.forEach((settingsGradleFile) => {
-        addNxProjectGraphPluginToBuildGradle(settingsGradleFile, tree);
-    });
-}
-/**
- * - creates a build.gradle file next to the settings.gradle file if it does not exist.
- * - adds the NxProjectGraphPlugin plugin to the build.gradle file if it does not exist.
- */
-function addNxProjectGraphPluginToBuildGradle(settingsGradleFile, tree) {
-    const filename = (0, path_1.basename)(settingsGradleFile);
-    let gradleFilePath = 'build.gradle';
-    if (filename.endsWith('.kts')) {
-        gradleFilePath = 'build.gradle.kts';
-    }
-    gradleFilePath = (0, path_1.join)((0, path_1.dirname)(settingsGradleFile), gradleFilePath);
-    let buildGradleContent = '';
-    if (!tree.exists(gradleFilePath)) {
-        tree.write(gradleFilePath, buildGradleContent); // create a build.gradle file near settings.gradle file if it does not exist
-    }
-    else {
-        buildGradleContent = tree.read(gradleFilePath).toString();
-    }
-    const nxProjectGraphReportPlugin = filename.endsWith('.kts')
-        ? `id("${versions_1.gradleProjectGraphPluginName}") version("${versions_1.gradleProjectGraphVersion}")`
-        : `id "${versions_1.gradleProjectGraphPluginName}" version "${versions_1.gradleProjectGraphVersion}"`;
-    if (buildGradleContent.includes('plugins {')) {
-        if (!buildGradleContent.includes(versions_1.gradleProjectGraphPluginName)) {
-            buildGradleContent = buildGradleContent.replace('plugins {', `plugins {
-    ${nxProjectGraphReportPlugin}`);
-        }
-    }
-    else {
-        buildGradleContent = `plugins {
-    ${nxProjectGraphReportPlugin}
-}\n\r${buildGradleContent}`;
-    }
-    const applyNxProjectGraphReportPlugin = `plugin("${versions_1.gradleProjectGraphPluginName}")`;
-    if (buildGradleContent.includes('allprojects {')) {
-        if (!buildGradleContent.includes(`plugin("${versions_1.gradleProjectGraphPluginName}")`) &&
-            !buildGradleContent.includes(`plugin('${versions_1.gradleProjectGraphPluginName}')`)) {
-            devkit_1.logger.warn(`Please add the ${versions_1.gradleProjectGraphPluginName} plugin to your ${gradleFilePath}:
-allprojects {
-  apply {
-      ${applyNxProjectGraphReportPlugin}
-  }
-}`);
-        }
-    }
-    else {
-        buildGradleContent = `${buildGradleContent}\n\rallprojects {
-    apply {
-        ${applyNxProjectGraphReportPlugin}
-    }
-  }`;
-    }
-    tree.write(gradleFilePath, buildGradleContent);
-}
 function updateNxJsonConfiguration(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     if (!nxJson.namedInputs) {

package/src/migrations/21-1-2/change-plugin-version-0-1-0.d.ts

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

package/src/migrations/21-1-2/change-plugin-version-0-1-0.js

@@ -0,0 +1,18 @@
+"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");
+/* Change the plugin version to 0.1.0
+ */
+async function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    if (!(0, has_gradle_plugin_1.hasGradlePlugin)(tree)) {
+        return;
+    }
+    await (0, gradle_project_graph_plugin_utils_1.addNxProjectGraphPlugin)(tree, '0.1.0');
+}

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNxProjectGraphLines = getNxProjectGraphLines;
 const devkit_1 = require("@nx/devkit");
 const exec_gradle_1 = require("../../utils/exec-gradle");
-const node_path_1 = require("node:path");
 async function getNxProjectGraphLines(gradlewFile, gradleConfigHash, gradlePluginOptions) {
     if (process.env.VERCEL) {
         // skip on Vercel
@@ -21,7 +20,6 @@ async function getNxProjectGraphLines(gradlewFile, gradleConfigHash, gradlePlugi
             '--warning-mode',
             'none',
             ...gradlePluginOptionsArgs,
-            `-Pcwd=${(0, node_path_1.dirname)(gradlewFile)}`,
             `-PworkspaceRoot=${devkit_1.workspaceRoot}`,
             process.env.NX_VERBOSE_LOGGING ? '--info' : '',
         ]);
@@ -39,7 +37,7 @@ async function getNxProjectGraphLines(gradlewFile, gradleConfigHash, gradlePlugi
             throw new devkit_1.AggregateCreateNodesError([
                 [
                     gradlewFile,
-                    new Error(`Could not run 'nxProjectGraph' task. Please run 'nx generate @nx/gradle:init' to generate the necessary tasks.\n\r${e.toString()}`),
+                    new Error(`Could not run 'nxProjectGraph' task. Please run 'nx generate @nx/gradle:init' to add the necessary plugin dev.nx.gradle.project-graph.\n\r${e.toString()}`),
                 ],
             ], []);
         }