@nx/gradle 0.0.0-pr-26515-856ef7f

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2024 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+<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%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![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 the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+> Note: this plugin is currently experimental.
+
+# Nx: Smart Monorepos · Fast CI
+
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+
+This package is a [Gradle plugin for Nx](https://nx.dev/gradle/overview).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
+
+<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>
+

package/generators.json

@@ -0,0 +1,16 @@
+{
+  "name": "Nx Gradle",
+  "version": "0.1",
+  "generators": {
+    "init": {
+      "factory": "./src/generators/init/init#initGenerator",
+      "schema": "./src/generators/init/schema.json",
+      "description": "Initializes a Gradle project in the current workspace"
+    },
+    "ci-workflow": {
+      "factory": "./src/generators/ci-workflow/generator",
+      "schema": "./src/generators/ci-workflow/schema.json",
+      "description": "Setup a CI Workflow to run Nx in CI"
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin';

package/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./plugin"), exports);

package/migrations.json

@@ -0,0 +1,4 @@
+{
+  "generators": {},
+  "packageJsonUpdates": {}
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nx/gradle",
+  "version": "0.0.0-pr-26515-856ef7f",
+  "private": false,
+  "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/gradle"
+  },
+  "keywords": [
+    "Monorepo",
+    "Java",
+    "Gradle",
+    "CLI",
+    "Backend"
+  ],
+  "main": "./index",
+  "typings": "./index.d.ts",
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "homepage": "https://nx.dev",
+  "generators": "./generators.json",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./migrations.json": "./migrations.json",
+    "./generators.json": "./generators.json"
+  },
+  "nx-migrate": {
+    "migrations": "./migrations.json"
+  },
+  "dependencies": {
+    "@nx/devkit": "0.0.0-pr-26515-856ef7f"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs"
+}

package/plugin.d.ts

@@ -0,0 +1,2 @@
+export { createDependencies } from './src/plugin/dependencies';
+export { createNodes, createNodesV2 } from './src/plugin/nodes';

package/plugin.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
+var dependencies_1 = require("./src/plugin/dependencies");
+Object.defineProperty(exports, "createDependencies", { enumerable: true, get: function () { return dependencies_1.createDependencies; } });
+var nodes_1 = require("./src/plugin/nodes");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return nodes_1.createNodes; } });
+Object.defineProperty(exports, "createNodesV2", { enumerable: true, get: function () { return nodes_1.createNodesV2; } });

package/src/generators/ci-workflow/files/circleci/.circleci/config.yml.template

@@ -0,0 +1,32 @@
+version: 2.1
+
+orbs:
+  nx: nrwl/nx@1.6.2
+
+jobs:
+  main:
+    environment:
+      # Configure the JVM and Gradle to avoid OOM errors
+      _JAVA_OPTIONS: "-Xmx3g"
+      GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2"
+    docker:
+      - image: cimg/openjdk:17.0-node
+    steps:
+      - checkout
+
+      # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+      # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "build" targets have been requested
+      # - run: <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-jvm" --stop-agents-after="build"
+
+      - nx/set-shas:
+          main-branch-name: '<%= mainBranch %>'
+
+<% for (const command of commands) { %>
+      - run: <%= command %><% } %>
+
+workflows:
+  version: 2
+
+  <%= workflowFileName %>:
+    jobs:
+      - main

package/src/generators/ci-workflow/files/github/.github/workflows/__workflowFileName__.yml.template

@@ -0,0 +1,38 @@
+name: <%= workflowName %>
+
+on:
+  push:
+    branches:
+      - <%= mainBranch %>
+  pull_request:
+
+permissions:
+  actions: read
+  contents: read
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+      # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "build" targets have been requested
+      # - run: <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-jvm" --stop-agents-after="build"
+
+      - name: Set up JDK 17 for x64
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          architecture: x64
+
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@v2
+
+      - uses: nrwl/nx-set-shas@v4
+
+<% for (const command of commands) { %>
+      - run: <%= command %><% } %>

package/src/generators/ci-workflow/generator.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+export interface Schema {
+    name: string;
+    ci: 'github' | 'circleci';
+    packageManager?: null;
+    commands?: string[];
+}
+export declare function ciWorkflowGenerator(tree: Tree, schema: Schema): Promise<void>;
+export default ciWorkflowGenerator;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ciWorkflowGenerator = void 0;
+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");
+function getCiCommands(ci, mainBranch) {
+    switch (ci) {
+        case 'circleci': {
+            return [`./nx affected --base=$NX_BASE --head=$NX_HEAD -t test build`];
+        }
+        default: {
+            return [`./nx affected -t test build`];
+        }
+    }
+}
+async function ciWorkflowGenerator(tree, schema) {
+    const ci = schema.ci;
+    const options = getTemplateData(tree, schema);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files', ci), '', options);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.ciWorkflowGenerator = ciWorkflowGenerator;
+function getTemplateData(tree, options) {
+    const { name: workflowName, fileName: workflowFileName } = (0, devkit_1.names)(options.name);
+    const packageManager = (0, devkit_1.detectPackageManager)();
+    const { exec: packageManagerPrefix } = (0, devkit_1.getPackageManagerCommand)(packageManager);
+    let nxCloudHost = 'nx.app';
+    try {
+        const nxCloudUrl = (0, nx_cloud_utils_1.getNxCloudUrl)((0, devkit_1.readJson)(tree, 'nx.json'));
+        nxCloudHost = new URL(nxCloudUrl).host;
+    }
+    catch { }
+    const mainBranch = (0, default_base_1.deduceDefaultBase)();
+    const commands = options.commands ?? getCiCommands(options.ci, mainBranch);
+    return {
+        workflowName,
+        workflowFileName,
+        packageManager,
+        packageManagerPrefix,
+        commands,
+        mainBranch,
+        nxCloudHost,
+    };
+}
+exports.default = ciWorkflowGenerator;

package/src/generators/ci-workflow/schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxGradleCiWorkflowSchema",
+  "title": "Gradle CI Workflow Generator",
+  "description": "Setup a CI Workflow to run Nx in CI.",
+  "type": "object",
+  "properties": {
+    "ci": {
+      "type": "string",
+      "description": "CI provider.",
+      "enum": ["github", "circleci"],
+      "x-prompt": {
+        "message": "What is your target CI provider?",
+        "type": "list",
+        "items": [
+          {
+            "value": "github",
+            "label": "GitHub Actions"
+          },
+          {
+            "value": "circleci",
+            "label": "Circle CI"
+          }
+        ]
+      }
+    },
+    "name": {
+      "type": "string",
+      "description": "Workflow name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "default": "CI",
+      "x-prompt": "How should we name your workflow?",
+      "pattern": "^[a-zA-Z].*$"
+    }
+  },
+  "required": ["ci", "name"]
+}

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

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { InitGeneratorSchema } from './schema';
+export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const versions_1 = require("../../utils/versions");
+const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
+async function initGenerator(tree, options) {
+    const tasks = [];
+    if (!tree.exists('settings.gradle') && !tree.exists('settings.gradle.kts')) {
+        devkit_1.logger.warn(`Could not find 'settings.gradle' or 'settings.gradle.kts' file in your gradle workspace.
+A Gradle build should contain a 'settings.gradle' or 'settings.gradle.kts' file in its root directory. It may also contain a 'build.gradle' or 'build.gradle.kts' file.
+Running 'gradle init':`);
+        (0, child_process_1.execSync)('gradle init', { stdio: 'inherit' });
+    }
+    if (!options.skipPackageJson && tree.exists('package.json')) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/gradle': versions_1.nxVersion,
+        }, undefined, options.keepExistingVersions));
+    }
+    addPlugin(tree);
+    updateNxJsonConfiguration(tree);
+    addProjectReportToBuildGradle(tree);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.initGenerator = initGenerator;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!(0, has_gradle_plugin_1.hasGradlePlugin)(tree)) {
+        nxJson.plugins ??= [];
+        nxJson.plugins.push({
+            plugin: '@nx/gradle',
+            options: {
+                testTargetName: 'test',
+                classesTargetName: 'classes',
+                buildTargetName: 'build',
+            },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+/**
+ * This function adds the project-report plugin to the build.gradle or build.gradle.kts file
+ */
+function addProjectReportToBuildGradle(tree) {
+    let buildGradleFile;
+    if (tree.exists('settings.gradle.kts')) {
+        buildGradleFile = 'build.gradle.kts';
+    }
+    else if (tree.exists('settings.gradle')) {
+        buildGradleFile = 'build.gradle';
+    }
+    let buildGradleContent = '';
+    if (tree.exists(buildGradleFile)) {
+        buildGradleContent = tree.read(buildGradleFile).toString();
+    }
+    if (buildGradleContent.includes('allprojects')) {
+        if (!buildGradleContent.includes('"project-report')) {
+            devkit_1.logger.warn(`Please add the project-report plugin to your ${buildGradleFile}:
+allprojects {
+  apply {
+      plugin("project-report")
+  }
+}`);
+        }
+    }
+    else {
+        buildGradleContent += `\n\rallprojects {
+  apply {
+      plugin("project-report")
+  }
+}`;
+        tree.write(buildGradleFile, buildGradleContent);
+    }
+}
+function updateNxJsonConfiguration(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson.namedInputs) {
+        nxJson.namedInputs = {};
+    }
+    const defaultFilesSet = nxJson.namedInputs.default ?? [];
+    nxJson.namedInputs.default = Array.from(new Set([...defaultFilesSet, '{projectRoot}/**/*']));
+    const productionFileSet = nxJson.namedInputs.production ?? [];
+    nxJson.namedInputs.production = Array.from(new Set([...productionFileSet, 'default', '!{projectRoot}/test/**/*']));
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.default = initGenerator;

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

@@ -0,0 +1,6 @@
+export interface InitGeneratorSchema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxGradleInitSchema",
+  "title": "Gradle Init Generator",
+  "description": "Initializes a Gradle project in the current workspace.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/plugin/dependencies.d.ts

@@ -0,0 +1,2 @@
+import { CreateDependencies } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;

package/src/plugin/dependencies.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const get_gradle_report_1 = require("../utils/get-gradle-report");
+const createDependencies = async (_, context) => {
+    const gradleFiles = findGradleFiles(context.filesToProcess);
+    if (gradleFiles.length === 0) {
+        return [];
+    }
+    let dependencies = [];
+    const gradleDependenciesStart = performance.mark('gradleDependencies:start');
+    const { gradleFileToGradleProjectMap, gradleProjectToProjectName, buildFileToDepsMap, } = (0, get_gradle_report_1.getCurrentGradleReport)();
+    for (const gradleFile of gradleFiles) {
+        const gradleProject = gradleFileToGradleProjectMap.get(gradleFile);
+        const projectName = gradleProjectToProjectName.get(gradleProject);
+        const depsFile = buildFileToDepsMap.get(gradleFile);
+        if (projectName && depsFile) {
+            dependencies = dependencies.concat(Array.from(processGradleDependencies(depsFile, gradleProjectToProjectName, projectName, gradleFile, context)));
+        }
+    }
+    const gradleDependenciesEnd = performance.mark('gradleDependencies:end');
+    performance.measure('gradleDependencies', gradleDependenciesStart.name, gradleDependenciesEnd.name);
+    return dependencies;
+};
+exports.createDependencies = createDependencies;
+const gradleConfigFileNames = new Set(['build.gradle', 'build.gradle.kts']);
+function findGradleFiles(fileMap) {
+    const gradleFiles = [];
+    for (const [_, files] of Object.entries(fileMap.projectFileMap)) {
+        for (const file of files) {
+            if (gradleConfigFileNames.has((0, node_path_1.basename)(file.file))) {
+                gradleFiles.push(file.file);
+            }
+        }
+    }
+    return gradleFiles;
+}
+function processGradleDependencies(depsFile, gradleProjectToProjectName, sourceProjectName, gradleFile, context) {
+    const dependencies = new Set();
+    const lines = (0, node_fs_1.readFileSync)(depsFile).toString().split(get_gradle_report_1.newLineSeparator);
+    let inDeps = false;
+    for (const line of lines) {
+        if (line.startsWith('implementationDependenciesMetadata') ||
+            line.startsWith('compileClasspath')) {
+            inDeps = true;
+            continue;
+        }
+        if (inDeps) {
+            if (line === '') {
+                inDeps = false;
+                continue;
+            }
+            const [indents, dep] = line.split('--- ');
+            if ((indents === '\\' || indents === '+') && dep.startsWith('project ')) {
+                const gradleProjectName = dep
+                    .substring('project '.length)
+                    .replace(/ \(n\)$/, '')
+                    .trim();
+                const target = gradleProjectToProjectName.get(gradleProjectName);
+                const dependency = {
+                    source: sourceProjectName,
+                    target,
+                    type: devkit_1.DependencyType.static,
+                    sourceFile: gradleFile,
+                };
+                (0, devkit_1.validateDependency)(dependency, context);
+                dependencies.add(dependency);
+            }
+        }
+    }
+    return dependencies;
+}

package/src/plugin/nodes.d.ts

@@ -0,0 +1,22 @@
+import { CreateNodes, CreateNodesV2, ProjectConfiguration, TargetConfiguration, CreateNodesFunction } from '@nx/devkit';
+import { GradleReport } from '../utils/get-gradle-report';
+export interface GradlePluginOptions {
+    testTargetName?: string;
+    classesTargetName?: string;
+    buildTargetName?: string;
+    [taskTargetName: string]: string | undefined;
+}
+type GradleTargets = Record<string, {
+    name: string;
+    targets: Record<string, TargetConfiguration>;
+    metadata: ProjectConfiguration['metadata'];
+}>;
+export declare function writeTargetsToCache(cachePath: string, results: GradleTargets): void;
+export declare const createNodesV2: CreateNodesV2<GradlePluginOptions>;
+export declare const makeCreateNodes: (gradleReport: GradleReport, targetsCache: GradleTargets) => CreateNodesFunction;
+/**
+ @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.
+ */
+export declare const createNodes: CreateNodes<GradlePluginOptions>;
+export {};

package/src/plugin/nodes.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.makeCreateNodes = exports.createNodesV2 = exports.writeTargetsToCache = void 0;
+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 exec_gradle_1 = require("../utils/exec-gradle");
+const get_gradle_report_1 = require("../utils/get-gradle-report");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cacheableTaskType = new Set(['Build', 'Verification']);
+const dependsOnMap = {
+    build: ['^build', 'classes'],
+    test: ['classes'],
+    classes: ['^classes'],
+};
+function readTargetsCache(cachePath) {
+    return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+exports.writeTargetsToCache = writeTargetsToCache;
+exports.createNodesV2 = [
+    get_gradle_report_1.gradleConfigGlob,
+    async (configFiles, options, context) => {
+        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);
+        const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodes)(gradleReport, targetsCache), configFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
+const makeCreateNodes = (gradleReport, targetsCache) => async (gradleFilePath, options, context) => {
+    const projectRoot = (0, node_path_1.dirname)(gradleFilePath);
+    const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options ?? {}, context);
+    targetsCache[hash] ??= createGradleProject(gradleReport, gradleFilePath, options, context);
+    const project = targetsCache[hash];
+    if (!project) {
+        return {};
+    }
+    return {
+        projects: {
+            [projectRoot]: project,
+        },
+    };
+};
+exports.makeCreateNodes = makeCreateNodes;
+/**
+ @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 = [
+    get_gradle_report_1.gradleConfigGlob,
+    async (configFile, 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.');
+        await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot);
+        const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
+        const internalCreateNodes = (0, exports.makeCreateNodes)(gradleReport, {});
+        return await internalCreateNodes(configFile, options, context);
+    },
+];
+function createGradleProject(gradleReport, gradleFilePath, options, context) {
+    try {
+        const { gradleProjectToTasksTypeMap, gradleFileToOutputDirsMap, gradleFileToGradleProjectMap, gradleProjectToProjectName, } = gradleReport;
+        const gradleProject = gradleFileToGradleProjectMap.get(gradleFilePath);
+        const projectName = gradleProjectToProjectName.get(gradleProject);
+        if (!projectName) {
+            return;
+        }
+        const tasksTypeMap = gradleProjectToTasksTypeMap.get(gradleProject);
+        let tasks = [];
+        for (let [taskName, taskType] of tasksTypeMap.entries()) {
+            tasks.push({
+                type: taskType,
+                name: taskName,
+            });
+        }
+        const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
+        const { targets, targetGroups } = createGradleTargets(tasks, options, context, outputDirs, gradleProject);
+        const project = {
+            name: projectName,
+            targets,
+            metadata: {
+                targetGroups,
+                technologies: ['gradle'],
+            },
+        };
+        return project;
+    }
+    catch (e) {
+        console.error(e);
+        return undefined;
+    }
+}
+function createGradleTargets(tasks, options, context, outputDirs, gradleProject) {
+    const inputsMap = createInputsMap(context);
+    const targets = {};
+    const targetGroups = {};
+    for (const task of tasks) {
+        const targetName = options?.[`${task.name}TargetName`] ?? task.name;
+        const outputs = outputDirs.get(task.name);
+        targets[targetName] = {
+            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${gradleProject ? gradleProject + ':' : ''}${task.name}`,
+            cache: cacheableTaskType.has(task.type),
+            inputs: inputsMap[task.name],
+            dependsOn: dependsOnMap[task.name],
+            metadata: {
+                technologies: ['gradle'],
+            },
+        };
+        if (outputs) {
+            targets[targetName].outputs = [outputs];
+        }
+        if (!targetGroups[task.type]) {
+            targetGroups[task.type] = [];
+        }
+        targetGroups[task.type].push(task.name);
+    }
+    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'],
+    };
+}

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecFileOptions } from 'node:child_process';
+export declare function getGradleBinaryPath(): string;
+export declare function getGradleExecFile(): string;
+export declare function execGradleAsync(args: ReadonlyArray<string>, execOptions?: ExecFileOptions): Promise<Buffer>;

package/src/utils/exec-gradle.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execGradleAsync = exports.getGradleExecFile = exports.getGradleBinaryPath = void 0;
+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");
+function getGradleBinaryPath() {
+    const gradleFile = process.platform.startsWith('win')
+        ? 'gradlew.bat'
+        : 'gradlew';
+    const gradleBinaryPath = (0, node_path_1.join)(devkit_1.workspaceRoot, gradleFile);
+    if (!(0, node_fs_1.existsSync)(gradleBinaryPath)) {
+        throw new Error('Gradle is not setup. Run "gradle init"');
+    }
+    return gradleBinaryPath;
+}
+exports.getGradleBinaryPath = getGradleBinaryPath;
+function getGradleExecFile() {
+    return process.platform.startsWith('win') ? '.\\gradlew.bat' : './gradlew';
+}
+exports.getGradleExecFile = getGradleExecFile;
+function execGradleAsync(args, execOptions = {}) {
+    const gradleBinaryPath = getGradleBinaryPath();
+    return new Promise((res, rej) => {
+        const cp = (0, node_child_process_1.execFile)(gradleBinaryPath, args, {
+            ...execOptions,
+            shell: true,
+            windowsHide: true,
+        });
+        let stdout = Buffer.from('');
+        cp.stdout?.on('data', (data) => {
+            stdout += data;
+        });
+        cp.on('exit', (code) => {
+            if (code === 0) {
+                res(stdout);
+            }
+            else {
+                rej(new Error(`Executing Gradle with ${args.join(' ')} failed with code: ${code}. \nLogs: ${stdout}`));
+            }
+        });
+    });
+}
+exports.execGradleAsync = execGradleAsync;

package/src/utils/get-gradle-report.d.ts

@@ -0,0 +1,13 @@
+export declare const fileSeparator: string;
+export declare const newLineSeparator: string;
+export interface GradleReport {
+    gradleFileToGradleProjectMap: Map<string, string>;
+    buildFileToDepsMap: Map<string, string>;
+    gradleFileToOutputDirsMap: Map<string, Map<string, string>>;
+    gradleProjectToTasksTypeMap: Map<string, Map<string, string>>;
+    gradleProjectToProjectName: Map<string, string>;
+}
+export declare const gradleConfigGlob = "**/build.{gradle.kts,gradle}";
+export declare function getCurrentGradleReport(): GradleReport;
+export declare function populateGradleReport(workspaceRoot: string): Promise<void>;
+export declare function processProjectReports(projectReportLines: string[]): GradleReport;

package/src/utils/get-gradle-report.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processProjectReports = exports.populateGradleReport = exports.getCurrentGradleReport = exports.gradleConfigGlob = exports.newLineSeparator = exports.fileSeparator = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const devkit_1 = require("@nx/devkit");
+const exec_gradle_1 = require("./exec-gradle");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+exports.fileSeparator = process.platform.startsWith('win')
+    ? 'file:///'
+    : 'file://';
+exports.newLineSeparator = process.platform.startsWith('win')
+    ? '\r\n'
+    : '\n';
+let gradleReportCache;
+let gradleCurrentConfigHash;
+exports.gradleConfigGlob = '**/build.{gradle.kts,gradle}';
+function getCurrentGradleReport() {
+    if (!gradleReportCache) {
+        throw new Error('Expected cached gradle report. Please open an issue at https://github.com/nrwl/nx/issues/new/choose');
+    }
+    return gradleReportCache;
+}
+exports.getCurrentGradleReport = getCurrentGradleReport;
+async function populateGradleReport(workspaceRoot) {
+    const gradleConfigHash = await (0, workspace_context_1.hashWithWorkspaceContext)(workspaceRoot, [
+        exports.gradleConfigGlob,
+    ]);
+    if (gradleReportCache && gradleConfigHash === gradleCurrentConfigHash) {
+        return;
+    }
+    const gradleProjectReportStart = performance.mark('gradleProjectReport:start');
+    const projectReportLines = (await (0, exec_gradle_1.execGradleAsync)(['projectReport'], {
+        cwd: workspaceRoot,
+    }))
+        .toString()
+        .split(exports.newLineSeparator);
+    const gradleProjectReportEnd = performance.mark('gradleProjectReport:end');
+    performance.measure('gradleProjectReport', gradleProjectReportStart.name, gradleProjectReportEnd.name);
+    gradleReportCache = processProjectReports(projectReportLines);
+}
+exports.populateGradleReport = populateGradleReport;
+function processProjectReports(projectReportLines) {
+    /**
+     * Map of Gradle File path to Gradle Project Name
+     */
+    const gradleFileToGradleProjectMap = new Map();
+    /**
+     * Map of Gradle Project Name to Gradle File
+     */
+    const gradleProjectToGradleFileMap = new Map();
+    const dependenciesMap = new Map();
+    /**
+     * Map of Gradle Build File to tasks type map
+     */
+    const gradleProjectToTasksTypeMap = new Map();
+    const gradleProjectToProjectName = new Map();
+    /**
+     * Map of buildFile to dependencies report path
+     */
+    const buildFileToDepsMap = new Map();
+    /**
+     * Map fo possible output files of each gradle file
+     * e.g. {build.gradle.kts: { projectReportDir: '' testReportDir: '' }}
+     */
+    const gradleFileToOutputDirsMap = new Map();
+    let index = 0;
+    while (index < projectReportLines.length) {
+        const line = projectReportLines[index].trim();
+        if (line.startsWith('> Task ')) {
+            if (line.endsWith(':dependencyReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':dependencyReport'.length);
+                while (index < projectReportLines.length &&
+                    !projectReportLines[index].includes(exports.fileSeparator)) {
+                    index++;
+                }
+                const [_, file] = projectReportLines[index].split(exports.fileSeparator);
+                dependenciesMap.set(gradleProject, file);
+            }
+            if (line.endsWith('propertyReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':propertyReport'.length);
+                while (index < projectReportLines.length &&
+                    !projectReportLines[index].includes(exports.fileSeparator)) {
+                    index++;
+                }
+                const [_, file] = projectReportLines[index].split(exports.fileSeparator);
+                const propertyReportLines = (0, node_fs_1.existsSync)(file)
+                    ? (0, node_fs_1.readFileSync)(file).toString().split(exports.newLineSeparator)
+                    : [];
+                let projectName, absBuildFilePath, absBuildDirPath;
+                const outputDirMap = new Map();
+                for (const line of propertyReportLines) {
+                    if (line.startsWith('name: ')) {
+                        projectName = line.substring('name: '.length);
+                    }
+                    if (line.startsWith('buildFile: ')) {
+                        absBuildFilePath = line.substring('buildFile: '.length);
+                    }
+                    if (line.startsWith('buildDir: ')) {
+                        absBuildDirPath = line.substring('buildDir: '.length);
+                    }
+                    if (line.includes('Dir: ')) {
+                        const [dirName, dirPath] = line.split(': ');
+                        const taskName = dirName.replace('Dir', '');
+                        outputDirMap.set(taskName, `{workspaceRoot}/${(0, node_path_1.relative)(devkit_1.workspaceRoot, dirPath)}`);
+                    }
+                }
+                if (!projectName || !absBuildFilePath || !absBuildDirPath) {
+                    continue;
+                }
+                const buildFile = (0, devkit_1.normalizePath)((0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildFilePath));
+                const buildDir = (0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildDirPath);
+                buildFileToDepsMap.set(buildFile, dependenciesMap.get(gradleProject));
+                outputDirMap.set('build', `{workspaceRoot}/${buildDir}`);
+                outputDirMap.set('classes', `{workspaceRoot}/${(0, node_path_1.join)(buildDir, 'classes')}`);
+                gradleFileToOutputDirsMap.set(buildFile, outputDirMap);
+                gradleFileToGradleProjectMap.set(buildFile, gradleProject);
+                gradleProjectToGradleFileMap.set(gradleProject, buildFile);
+                gradleProjectToProjectName.set(gradleProject, projectName);
+            }
+            if (line.endsWith('taskReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':taskReport'.length);
+                while (index < projectReportLines.length &&
+                    !projectReportLines[index].includes(exports.fileSeparator)) {
+                    index++;
+                }
+                const [_, file] = projectReportLines[index].split(exports.fileSeparator);
+                const taskTypeMap = new Map();
+                const tasksFileLines = (0, node_fs_1.existsSync)(file)
+                    ? (0, node_fs_1.readFileSync)(file).toString().split(exports.newLineSeparator)
+                    : [];
+                let i = 0;
+                while (i < tasksFileLines.length) {
+                    const line = tasksFileLines[i];
+                    if (line.endsWith('tasks')) {
+                        const dashes = new Array(line.length + 1).join('-');
+                        if (tasksFileLines[i + 1] === dashes) {
+                            const type = line.substring(0, line.length - ' tasks'.length);
+                            i++;
+                            while (tasksFileLines[++i] !== '') {
+                                const [taskName] = tasksFileLines[i].split(' - ');
+                                taskTypeMap.set(taskName, type);
+                            }
+                        }
+                    }
+                    i++;
+                }
+                gradleProjectToTasksTypeMap.set(gradleProject, taskTypeMap);
+            }
+        }
+        index++;
+    }
+    return {
+        gradleFileToGradleProjectMap,
+        buildFileToDepsMap,
+        gradleFileToOutputDirsMap,
+        gradleProjectToTasksTypeMap,
+        gradleProjectToProjectName,
+    };
+}
+exports.processProjectReports = processProjectReports;

package/src/utils/has-gradle-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasGradlePlugin(tree: Tree): boolean;

package/src/utils/has-gradle-plugin.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGradlePlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasGradlePlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string' ? p === '@nx/gradle' : p.plugin === '@nx/gradle');
+}
+exports.hasGradlePlugin = hasGradlePlugin;

package/src/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare const nxVersion: any;

package/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;