@nx/gradle 21.0.0-canary.20250422-8619c1d → 21.0.0-canary.20250424-e23b25f

package/src/plugin/nodes.js

@@ -1,32 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = void 0;
+exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = void 0;
 exports.writeTargetsToCache = writeTargetsToCache;
 const devkit_1 = require("@nx/devkit");
 const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-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']);
-const dependsOnMap = {
-    build: ['^build', 'classes', 'test'],
-    testClasses: ['classes'],
-    test: ['testClasses'],
-    classes: ['^classes'],
-};
-function normalizeOptions(options) {
-    options ??= {};
-    options.testTargetName ??= 'test';
-    options.classesTargetName ??= 'classes';
-    options.buildTargetName ??= 'build';
-    return options;
-}
-function readTargetsCache(cachePath) {
+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");
+function readProjectsCache(cachePath) {
     return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
 }
 function writeTargetsToCache(cachePath, results) {
@@ -35,232 +20,36 @@ function writeTargetsToCache(cachePath, results) {
 exports.createNodesV2 = [
     split_config_files_1.gradleConfigAndTestGlob,
     async (files, options, context) => {
-        const { buildFiles, projectRoots, gradlewFiles, testFiles } = (0, split_config_files_1.splitConfigFiles)(files);
+        const { buildFiles, 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 targetsCache = readTargetsCache(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);
+        const projectsCache = readProjectsCache(cachePath);
+        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 { nodes, externalNodes } = (0, get_project_graph_from_gradle_plugin_1.getCurrentProjectGraphReport)();
         try {
-            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(gradleReport, targetsCache, gradleProjectRootToTestFilesMap), buildFiles, options, context);
+            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(nodes, projectsCache, externalNodes), buildFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            writeTargetsToCache(cachePath, projectsCache);
         }
     },
 ];
-const makeCreateNodesForGradleConfigFile = (gradleReport, targetsCache = {}, gradleProjectRootToTestFilesMap = {}) => async (gradleFilePath, options, context) => {
+const makeCreateNodesForGradleConfigFile = (projects, projectsCache = {}, externalNodes = {}) => async (gradleFilePath, options, context) => {
     const projectRoot = (0, node_path_1.dirname)(gradleFilePath);
-    options = normalizeOptions(options);
+    options = (0, gradle_plugin_options_1.normalizeOptions)(options);
     const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options ?? {}, context);
-    targetsCache[hash] ??= await createGradleProject(gradleReport, gradleFilePath, options, context, gradleProjectRootToTestFilesMap[projectRoot]);
-    const project = targetsCache[hash];
+    projectsCache[hash] ??=
+        projects[projectRoot] ?? projects[(0, node_path_1.join)(devkit_1.workspaceRoot, projectRoot)];
+    const project = projectsCache[hash];
     if (!project) {
         return {};
     }
+    project.root = projectRoot;
     return {
         projects: {
             [projectRoot]: project,
         },
+        externalNodes: externalNodes,
     };
 };
 exports.makeCreateNodesForGradleConfigFile = makeCreateNodesForGradleConfigFile;
-/**
- @deprecated This is replaced with {@link createNodesV2}. Update your plugin to export its own `createNodesV2` function that wraps this one instead.
-  This function will change to the v2 function in Nx 20.
- */
-exports.createNodes = [
-    split_config_files_1.gradleConfigGlob,
-    async (buildFile, options, context) => {
-        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
-        const { gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(context.configFiles);
-        await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot, gradlewFiles);
-        const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
-        const internalCreateNodes = (0, exports.makeCreateNodesForGradleConfigFile)(gradleReport);
-        return await internalCreateNodes(buildFile, options, context);
-    },
-];
-async function createGradleProject(gradleReport, gradleFilePath, options, context, testFiles = []) {
-    try {
-        const { gradleProjectToTasksTypeMap, gradleProjectToTasksMap, gradleFileToOutputDirsMap, gradleFileToGradleProjectMap, gradleProjectToProjectName, } = gradleReport;
-        const gradleProject = gradleFileToGradleProjectMap.get(gradleFilePath);
-        const projectName = gradleProjectToProjectName.get(gradleProject);
-        if (!projectName) {
-            return;
-        }
-        const tasksTypeMap = gradleProjectToTasksTypeMap.get(gradleProject);
-        const tasksSet = gradleProjectToTasksMap.get(gradleProject);
-        let tasks = [];
-        tasksSet.forEach((taskName) => {
-            tasks.push({
-                type: tasksTypeMap?.get(taskName),
-                name: taskName,
-            });
-        });
-        if (options.includeSubprojectsTasks) {
-            tasksTypeMap.forEach((taskType, taskName) => {
-                if (!tasksSet.has(taskName)) {
-                    tasks.push({
-                        type: taskType,
-                        name: taskName,
-                    });
-                }
-            });
-        }
-        const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
-        const { targets, targetGroups } = await createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleFilePath, testFiles);
-        const project = {
-            name: projectName,
-            projectType: 'application',
-            targets,
-            metadata: {
-                targetGroups,
-                technologies: ['gradle'],
-            },
-        };
-        return project;
-    }
-    catch (e) {
-        console.error(e);
-        return undefined;
-    }
-}
-async function createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleBuildFilePath, testFiles = []) {
-    const inputsMap = createInputsMap(context);
-    const gradlewFileDirectory = (0, node_path_1.dirname)((0, exec_gradle_1.findGraldewFile)(gradleBuildFilePath, context.workspaceRoot));
-    const targets = {};
-    const targetGroups = {};
-    for (const task of tasks) {
-        const targetName = options?.[`${task.name}TargetName`] ?? task.name;
-        let outputs = [outputDirs.get(task.name)].filter(Boolean);
-        if (task.name === 'test') {
-            outputs = [
-                outputDirs.get('testReport'),
-                outputDirs.get('testResults'),
-            ].filter(Boolean);
-            getTestCiTargets(testFiles, gradleProject, targetName, options.ciTargetName, inputsMap['test'], outputs, task.type, targets, targetGroups, gradlewFileDirectory);
-        }
-        const taskCommandToRun = `${gradleProject ? gradleProject + ':' : ''}${task.name}`;
-        targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${taskCommandToRun}`,
-            options: {
-                cwd: gradlewFileDirectory,
-            },
-            cache: cacheableTaskType.has(task.type),
-            inputs: inputsMap[task.name],
-            dependsOn: dependsOnMap[task.name],
-            metadata: {
-                technologies: ['gradle'],
-                help: {
-                    command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                    example: {
-                        options: {
-                            args: ['--rerun'],
-                        },
-                    },
-                },
-            },
-            ...(outputs && outputs.length ? { outputs } : {}),
-        };
-        if (task.type) {
-            if (!targetGroups[task.type]) {
-                targetGroups[task.type] = [];
-            }
-            targetGroups[task.type].push(targetName);
-        }
-    }
-    return { targetGroups, targets };
-}
-function createInputsMap(context) {
-    const namedInputs = context.nxJsonConfiguration.namedInputs;
-    return {
-        build: namedInputs?.production
-            ? ['production', '^production']
-            : ['default', '^default'],
-        test: ['default', namedInputs?.production ? '^production' : '^default'],
-        classes: namedInputs?.production
-            ? ['production', '^production']
-            : ['default', '^default'],
-    };
-}
-function getTestCiTargets(testFiles, gradleProject, testTargetName, ciTargetName, inputs, outputs, targetGroupName, targets, targetGroups, gradlewFileDirectory) {
-    if (!testFiles || testFiles.length === 0 || !ciTargetName) {
-        return;
-    }
-    const taskCommandToRun = `${gradleProject ? gradleProject + ':' : ''}test`;
-    if (!targetGroups[targetGroupName]) {
-        targetGroups[targetGroupName] = [];
-    }
-    const dependsOn = [];
-    testFiles.forEach((testFile) => {
-        const testName = (0, node_path_1.basename)(testFile).split('.')[0];
-        const targetName = ciTargetName + '--' + testName;
-        targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${taskCommandToRun} --tests ${testName}`,
-            options: {
-                cwd: gradlewFileDirectory,
-            },
-            cache: true,
-            inputs,
-            dependsOn: dependsOnMap['test'],
-            metadata: {
-                technologies: ['gradle'],
-                description: `Runs Gradle test ${testFile} in CI`,
-                help: {
-                    command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                    example: {
-                        options: {
-                            args: ['--rerun'],
-                        },
-                    },
-                },
-            },
-            ...(outputs && outputs.length > 0 ? { outputs } : {}),
-        };
-        targetGroups[targetGroupName].push(targetName);
-        dependsOn.push({
-            target: targetName,
-            projects: 'self',
-            params: 'forward',
-        });
-    });
-    targets[ciTargetName] = {
-        executor: 'nx:noop',
-        cache: true,
-        inputs,
-        dependsOn: dependsOn,
-        ...(outputs && outputs.length > 0 ? { outputs } : {}),
-        metadata: {
-            technologies: ['gradle'],
-            description: 'Runs Gradle Tests in CI',
-            nonAtomizedTarget: testTargetName,
-            help: {
-                command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                example: {
-                    options: {
-                        args: ['--rerun'],
-                    },
-                },
-            },
-        },
-    };
-    targetGroups[targetGroupName].push(ciTargetName);
-}
-function getGradleProjectRootToTestFilesMap(testFiles, projectRoots) {
-    if (testFiles.length === 0 || projectRoots.length === 0) {
-        return;
-    }
-    const roots = new Map(projectRoots.map((root) => [root, root]));
-    const testFilesToGradleProjectMap = {};
-    testFiles.forEach((testFile) => {
-        const projectRoot = (0, devkit_internals_1.findProjectForPath)(testFile, roots);
-        if (projectRoot) {
-            if (!testFilesToGradleProjectMap[projectRoot]) {
-                testFilesToGradleProjectMap[projectRoot] = [];
-            }
-            testFilesToGradleProjectMap[projectRoot].push(testFile);
-        }
-    });
-    return testFilesToGradleProjectMap;
-}

package/src/plugin/utils/__mocks__/gradle_composite.json

@@ -0,0 +1,38 @@
+{
+  "nodes": {
+    "nested/nested/proj": {
+      "targets": {
+        "buildEnvironment": {
+          "cache": true,
+          "metadata": {
+            "description": "Displays all buildscript dependencies declared in root project \u0027my-composite\u0027.",
+            "technologies": ["gradle"]
+          },
+          "command": "./gradlew :buildEnvironment",
+          "options": {
+            "cwd": "nested/nested/proj"
+          }
+        }
+      },
+      "metadata": {
+        "targetGroups": {
+          "help": ["buildEnvironment"]
+        },
+        "technologies": ["gradle"]
+      },
+      "name": "my-composite"
+    }
+  },
+  "dependencies": [
+    {
+      "source": "nested/nested/proj",
+      "target": "projectRoot/my-app",
+      "sourceFile": "projectRoot/build.gradle.kts"
+    },
+    {
+      "source": "nested/nested/proj",
+      "target": "projectRoot/my-utils",
+      "sourceFile": "projectRoot/build.gradle.kts"
+    }
+  ]
+}