@nx/gradle 19.0.0-beta.0 → 19.0.0-beta.10

package/generators.json

@@ -6,6 +6,11 @@
       "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/package.json

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

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,40 @@
+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
+
+      - run: git branch --track main origin/main
+        if: ${{ github.event_name == 'pull_request' }}
+<% 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,48 @@
+"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 nxJson = (0, devkit_1.readNxJson)(tree);
+    const nxCloudUsed = (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson);
+    if (!nxCloudUsed) {
+        throw new Error('This workspace is not connected to Nx Cloud.');
+    }
+    const options = getTemplateData(schema, nxJson);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files', ci), '', options);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.ciWorkflowGenerator = ciWorkflowGenerator;
+function getTemplateData(options, nxJson) {
+    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);
+    const nxCloudUrl = (0, nx_cloud_utils_1.getNxCloudUrl)(nxJson);
+    const nxCloudHost = new URL(nxCloudUrl).host;
+    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/plugin/nodes.d.ts

@@ -1,4 +1,4 @@
-import { CreateNodes, TargetConfiguration } from '@nx/devkit';
+import { CreateNodes, ProjectConfiguration, TargetConfiguration } from '@nx/devkit';
 export interface GradlePluginOptions {
     testTargetName?: string;
     classesTargetName?: string;
@@ -8,11 +8,11 @@ export interface GradlePluginOptions {
 export declare const calculatedTargets: Record<string, {
     name: string;
     targets: Record<string, TargetConfiguration>;
-    targetGroups: Record<string, string[]>;
+    metadata: ProjectConfiguration['metadata'];
 }>;
 export declare function writeTargetsToCache(targets: Record<string, {
     name: string;
     targets: Record<string, TargetConfiguration>;
-    targetGroups: Record<string, string[]>;
+    metadata: ProjectConfiguration['metadata'];
 }>): void;
 export declare const createNodes: CreateNodes<GradlePluginOptions>;

package/src/plugin/nodes.js

@@ -33,12 +33,7 @@ exports.createNodes = [
             exports.calculatedTargets[hash] = targetsCache[hash];
             return {
                 projects: {
-                    [projectRoot]: {
-                        ...targetsCache[hash],
-                        metadata: {
-                            technologies: ['gradle'],
-                        },
-                    },
+                    [projectRoot]: targetsCache[hash],
                 },
             };
         }
@@ -58,19 +53,16 @@ exports.createNodes = [
                 });
             }
             const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
-            const { targets, targetGroups } = createGradleTargets(tasks, projectRoot, options, context, outputDirs);
-            exports.calculatedTargets[hash] = {
-                name: projectName,
-                targets,
-                targetGroups,
-            };
+            const { targets, targetGroups } = createGradleTargets(tasks, options, context, outputDirs, gradleProject);
             const project = {
                 name: projectName,
                 targets,
                 metadata: {
+                    targetGroups,
                     technologies: ['gradle'],
                 },
             };
+            exports.calculatedTargets[hash] = project;
             return {
                 projects: {
                     [projectRoot]: project,
@@ -83,7 +75,7 @@ exports.createNodes = [
         }
     },
 ];
