feat(plugins): add nx-micronaut-gradle plugin

.commitlintrc.json

@@ -5,6 +5,7 @@
       2,
       "always",
       [
+        "plugins",
         "generators",
         "executors",
         "graph",

.github/workflows/check-plugin.yml

@@ -53,12 +53,6 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Unit tests
-        run: npm run test nx-${{ github.event.inputs.framework }}-${{ github.event.inputs.buildTool }}
-
-      - name: Build
-        run: npm run build nx-${{ github.event.inputs.framework }}-${{ github.event.inputs.buildTool }}
-
       - name: E2E tests
         run: npm run e2e nx-${{ github.event.inputs.framework }}-${{ github.event.inputs.buildTool }}-e2e
         env:

packages/common/src/lib/versions/index.ts

@@ -7,6 +7,10 @@ export const springKotlinVersion = '1.8.21';
 export const quarkusPlatformVersion = '3.0.4.Final';
 export const quarkusKotlinVersion = '1.8.10';
 
+//Micronaut
+export const micronautVersion = '4.0.0-M2';
+export const micronautKotlinVersion = '1.8.20';
+
 //Linters
 export const checkstyleVersion = '10.11.0';
 export const ktlintVersion = '0.49.1';

packages/gradle/src/executors/build-image/micronaut/executor.spec.ts

@@ -0,0 +1,40 @@
+import { ExecutorContext } from '@nx/devkit';
+import { runCommand } from '@jnxplus/common';
+import executor from './executor';
+import { BuildImageExecutorSchema } from './schema';
+jest.mock('@jnxplus/common');
+
+const options: BuildImageExecutorSchema = {
+  useDocker: true,
+  native: true,
+  optimized: true,
+};
+const context: ExecutorContext = {
+  root: '/root',
+  cwd: '/root',
+  projectName: 'my-app',
+  targetName: 'build',
+  workspace: {
+    version: 2,
+    projects: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'my-app': <any>{
+        root: 'apps/wibble',
+        sourceRoot: 'apps/wibble',
+      },
+    },
+    npmScope: 'test',
+  },
+  isVerbose: false,
+};
+
+describe('Build Image Executor', () => {
+  beforeEach(async () => {
+    (runCommand as jest.Mock).mockReturnValue({ success: true });
+  });
+
+  xit('can run', async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

packages/gradle/src/executors/build-image/micronaut/executor.ts

@@ -0,0 +1,43 @@
+import { ExecutorContext, logger } from '@nx/devkit';
+import { getExecutable, getProjectPath } from '../../../.';
+import { runCommand } from '@jnxplus/common';
+import { BuildImageExecutorSchema } from './schema';
+
+export default async function runExecutor(
+  options: BuildImageExecutorSchema,
+  context: ExecutorContext
+) {
+  logger.info(`Executor ran for Build Image: ${JSON.stringify(options)}`);
+
+  if (options.useDocker && options.native && options.optimized) {
+    return runCommand(
+      `${getExecutable()} ${getProjectPath(context)}:optimizedDockerBuildNative`
+    );
+  }
+
+  if (options.useDocker && !options.native && options.optimized) {
+    return runCommand(
+      `${getExecutable()} ${getProjectPath(context)}:optimizedDockerBuild`
+    );
+  }
+
+  if (options.useDocker && options.native && !options.optimized) {
+    return runCommand(
+      `${getExecutable()} ${getProjectPath(context)}:dockerBuildNative`
+    );
+  }
+
+  if (options.useDocker && !options.native && !options.optimized) {
+    return runCommand(
+      `${getExecutable()} ${getProjectPath(context)}:dockerBuild`
+    );
+  }
+
+  if (!options.useDocker) {
+    return runCommand(
+      `${getExecutable()} ${getProjectPath(context)}:nativeCompile`
+    );
+  }
+
+  throw new Error(`Case not handled`);
+}

packages/gradle/src/executors/build-image/micronaut/schema.d.ts

@@ -0,0 +1,5 @@
+export interface BuildImageExecutorSchema {
+  useDocker: boolean;
+  native: boolean;
+  optimized: boolean;
+}

packages/gradle/src/executors/build-image/micronaut/schema.json

@@ -0,0 +1,20 @@
+{
+  "version": 2,
+  "outputCapture": "pipe",
+  "$schema": "http://json-schema.org/schema",
+  "title": "Build Image executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "useDocker": {
+      "type": "boolean"
+    },
+    "native": {
+      "type": "boolean"
+    },
+    "optimized": {
+      "type": "boolean"
+    }
+  },
+  "required": []
+}

packages/gradle/src/executors/build/micronaut/executor.spec.ts

@@ -0,0 +1,46 @@
+import { ExecutorContext } from '@nx/devkit';
+import { runCommand } from '@jnxplus/common';
+import executor from './executor';
+import { BuildExecutorSchema } from './schema';
+jest.mock('@jnxplus/common');
+
+const options: BuildExecutorSchema = {};
+const context: ExecutorContext = {
+  root: '/root',
+  cwd: '/root',
+  projectName: 'my-app',
+  targetName: 'build',
+  workspace: {
+    version: 2,
+    projects: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'my-app': <any>{
+        root: 'apps/wibble',
+        sourceRoot: 'apps/wibble',
+      },
+    },
+    npmScope: 'test',
+  },
+  projectsConfigurations: {
+    version: 2,
+    projects: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'my-app': <any>{
+        root: 'apps/wibble',
+        sourceRoot: 'apps/wibble',
+      },
+    },
+  },
+  isVerbose: false,
+};
+
+describe('Build Executor', () => {
+  beforeEach(async () => {
+    (runCommand as jest.Mock).mockReturnValue({ success: true });
+  });
+
+  xit('can run', async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

packages/gradle/src/executors/build/micronaut/executor.ts

@@ -0,0 +1,14 @@
+import { runCommand } from '@jnxplus/common';
+import { ExecutorContext, logger } from '@nx/devkit';
+import { getExecutable, getProjectPath } from '../../../.';
+import { BuildExecutorSchema } from './schema';
+
+export default async function runExecutor(
+  options: BuildExecutorSchema,
+  context: ExecutorContext
+) {
+  logger.info(`Executor ran for Build: ${JSON.stringify(options)}`);
+  return runCommand(
+    `${getExecutable()} ${getProjectPath(context)}:build -x test`
+  );
+}

packages/gradle/src/executors/build/micronaut/schema.d.ts

@@ -0,0 +1 @@
+export interface BuildExecutorSchema {} // eslint-disable-line

packages/gradle/src/executors/build/micronaut/schema.json

@@ -0,0 +1,10 @@
+{
+  "version": 2,
+  "outputCapture": "pipe",
+  "$schema": "http://json-schema.org/schema",
+  "title": "Build executor",
+  "description": "",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

packages/gradle/src/executors/serve/micronaut/executor.spec.ts

@@ -0,0 +1,38 @@
+import { ExecutorContext } from '@nx/devkit';
+import { runCommand } from '@jnxplus/common';
+import executor from './executor';
+import { ServeExecutorSchema } from './schema';
+jest.mock('@jnxplus/common');
+
+const options: ServeExecutorSchema = {
+  args: 'args',
+};
+const context: ExecutorContext = {
+  root: '/root',
+  cwd: '/root',
+  projectName: 'my-app',
+  targetName: 'serve',
+  workspace: {
+    version: 2,
+    projects: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'my-app': <any>{
+        root: 'apps/wibble',
+        sourceRoot: 'apps/wibble',
+      },
+    },
+    npmScope: 'test',
+  },
+  isVerbose: false,
+};
+
+describe('Serve Executor', () => {
+  beforeEach(async () => {
+    (runCommand as jest.Mock).mockReturnValue({ success: true });
+  });
+
+  xit('can run', async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

packages/gradle/src/executors/serve/micronaut/executor.ts

@@ -0,0 +1,27 @@
+import { runCommand, waitForever } from '@jnxplus/common';
+import { ExecutorContext, logger } from '@nx/devkit';
+
+import { getExecutable, getProjectPath } from '../../../.';
+import { ServeExecutorSchema } from './schema';
+
+export default async function runExecutor(
+  options: ServeExecutorSchema,
+  context: ExecutorContext
+) {
+  logger.info(`Executor ran for serve: ${JSON.stringify(options)}`);
+
+  let command = `${getExecutable()} ${getProjectPath(context)}:run`;
+
+  if (options.args) {
+    command += ` --args='${options.args}'`;
+  }
+
+  const result = runCommand(command);
+
+  if (!result.success) {
+    return { success: false };
+  }
+
+  await waitForever();
+  return { success: true };
+}

packages/gradle/src/executors/serve/micronaut/schema.d.ts

@@ -0,0 +1,3 @@
+export interface ServeExecutorSchema {
+  args: string;
+}

packages/gradle/src/executors/serve/micronaut/schema.json

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "outputCapture": "pipe",
+  "$schema": "http://json-schema.org/schema",
+  "title": "Serve executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "args": {
+      "type": "string"
+    }
+  },
+  "required": []
+}

packages/nx-micronaut-gradle/.babelrc

@@ -0,0 +1,10 @@
+{
+  "presets": [
+    [
+      "@nx/js/babel",
+      {
+        "useBuiltIns": "usage"
+      }
+    ]
+  ]
+}

packages/nx-micronaut-gradle/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

packages/nx-micronaut-gradle/README.md

@@ -0,0 +1,55 @@
+# @jnxplus/nx-micronaut-gradle
+
+[![npm version](https://badge.fury.io/js/@jnxplus%2Fnx-micronaut-gradle.svg)](https://badge.fury.io/js/@jnxplus%2Fnx-micronaut-gradle)
+
+This plugin adds Spring micronaut and Gradle multi-project builds capabilities to Nx workspace.
+
+Here is a quick overview of the plugin, to know more, please visit [the documentation](https://khalilou88.github.io/jnxplus/).
+
+## Supported versions
+
+| @jnxplus/nx-micronaut-gradle | Nx     | Spring micronaut |
+| ---------------------------- | ------ | ---------------- |
+| 6.x.x                        | 16.x.x | 3.x.x            |
+| 5.x.x                        | 15.x.x | 3.x.x            |
+
+## Getting Started
+
+### 0. Prerequisites
+
+`@jnxplus/nx-micronaut-gradle` requires a Java 17 or higher Runtime Environment and the current Long Term Support (LTS) version of node.js.
+
+### 1. Install the plugin
+
+In the Nx workspace root folder, run this command to install the plugin :
+
+```bash
+npm install --save-dev @jnxplus/nx-micronaut-gradle
+```
+
+### 2. Add Spring micronaut and Gradle wrapper support
+
+The following command adds Spring micronaut and Gradle support (Gradle wrapper and config files) to the workspace. This only needs to be performed once per workspace.
+
+```bash
+nx generate @jnxplus/nx-micronaut-gradle:init
+```
+
+### 3. Usage
+
+| Action                               | Command                                                            |
+| ------------------------------------ | ------------------------------------------------------------------ |
+| Generate an application              | `nx generate @jnxplus/nx-micronaut-gradle:application my-app-name` |
+| Generate a library                   | `nx generate @jnxplus/nx-micronaut-gradle:library my-lib-name`     |
+| Build a project                      | `nx build my-project-name`                                         |
+| Serve an application                 | `nx serve my-app-name`                                             |
+| Test a project                       | `nx test my-project-name`                                          |
+| Lint a project                       | `nx lint my-project-name`                                          |
+| Format a java project                | `nx format --projects my-project-name`                             |
+| Format a kotlin project              | `nx ktformat my-project-name`                                      |
+| Run a custom task                    | `nx run-task my-project-name --task="test"`                        |
+| Visualize project's dependency graph | `nx dep-graph`                                                     |
+
+## License
+
+MIT © 2021-2023 Khalil LAGRIDA