feat: update Java Micronaut generator to support Micronaut 3

- fix useBeanValidation option application
- add support for choosing Reactive Streams implementation for generated
  code through library option
- remove @controller annotation from generated interfaces, as it is not
  @inherited anyway
- use jakarta inject implementation instead of javax, as Micronaut now
  uses it by default
- generate stub controllers when skipSupportFiles is disabled to be able
  to run tests and start generated application
- fix bean validation annotations
- add cookies parameters support
- use @Body instead of @QueryValue for form parameters generation
- update pom.xml to use Micronaut 3

Author: Paullo612

src/main/java/io/swagger/codegen/v3/generators/java/MicronautCodegen.java

@@ -1,5 +1,6 @@
 package io.swagger.codegen.v3.generators.java;
 
+import com.github.jknack.handlebars.Handlebars;
 import com.github.jknack.handlebars.Lambda;
 import com.google.common.collect.ImmutableMap;
 import io.swagger.codegen.v3.*;
@@ -30,10 +31,17 @@
 public class MicronautCodegen extends AbstractJavaCodegen implements BeanValidationFeatures, OptionalFeatures {
 
     private static Logger LOGGER = LoggerFactory.getLogger(MicronautCodegen.class);
+    private static final String DEFAULT_LIBRARY = "rxjava2";
+    private static final String RXJAVA3_LIBRARY = "rxjava3";
+    private static final String REACTOR_LIBRARY = "reactor";
     private static final String TITLE = "title";
     private static final String CONFIG_PACKAGE = "configPackage";
     private static final String BASE_PACKAGE = "basePackage";
     private static final String USE_TAGS = "useTags";
+    private static final String USE_RXJAVA = "useRxJava";
+    private static final String USE_RXJAVA2 = "useRxJava2";
+    private static final String USE_RXJAVA3 = "useRxJava3";
+    private static final String USE_REACTOR = "useReactor";
     private static final String IMPLICIT_HEADERS = "implicitHeaders";
     private static final String SKIP_SUPPORT_FILES = "skipSupportFiles";
 
@@ -69,12 +77,18 @@ private void init() {
         cliOptions.add(new CliOption(BASE_PACKAGE, "base package (invokerPackage) for generated code"));
         cliOptions.add(new CliOption(SKIP_SUPPORT_FILES, "skip support files such as pom.xml, mvnw, etc from code generation."));
         cliOptions.add(CliOption.newBoolean(USE_TAGS, "use tags for creating interface and controller classnames"));
-        cliOptions.add(CliOption.newBoolean(USE_BEANVALIDATION, "Use BeanValidation API annotations"));
+
+        CliOption useBeanValidation = CliOption.newBoolean(USE_BEANVALIDATION, "Use BeanValidation API annotations");
+        useBeanValidation.setDefault("true");
+        cliOptions.add(useBeanValidation);
+
         cliOptions.add(CliOption.newBoolean(IMPLICIT_HEADERS, "Use of @ApiImplicitParams for headers."));
         cliOptions.add(CliOption.newBoolean(USE_OPTIONAL,
                 "Use Optional container for optional parameters"));
 
-        supportedLibraries.put(DEFAULT_LIBRARY, "Java Micronaut Server application.");
+        supportedLibraries.put(DEFAULT_LIBRARY, "Java Micronaut Server application with RxJava2 reactive streams implementation");
+        supportedLibraries.put(RXJAVA3_LIBRARY, "Java Micronaut Server application with RxJava3 reactive streams implementation");
+        supportedLibraries.put(REACTOR_LIBRARY, "Java Micronaut Server application with Project Reactor reactive streams implementation");
         setLibrary(DEFAULT_LIBRARY);
 
         CliOption library = new CliOption(CodegenConstants.LIBRARY, "library template (sub-template) to use");
@@ -155,17 +169,18 @@ public void processOpts() {
             skipSupportFiles = Boolean.valueOf(additionalProperties.get(SKIP_SUPPORT_FILES).toString());
         }
 
-        if (useBeanValidation) {
-            writePropertyBack(USE_BEANVALIDATION, useBeanValidation);
-        }
+        writePropertyBack(USE_BEANVALIDATION, useBeanValidation);
 
         if (additionalProperties.containsKey(IMPLICIT_HEADERS)) {
             this.setImplicitHeaders(Boolean.valueOf(additionalProperties.get(IMPLICIT_HEADERS).toString()));
         }
 
-        if (useOptional) {
-            writePropertyBack(USE_OPTIONAL, useOptional);
-        }
+        writePropertyBack(USE_OPTIONAL, useOptional);
+
+        additionalProperties.put(USE_RXJAVA, isRxJava2Library() || isRxJava3Library());
+        additionalProperties.put(USE_RXJAVA2, isRxJava2Library());
+        additionalProperties.put(USE_RXJAVA3, isRxJava3Library());
+        additionalProperties.put(USE_REACTOR, isReactorLibrary());
 
         if (!skipSupportFiles) {
             supportingFiles.add(new SupportingFile("pom.mustache", "", "pom.xml"));
@@ -175,6 +190,7 @@ public void processOpts() {
             supportingFiles.add(new SupportingFile("unsupportedOperationExceptionHandler.mustache",
                 (sourceFolder + File.separator + configPackage).replace(".", File.separator), "UnsupportedOperationExceptionHandler.java"));
             supportingFiles.add(new SupportingFile("mainApplication.mustache", (sourceFolder + File.separator).replace(".", File.separator), "MainApplication.java"));
+            apiTemplateFiles.put("apiController.mustache", "Controller.java");
         }
         addHandlebarsLambdas(additionalProperties);
     }
@@ -529,4 +545,22 @@ public void setUseBeanValidation(boolean useBeanValidation) {
     public void setUseOptional(boolean useOptional) {
         this.useOptional = useOptional;
     }
+
+    @Override
+    public void addHandlebarHelpers(Handlebars handlebars) {
+        handlebars.setInfiniteLoops(true);
+        super.addHandlebarHelpers(handlebars);
+    }
+
+    private boolean isRxJava2Library() {
+        return library.equals(DEFAULT_LIBRARY);
+    }
+
+    private boolean isRxJava3Library() {
+        return library.equals(RXJAVA3_LIBRARY);
+    }
+
+    private boolean isReactorLibrary() {
+        return library.equals(REACTOR_LIBRARY);
+    }
 }

src/main/resources/handlebars/JavaMicronaut/api.mustache

@@ -10,11 +10,18 @@ package {{package}};
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.micronaut.http.*;
 import io.micronaut.http.annotation.*;
+{{#useRxJava2}}
 import io.reactivex.Single;
+{{/useRxJava2}}
+{{#useRxJava3}}
+import io.reactivex.rxjava3.core.Single;
+{{/useRxJava3}}
 import io.swagger.v3.oas.annotations.*;
 import io.swagger.v3.oas.annotations.responses.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+{{#useReactor}}
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Mono;
+{{/useReactor}}
 
 {{#useBeanValidation}}
 import javax.annotation.Nullable;
@@ -24,11 +31,12 @@ import javax.validation.constraints.*;
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
+{{#useOptional}}
 import java.util.Optional;
+{{/useOptional}}
 
 {{>generatedAnnotation}}
 {{#operations}}
-@Controller
 public interface {{classname}} {
 
 {{#operation}}
@@ -46,8 +54,8 @@ public interface {{classname}} {
     })
     {{/implicitHeaders}}
     @{{#lambda.capitalise}}{{httpMethod}}{{/lambda.capitalise}}(value = "{{{path}}}"{{#hasProduces}}, produces = { {{#produces}}"{{{mediaType}}}"{{#hasMore}}, {{/hasMore}}{{/produces}} }{{/hasProduces}}{{#hasConsumes}}, consumes = {{braces "left"}}{{#consumes}}"{{{mediaType}}}"{{#hasMore}}, {{/hasMore}}{{/consumes}}{{braces "right"}}{{/hasConsumes}})
-    default Single<HttpResponse<{{>returnTypes}}>> {{operationId}}({{#parameters}}{{>queryParams}}{{>pathParams}}{{>headerParams}}{{>bodyParams}}{{>formParams}}{{#hasMore}},{{/hasMore}}{{/parameters}}) {
-        return Single.fromCallable(() -> {
+    default {{>publisher}}<HttpResponse<{{>returnTypes}}>> {{operationId}}({{#parameters}}{{>queryParams}}{{>pathParams}}{{>headerParams}}{{>cookieParams}}{{>bodyParams}}{{>formParams}}{{#hasMore}},{{/hasMore}}{{/parameters}}) {
+        return {{#useRxJava}}Single{{/useRxJava}}{{#useReactor}}Mono{{/useReactor}}.fromCallable(() -> {
             throw new UnsupportedOperationException();
         });
     }

src/main/resources/handlebars/JavaMicronaut/apiController.mustache

@@ -0,0 +1,53 @@
+package {{package}};
+
+{{#imports}}
+import {{import}};
+
+{{/imports}}
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.HttpResponse;
+{{#useRxJava2}}
+import io.reactivex.Single;
+{{/useRxJava2}}
+{{#useRxJava3}}
+import io.reactivex.rxjava3.core.Single;
+{{/useRxJava3}}
+{{#useReactor}}
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Mono;
+{{/useReactor}}
+
+{{#useBeanValidation}}
+import javax.annotation.Nullable;
+import javax.validation.Valid;
+import javax.validation.constraints.*;
+{{/useBeanValidation}}
+import java.util.List;
+import java.util.Map;
+{{#useOptional}}
+import java.util.Optional;
+{{/useOptional}}
+
+{{#operations}}
+@Controller
+public class {{classname}}Controller implements {{classname}} {
+{{#operation}}
+{{#contents}}
+
+    @Override
+    public {{>publisher}}<HttpResponse<{{>returnTypes}}>> {{operationId}}({{#parameters}}{{#useBeanValidation}}{{!
+    Bean validation spec for path parameters (PathParam is always required)
+}}{{#isPathParam}}{{>beanValidationParams}}{{/isPathParam}}{{!
+    Bean validation spec for any other parameters
+}}{{^isPathParam}}{{>nullableBeanValidationParams}}{{/isPathParam}}{{/useBeanValidation}}{{!
+    Method argument type and name
+}}{{>optionalDataType}} {{paramName}}{{!
+    Arguments separator, if required
+}}{{#hasMore}}, {{/hasMore}}{{/parameters}}) {
+        // TODO: Implement me
+        return {{classname}}.super.{{operationId}}({{#parameters}}{{paramName}}{{#hasMore}}, {{/hasMore}}{{/parameters}});
+    }
+{{/contents}}
+{{/operation}}
+}
+{{/operations}}

src/main/resources/handlebars/JavaMicronaut/api_test.mustache

@@ -5,10 +5,13 @@ package {{package}};
 
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.HttpStatus;
-import io.micronaut.test.annotation.MicronautTest;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
 import org.junit.jupiter.api.Test;
+{{#useReactor}}
+import reactor.core.publisher.Mono;
+{{/useReactor}}
 
-import javax.inject.Inject;
+import jakarta.inject.Inject;
 
 import java.util.*;
 
@@ -29,7 +32,13 @@ class {{classname}}ControllerTest {
         {{{dataType}}} {{paramName}} = {{{example}}};
         {{/parameters}}
         try {
-            api.{{operationId}}({{#parameters}}{{paramName}}{{#hasMore}}, {{/hasMore}}{{/parameters}}).blockingGet();
+            {{#useReactor}}Mono.from({{/useReactor}}api.{{operationId}}({{#parameters}}{{paramName}}{{#hasMore}}, {{/hasMore}}{{/parameters}}){{#useReactor}}){{/useReactor}}
+{{#useRxJava}}
+                    .blockingGet();
+{{/useRxJava}}
+{{#useReactor}}
+                    .block();
+{{/useReactor}}
         } catch (UnsupportedOperationException e) {
             assumeTrue(false, "API is not yet implemented");
         }

src/main/resources/handlebars/JavaMicronaut/beanValidation.mustache

@@ -3,4 +3,4 @@
 {{/required}}{{#isContainer}}{{^isPrimitiveType}}{{^isEnum}}
   @Valid{{/isEnum}}{{/isPrimitiveType}}{{/isContainer}}{{#isNotContainer}}{{^isPrimitiveType}}
   @Valid{{/isPrimitiveType}}{{/isNotContainer}}
-{{>beanValidationCore}}
+{{>beanValidationCore}}

src/main/resources/handlebars/JavaMicronaut/beanValidationHeaderParams.mustache

@@ -0,0 +1 @@
+{{#useBeanValidation}}{{>beanValidationParamsInner}}{{>beanValidationCore}}{{/useBeanValidation}}

src/main/resources/handlebars/JavaMicronaut/beanValidationParams.mustache

@@ -0,0 +1,5 @@
+{{^isPrimitiveType}}{{^isEnum}}{{!
+    Non-container
+}}{{^isContainer}}@Valid {{/isContainer}}{{!
+    Container
+}}{{#isContainer}}{{#items}}{{>beanValidationParamsInner}}{{/items}}{{/isContainer}}{{/isEnum}}{{/isPrimitiveType}}