-function createGradleTargets(tasks, projectRoot, options, context, outputDirs) {
+function createGradleTargets(tasks, options, context, outputDirs, gradleProject) {
     const inputsMap = createInputsMap(context);
     const targets = {};
     const targetGroups = {};
@@ -91,14 +83,14 @@ function createGradleTargets(tasks, projectRoot, options, context, outputDirs) {
         const targetName = options?.[`${task.name}TargetName`] ?? task.name;
         const outputs = outputDirs.get(task.name);
         targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleBinaryPath)()} ${task.name}`,
-            options: {
-                cwd: projectRoot,
-            },
+            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${gradleProject ? gradleProject + ':' : ''}${task.name}`,
             cache: cacheableTaskType.has(task.type),
             inputs: inputsMap[task.name],
             outputs: outputs ? [outputs] : undefined,
             dependsOn: dependsOnMap[task.name],
+            metadata: {
+                technologies: ['gradle'],
+            },
         };
         if (!targetGroups[task.type]) {
             targetGroups[task.type] = [];

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

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

package/src/utils/exec-gradle.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execGradleAsync = exports.getGradleBinaryPath = exports.execGradle = void 0;
+exports.execGradleAsync = exports.getGradleExecFile = exports.getGradleBinaryPath = exports.execGradle = void 0;
 const devkit_1 = require("@nx/devkit");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
@@ -21,11 +21,12 @@ function getGradleBinaryPath() {
     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();
-    if (!(0, node_fs_1.existsSync)(gradleBinaryPath)) {
-        throw new Error('Gradle is not setup. Run "gradle init"');
-    }
     return new Promise((res, rej) => {
         const cp = (0, node_child_process_1.execFile)(gradleBinaryPath, args, execOptions);
         let stdout = Buffer.from('');

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

@@ -1,4 +1,5 @@
-interface GradleReport {
+export declare const fileSeparator: string;
+export interface GradleReport {
     gradleFileToGradleProjectMap: Map<string, string>;
     buildFileToDepsMap: Map<string, string>;
     gradleFileToOutputDirsMap: Map<string, Map<string, string>>;
@@ -7,4 +8,4 @@ interface GradleReport {
 }
 export declare function invalidateGradleReportCache(): void;
 export declare function getGradleReport(): GradleReport;
-export {};
+export declare function processProjectReports(projectReportLines: string[]): GradleReport;

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGradleReport = exports.invalidateGradleReportCache = void 0;
+exports.processProjectReports = exports.getGradleReport = exports.invalidateGradleReportCache = 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 fileSeparator = process.platform.startsWith('win')
+exports.fileSeparator = process.platform.startsWith('win')
     ? 'file:///'
     : 'file://';
 const newLineSeparator = process.platform.startsWith('win') ? '\r\n' : '\n';
@@ -54,20 +54,29 @@ function processProjectReports(projectReportLines) {
      * e.g. {build.gradle.kts: { projectReportDir: '' testReportDir: '' }}
      */
     const gradleFileToOutputDirsMap = new Map();
-    projectReportLines.forEach((line, index) => {
+    let index = 0;
+    while (index < projectReportLines.length) {
+        const line = projectReportLines[index].trim();
         if (line.startsWith('> Task ')) {
-            const nextLine = projectReportLines[index + 1];
             if (line.endsWith(':dependencyReport')) {
                 const gradleProject = line.substring('> Task '.length, line.length - ':dependencyReport'.length);
-                const [_, file] = nextLine.split(fileSeparator);
+                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);
-                const [_, file] = nextLine.split(fileSeparator);
-                const propertyReportLines = (0, node_fs_1.readFileSync)(file)
-                    .toString()
-                    .split(newLineSeparator);
+                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(newLineSeparator)
+                    : [];
                 let projectName, absBuildFilePath, absBuildDirPath;
                 const outputDirMap = new Map();
                 for (const line of propertyReportLines) {
@@ -87,7 +96,7 @@ function processProjectReports(projectReportLines) {
                     }
                 }
                 if (!projectName || !absBuildFilePath || !absBuildDirPath) {
-                    return;
+                    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);
@@ -101,11 +110,15 @@ function processProjectReports(projectReportLines) {
             }
             if (line.endsWith('taskReport')) {
                 const gradleProject = line.substring('> Task '.length, line.length - ':taskReport'.length);
-                const [_, file] = nextLine.split(fileSeparator);
+                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.readFileSync)(file)
-                    .toString()
-                    .split(newLineSeparator);
+                const tasksFileLines = (0, node_fs_1.existsSync)(file)
+                    ? (0, node_fs_1.readFileSync)(file).toString().split(newLineSeparator)
+                    : [];
                 let i = 0;
                 while (i < tasksFileLines.length) {
                     const line = tasksFileLines[i];
@@ -125,7 +138,8 @@ function processProjectReports(projectReportLines) {
                 gradleProjectToTasksTypeMap.set(gradleProject, taskTypeMap);
             }
         }
-    });
+        index++;
+    }
     return {
         gradleFileToGradleProjectMap,
         buildFileToDepsMap,
@@ -134,3 +148,4 @@ function processProjectReports(projectReportLines) {
         gradleProjectToProjectName,
     };
 }
+exports.processProjectReports = processProjectReports;