micronaut-projects · melix · Apr 2, 2024 · Mar 1, 2024
diff --git a/...onal-tests/src/test/groovy/io/micronaut/gradle/openapi/OpenApiClientWithKotlinSpec.groovy b/...onal-tests/src/test/groovy/io/micronaut/gradle/openapi/OpenApiClientWithKotlinSpec.groovy
@@ -5,7 +5,7 @@ import org.gradle.testkit.runner.TaskOutcome
 
 class OpenApiClientWithKotlinSpec extends AbstractOpenApiWithKotlinSpec {
 
-    def "can generate an kotlin OpenAPI client implementation with some properties (KAPT)"() {
+    def "can generate an kotlin OpenAPI client implementation with clientId (KAPT)"() {
         given:
         settingsFile << "rootProject.name = 'openapi-client'"
         buildFile << """
@@ -26,6 +26,7 @@ class OpenApiClientWithKotlinSpec extends AbstractOpenApiWithKotlinSpec {
                         generatedAnnotation = false
                         fluxForArrays = true
                         nameMapping = [test: "changedTest"]
+                        clientId = "my-client"
                     }
                 }
             }
@@ -55,9 +56,249 @@ class OpenApiClientWithKotlinSpec extends AbstractOpenApiWithKotlinSpec {
 
         and:
         file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client("my-client")') }
+                .size() == 1
     }
 
-    def "can generate an kotlin OpenAPI client implementation with some properties (KSP)"() {
+    def "can generate an kotlin OpenAPI client implementation with clientId and clientPath (KAPT)"() {
+        given:
+        settingsFile << "rootProject.name = 'openapi-client'"
+        buildFile << """
+            plugins {
+                id "io.micronaut.minimal.application"
+                id "io.micronaut.openapi"
+                id "org.jetbrains.kotlin.jvm" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.plugin.allopen" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.kapt" version "$kotlinVersion"
+            }
+
+            micronaut {
+                version "$micronautVersion"
+                openapi {
+                    client(file("petstore.json")) {
+                        lang = "kotlin"
+                        useReactive = true
+                        generatedAnnotation = false
+                        fluxForArrays = true
+                        nameMapping = [test: "changedTest"]
+                        clientId = "my-client"
+                        clientPath = true
+                    }
+                }
+            }
+
+            $repositoriesBlock
+
+            dependencies {
+
+                kapt "io.micronaut.serde:micronaut-serde-processor"
+
+                implementation "io.micronaut.serde:micronaut-serde-jackson"
+                implementation "io.micronaut.reactor:micronaut-reactor"
+                implementation "io.micronaut:micronaut-inject-kotlin"
+            }
+
+        """
+
+        withPetstore()
+
+        when:
+        def result = build('test')
+
+        then:
+        result.task(":generateClientOpenApiApis").outcome == TaskOutcome.SUCCESS
+        result.task(":generateClientOpenApiModels").outcome == TaskOutcome.SUCCESS
+        result.task(":compileKotlin").outcome == TaskOutcome.SUCCESS
+
+        and:
+        file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client(id = "my-client", path = "\\${my-client.base-path}")') }
+                .size() == 1
+    }
+
+    def "can generate an kotlin OpenAPI client implementation without clientId (KAPT)"() {
+        given:
+        settingsFile << "rootProject.name = 'openapi-client'"
+        buildFile << """
+            plugins {
+                id "io.micronaut.minimal.application"
+                id "io.micronaut.openapi"
+                id "org.jetbrains.kotlin.jvm" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.plugin.allopen" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.kapt" version "$kotlinVersion"
+            }
+
+            micronaut {
+                version "$micronautVersion"
+                openapi {
+                    client(file("petstore.json")) {
+                        lang = "kotlin"
+                        useReactive = true
+                        generatedAnnotation = false
+                        fluxForArrays = true
+                        nameMapping = [test: "changedTest"]
+                    }
+                }
+            }
+
+            $repositoriesBlock
+
+            dependencies {
+
+                kapt "io.micronaut.serde:micronaut-serde-processor"
+
+                implementation "io.micronaut.serde:micronaut-serde-jackson"
+                implementation "io.micronaut.reactor:micronaut-reactor"
+                implementation "io.micronaut:micronaut-inject-kotlin"
+            }
+
+        """
+
+        withPetstore()
+
+        when:
+        def result = build('test')
+
+        then:
+        result.task(":generateClientOpenApiApis").outcome == TaskOutcome.SUCCESS
+        result.task(":generateClientOpenApiModels").outcome == TaskOutcome.SUCCESS
+        result.task(":compileKotlin").outcome == TaskOutcome.SUCCESS
+
+        and:
+        file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client("\\${openapi-micronaut-client.base-path}")') }
+                .size() == 1
+    }
+
+    def "can generate an kotlin OpenAPI client implementation with clientId (KSP)"() {
+        given:
+        settingsFile << "rootProject.name = 'openapi-client'"
+        buildFile << """
+            plugins {
+                id "io.micronaut.minimal.application"
+                id "io.micronaut.openapi"
+                id "org.jetbrains.kotlin.jvm" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.plugin.allopen" version "$kotlinVersion"
+                id "com.google.devtools.ksp" version "$kspVersion"
+            }
+
+            micronaut {
+                version "$micronautVersion"
+                openapi {
+                    client(file("petstore.json")) {
+                        lang = "kotlin"
+                        useReactive = true
+                        generatedAnnotation = false
+                        fluxForArrays = true
+                        ksp = true
+                        nameMapping = [test: "changedTest"]
+                        clientId = "my-client"
+                    }
+                }
+            }
+
+            $repositoriesBlock
+
+            dependencies {
+
+                ksp "io.micronaut.serde:micronaut-serde-processor"
+
+                implementation "io.micronaut.serde:micronaut-serde-jackson"
+                implementation "io.micronaut.reactor:micronaut-reactor"
+                implementation "io.micronaut:micronaut-inject-kotlin"
+            }
+
+        """
+
+        withPetstore()
+
+        when:
+        def result = build('test')
+
+        then:
+        result.task(":generateClientOpenApiApis").outcome == TaskOutcome.SUCCESS
+        result.task(":generateClientOpenApiModels").outcome == TaskOutcome.SUCCESS
+        result.task(":compileKotlin").outcome == TaskOutcome.SUCCESS
+
+        and:
+        file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client("my-client")') }
+                .size() == 1
+    }
+
+    def "can generate an kotlin OpenAPI client implementation with clientId and clientPath (KSP)"() {
+        given:
+        settingsFile << "rootProject.name = 'openapi-client'"
+        buildFile << """
+            plugins {
+                id "io.micronaut.minimal.application"
+                id "io.micronaut.openapi"
+                id "org.jetbrains.kotlin.jvm" version "$kotlinVersion"
+                id "org.jetbrains.kotlin.plugin.allopen" version "$kotlinVersion"
+                id "com.google.devtools.ksp" version "$kspVersion"
+            }
+
+            micronaut {
+                version "$micronautVersion"
+                openapi {
+                    client(file("petstore.json")) {
+                        lang = "kotlin"
+                        useReactive = true
+                        generatedAnnotation = false
+                        fluxForArrays = true
+                        ksp = true
+                        nameMapping = [test: "changedTest"]
+                        clientId = "my-client"
+                        clientPath = true
+                    }
+                }
+            }
+
+            $repositoriesBlock
+
+            dependencies {
+
+                ksp "io.micronaut.serde:micronaut-serde-processor"
+
+                implementation "io.micronaut.serde:micronaut-serde-jackson"
+                implementation "io.micronaut.reactor:micronaut-reactor"
+                implementation "io.micronaut:micronaut-inject-kotlin"
+            }
+
+        """
+
+        withPetstore()
+
+        when:
+        def result = build('test')
+
+        then:
+        result.task(":generateClientOpenApiApis").outcome == TaskOutcome.SUCCESS
+        result.task(":generateClientOpenApiModels").outcome == TaskOutcome.SUCCESS
+        result.task(":compileKotlin").outcome == TaskOutcome.SUCCESS
+
+        and:
+        file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client(id = "my-client", path = "\\${my-client.base-path}")') }
+                .size() == 1
+    }
+
+    def "can generate an kotlin OpenAPI client implementation without clientId (KSP)"() {
         given:
         settingsFile << "rootProject.name = 'openapi-client'"
         buildFile << """
@@ -108,5 +349,10 @@ class OpenApiClientWithKotlinSpec extends AbstractOpenApiWithKotlinSpec {
 
         and:
         file("build/generated/openapi/generateClientOpenApiModels/src/main/kotlin/io/micronaut/openapi/model/Pet.kt").exists()
+        def petApiFile = file("build/generated/openapi/generateClientOpenApiApis/src/main/kotlin/io/micronaut/openapi/api/PetApi.kt")
+        petApiFile.exists()
+        petApiFile.readLines()
+                .findAll { it.contains('@Client("\\${openapi-micronaut-client.base-path}")') }
+                .size() == 1
     }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -16,7 +16,7 @@ tomlj = "1.1.1"
 micronaut-platform = "4.3.3" # This is the platform version, used in our tests
 micronaut-aot = "2.2.0"
 micronaut-testresources = "2.3.3"
-micronaut-openapi = "6.6.3"
+micronaut-openapi = "6.7.0"
 
 [libraries]
 # Core

diff --git a/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/DefaultOpenApiExtension.java b/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/DefaultOpenApiExtension.java
@@ -29,6 +29,7 @@
 import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
+import org.openapitools.codegen.CodegenConstants;
 
 import javax.inject.Inject;
 import java.io.File;
@@ -81,14 +82,14 @@ public void server(String name, Provider<RegularFile> definition, Action<? super
                 task.getAot().set(serverSpec.getAot());
                 task.setDescription("Generates OpenAPI controllers from an OpenAPI definition");
                 configureServerTask(serverSpec, task);
-                task.getOutputKinds().addAll("APIS", "SUPPORTING_FILES");
+                task.getOutputKinds().addAll(CodegenConstants.APIS, CodegenConstants.SUPPORTING_FILES);
             });
             var models = project.getTasks().register(generateModelsTaskName(name), OpenApiServerGenerator.class, task -> {
                 configureCommonProperties(name, task, serverSpec, definition);
                 task.getAot().set(serverSpec.getAot());
                 task.setDescription("Generates OpenAPI models from an OpenAPI definition");
                 configureServerTask(serverSpec, task);
-                task.getOutputKinds().add("MODELS");
+                task.getOutputKinds().add(CodegenConstants.MODELS);
             });
             withJavaSourceSets(sourceSets -> {
                 var javaMain = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getJava();
@@ -207,13 +208,13 @@ public void client(String name, Provider<RegularFile> definition, Action<? super
                 configureCommonProperties(name, task, clientSpec, definition);
                 task.setDescription("Generates OpenAPI client from an OpenAPI definition");
                 configureClientTask(clientSpec, task);
-                task.getOutputKinds().add("APIS");
+                task.getOutputKinds().add(CodegenConstants.APIS);
             });
             var models = project.getTasks().register(generateModelsTaskName(name), OpenApiClientGenerator.class, task -> {
                 configureCommonProperties(name, task, clientSpec, definition);
                 task.setDescription("Generates OpenAPI client models from an OpenAPI definition");
                 configureClientTask(clientSpec, task);
-                task.getOutputKinds().add("MODELS");
+                task.getOutputKinds().add(CodegenConstants.MODELS);
             });
             withJavaSourceSets(sourceSets -> {
                 var javaMain = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getJava();
@@ -260,6 +261,7 @@ private static Provider<Directory> mainSrcDir(AbstractOpenApiGenerator<?, ?> t)
 
     private static void configureClientTask(OpenApiClientSpec clientSpec, OpenApiClientGenerator task) {
         task.getClientId().convention(clientSpec.getClientId());
+        task.getClientPath().convention(clientSpec.getClientPath());
         task.getAdditionalClientTypeAnnotations().set(clientSpec.getAdditionalClientTypeAnnotations());
         task.getBasePathSeparator().convention(clientSpec.getBasePathSeparator());
         task.getAuthorizationFilterPattern().convention(clientSpec.getAuthorizationFilterPattern());

diff --git a/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/OpenApiClientSpec.java b/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/OpenApiClientSpec.java
@@ -22,6 +22,8 @@ public interface OpenApiClientSpec extends OpenApiSpec {
 
     Property<String> getClientId();
 
+    Property<Boolean> getClientPath();
+
     Property<Boolean> getUseAuth();
 
     Property<String> getAuthorizationFilterPattern();

diff --git a/...api-plugin/src/main/java/io/micronaut/gradle/openapi/tasks/AbstractOpenApiWorkAction.java b/...api-plugin/src/main/java/io/micronaut/gradle/openapi/tasks/AbstractOpenApiWorkAction.java
@@ -118,7 +118,7 @@ public void execute() {
                 .withOutputs(
                         parameters.getOutputKinds().get()
                                 .stream()
-                                .map(s -> MicronautCodeGeneratorEntryPoint.OutputKind.valueOf(s.toUpperCase(Locale.US)))
+                                .map(MicronautCodeGeneratorEntryPoint.OutputKind::of)
                                 .toArray(MicronautCodeGeneratorEntryPoint.OutputKind[]::new)
                 )
                 .withOptions(options -> options.withInvokerPackage(parameters.getInvokerPackageName().get())

diff --git a/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/tasks/OpenApiClientGenerator.java b/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/tasks/OpenApiClientGenerator.java
@@ -28,6 +28,10 @@ public abstract class OpenApiClientGenerator extends AbstractOpenApiGenerator<Op
     @Optional
     public abstract Property<String> getClientId();
 
+    @Input
+    @Optional
+    public abstract Property<Boolean> getClientPath();
+
     @Input
     public abstract Property<Boolean> getUseAuth();
 
@@ -50,6 +54,7 @@ protected Class<OpenApiClientWorkAction> getWorkerAction() {
     @Override
     protected void configureWorkerParameters(OpenApiClientWorkAction.ClientParameters params) {
         params.getClientId().set(getClientId());
+        params.getClientPath().set(getClientPath());
         params.getUseAuth().set(getUseAuth());
         params.getAuthorizationFilterPattern().set(getAuthorizationFilterPattern());
         params.getBasePathSeparator().set(getBasePathSeparator());