write @Status annotation (openapi-processor/openapi-processor-spring#339)

Author: hauner

gradle/libs.versions.toml

@@ -4,7 +4,7 @@ build-jdk = "11"
 test-jdk = "17"
 
 api = "2024.2"
-base = "2025.2"
+base = "2025.3-SNAPSHOT"
 
 junit = "5.9.3"
 jacoco = "0.8.7"

src/main/kotlin/io/openapiprocessor/micronaut/processor/MicronautFrameworkAnnotations.kt

@@ -5,8 +5,10 @@
 
 package io.openapiprocessor.micronaut.processor
 
+import io.openapiprocessor.core.converter.mapping.SimpleParameterValue
 import io.openapiprocessor.core.framework.FrameworkAnnotations
 import io.openapiprocessor.core.model.Annotation
+import io.openapiprocessor.core.model.EndpointResponseStatus
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.model.RequestBody
 import io.openapiprocessor.core.model.parameters.*
@@ -39,6 +41,19 @@ class MicronautFrameworkAnnotations: FrameworkAnnotations {
         }
     }
 
+    override fun getAnnotation(status: EndpointResponseStatus): Annotation {
+        val statusCode = HTTP_STATUS[status.statusCode]
+        if (statusCode == null) {
+            log.error("unknown http status code: ${status.statusCode}")
+            return UNKNOWN_ANNOTATION
+        }
+
+        return Annotation(
+            getAnnotationName("Status"),
+            linkedMapOf(
+                "code" to SimpleParameterValue(statusCode, HTTP_STATUS_ENUM)))
+    }
+
     private fun getAnnotation(key: String): Annotation {
         return PARAMETER_ANNOTATIONS.getValue(key)
     }
@@ -73,3 +88,83 @@ private const val ANNOTATION_PKG = "io.micronaut.http.annotation"
 private fun getAnnotationName(name: String): String {
     return "${ANNOTATION_PKG}.${name}"
 }
+
+private val HTTP_STATUS = hashMapOf(
+    "100" to getEnum("CONTINUE"),
+    "101" to getEnum("SWITCHING_PROTOCOLS"),
+    "102" to getEnum("PROCESSING"), // WebDAV
+
+    "200" to getEnum("OK"),
+    "201" to getEnum("CREATED"),
+    "202" to getEnum("ACCEPTED"),
+    "203" to getEnum("NON_AUTHORITATIVE_INFORMATION"),
+    "204" to getEnum("NO_CONTENT"),
+    "205" to getEnum("RESET_CONTENT"),
+    "206" to getEnum("PARTIAL_CONTENT"),
+    "207" to getEnum("MULTI_STATUS"), // WebDAV
+    "208" to getEnum("ALREADY_REPORTED"), // WebDAV
+    "226" to getEnum("IM_USED"),
+
+    "300" to getEnum("MULTIPLE_CHOICES"),
+    "301" to getEnum("MOVED_PERMANENTLY"),
+    "302" to getEnum("FOUND"), // replaces MOVED_TEMPORARILY
+    "303" to getEnum("SEE_OTHER"),
+    "304" to getEnum("NOT_MODIFIED"),
+    "305" to getEnum("USE_PROXY"),
+    "306" to getEnum("SWITCH_PROXY"),
+    "307" to getEnum("TEMPORARY_REDIRECT"),
+    "308" to getEnum("PERMANENT_REDIRECT"),
+
+    "400" to getEnum("BAD_REQUEST"),
+    "401" to getEnum("UNAUTHORIZED"),
+    "402" to getEnum("PAYMENT_REQUIRED"),
+    "403" to getEnum("FORBIDDEN"),
+    "404" to getEnum("NOT_FOUND"),
+    "405" to getEnum("METHOD_NOT_ALLOWED"),
+    "406" to getEnum("NOT_ACCEPTABLE"),
+    "407" to getEnum("PROXY_AUTHENTICATION_REQUIRED"),
+    "408" to getEnum("REQUEST_TIMEOUT"),
+    "409" to getEnum("CONFLICT"),
+    "410" to getEnum("GONE"),
+    "411" to getEnum("LENGTH_REQUIRED"),
+    "412" to getEnum("PRECONDITION_FAILED"),
+    "413" to getEnum("REQUEST_ENTITY_TOO_LARGE"),
+    "414" to getEnum("REQUEST_URI_TOO_LONG"),
+    "415" to getEnum("UNSUPPORTED_MEDIA_TYPE"),
+    "416" to getEnum("REQUESTED_RANGE_NOT_SATISFIABLE"),
+    "417" to getEnum("EXPECTATION_FAILED"),
+    "418" to getEnum("I_AM_A_TEAPOT"),
+    "420" to getEnum("ENHANCE_YOUR_CALM"),
+    "422" to getEnum("UNPROCESSABLE_ENTITY"), // WebDAV
+    "423" to getEnum("LOCKED"), // WebDAV
+    "424" to getEnum("FAILED_DEPENDENCY"), // WebDAV
+    "425" to getEnum("UNORDERED_COLLECTION"),
+    "426" to getEnum("UPGRADE_REQUIRED"),
+    "428" to getEnum("PRECONDITION_REQUIRED"),
+    "429" to getEnum("TOO_MANY_REQUESTS"),
+    "431" to getEnum("REQUEST_HEADER_FIELDS_TOO_LARGE"),
+    "444" to getEnum("NO_RESPONSE"),
+    "450" to getEnum("BLOCKED_BY_WINDOWS_PARENTAL_CONTROLS"),
+    "451" to getEnum("UNAVAILABLE_FOR_LEGAL_REASONS"),
+    "494" to getEnum("REQUEST_HEADER_TOO_LARGE"),
+
+    "500" to getEnum("INTERNAL_SERVER_ERROR"),
+    "501" to getEnum("NOT_IMPLEMENTED"),
+    "502" to getEnum("BAD_GATEWAY"),
+    "503" to getEnum("SERVICE_UNAVAILABLE"),
+    "504" to getEnum("GATEWAY_TIMEOUT"),
+    "505" to getEnum("HTTP_VERSION_NOT_SUPPORTED"),
+    "506" to getEnum("VARIANT_ALSO_NEGOTIATES"),
+    "507" to getEnum("INSUFFICIENT_STORAGE"), // WebDAV
+    "508" to getEnum("LOOP_DETECTED"), // WebDAV
+    "509" to getEnum("BANDWIDTH_LIMIT_EXCEEDED"),
+    "510" to getEnum("NOT_EXTENDED"),
+    "511" to getEnum("NETWORK_AUTHENTICATION_REQUIRED"),
+    "522" to getEnum("CONNECTION_TIMED_OUT")
+)
+
+private const val HTTP_STATUS_ENUM = "io.micronaut.http.HttpStatus"
+
+private fun getEnum(name: String): String {
+    return "HttpStatus.${name}"
+}

src/main/kotlin/io/openapiprocessor/micronaut/processor/MicronautProcessor.kt

@@ -16,6 +16,7 @@ import io.openapiprocessor.micronaut.Version
 import io.openapiprocessor.micronaut.writer.java.BeanValidations
 import io.openapiprocessor.micronaut.writer.java.MappingAnnotationWriter
 import io.openapiprocessor.micronaut.writer.java.ParameterAnnotationWriter
+import io.openapiprocessor.micronaut.writer.java.StatusAnnotationWriter
 import io.openapiprocessor.test.api.OpenApiProcessorTest
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -65,6 +66,7 @@ class MicronautProcessor : OpenApiProcessorTest {
                     MethodWriter(
                         options,
                         identifier,
+                        StatusAnnotationWriter(annotations),
                         MappingAnnotationWriter(),
                         ParameterAnnotationWriter(annotations),
                         beanValidations,

src/main/kotlin/io/openapiprocessor/micronaut/writer/java/StatusAnnotationWriter.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 https://github.com/openapi-processor/openapi-processor-micronaut
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.micronaut.writer.java
+
+import io.openapiprocessor.core.framework.FrameworkAnnotations
+import io.openapiprocessor.core.model.Endpoint
+import io.openapiprocessor.core.model.EndpointResponse
+import io.openapiprocessor.core.model.EndpointResponseStatus
+import java.io.Writer
+import io.openapiprocessor.core.writer.java.StatusAnnotationWriter as CoreStatusAnnotationWriter
+
+class StatusAnnotationWriter(private val annotations: FrameworkAnnotations): CoreStatusAnnotationWriter {
+
+    override fun write(
+        target: Writer,
+        endpoint: Endpoint,
+        endpointResponse: EndpointResponse
+    ) {
+        target.write(createStatusAnnotation(endpointResponse))
+    }
+
+    private fun createStatusAnnotation(status: EndpointResponseStatus): String {
+        val data = annotations.getAnnotation(status)
+        val status = data.parameters["code"]
+
+        var annotation = data.annotationName
+        annotation += "(${status!!.value})"
+        return annotation
+    }
+}

src/test/kotlin/io/openapiprocessor/micronaut/processor/MicronautFrameworkAnnotationsSpec.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 https://github.com/openapi-processor/openapi-processor-micronaut
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.micronaut.processor
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import io.openapiprocessor.core.model.EndpointResponseStatus
+import io.openapiprocessor.core.model.HttpStatus
+
+class MicronautFrameworkAnnotationsSpec : StringSpec({
+
+    class Status(override val statusCode: HttpStatus) : EndpointResponseStatus
+
+    "provides known HttpStatus annotation with specific status code import" {
+        val framework = MicronautFrameworkAnnotations()
+
+        val annotation200 = framework.getAnnotation(Status("200"))
+        annotation200.referencedImports shouldContainExactly setOf("io.micronaut.http.HttpStatus")
+        annotation200.parameters["code"]!!.value shouldBe "HttpStatus.OK"
+
+        val annotation400 = framework.getAnnotation(Status("400"))
+        annotation400.referencedImports shouldContainExactly setOf("io.micronaut.http.HttpStatus")
+        annotation400.parameters["code"]!!.value shouldBe "HttpStatus.BAD_REQUEST"
+
+        val annotation500 = framework.getAnnotation(Status("500"))
+        annotation500.referencedImports shouldContainExactly setOf("io.micronaut.http.HttpStatus")
+        annotation500.parameters["code"]!!.value shouldBe "HttpStatus.INTERNAL_SERVER_ERROR"
+    }
+})

src/test/kotlin/io/openapiprocessor/micronaut/writer/java/StatusAnnotationWriterSpec.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 https://github.com/openapi-processor/openapi-processor-micronaut
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.micronaut.writer.java
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.equals.shouldBeEqual
+import io.openapiprocessor.core.model.Endpoint
+import io.openapiprocessor.core.model.Response
+import io.openapiprocessor.core.model.datatypes.NoneDataType
+import io.openapiprocessor.core.parser.HttpMethod
+import io.openapiprocessor.micronaut.processor.MicronautFrameworkAnnotations
+import java.io.StringWriter
+
+class StatusAnnotationWriterSpec: StringSpec({
+    val writer = StatusAnnotationWriter(MicronautFrameworkAnnotations())
+    val target = StringWriter()
+
+    "write response status annotation" {
+        val ep = Endpoint(
+            "/foo",
+            HttpMethod.GET,
+            emptyList(),
+            emptyList(),
+            mapOf(
+                "204" to listOf(Response("?", NoneDataType()))
+            )
+        )
+
+        writer.write(target, ep, ep.endpointResponses.first())
+
+        target.toString() shouldBeEqual """@Status(HttpStatus.NO_CONTENT)"""
+    }
+})

src/testInt/kotlin/io/openapiprocessor/micronaut/ProcessorTestSets.kt

@@ -6,6 +6,7 @@
 package io.openapiprocessor.micronaut
 
 import io.openapiprocessor.test.*
+import io.openapiprocessor.test.test30_D_
 
 val ALL_30: List<TestParams> = listOf(
     test30_DR("bean-validation-introspected"),
@@ -15,7 +16,8 @@ val ALL_30: List<TestParams> = listOf(
     test30_D_("params-path-simple-data-types"),
     test30_DR("params-request-body"),
     test30_DR("params-request-body-multipart-mapping"),
-    test30_D_("params-simple-data-types")
+    test30_D_("params-simple-data-types"),
+    test30_D_("response-status")
 )
 
 val ALL_31: List<TestParams> = listOf(
@@ -26,5 +28,6 @@ val ALL_31: List<TestParams> = listOf(
     test31_D_("params-path-simple-data-types"),
     test31_DR("params-request-body"),
     test31_DR("params-request-body-multipart-mapping"),
-    test31_D_("params-simple-data-types")
+    test31_D_("params-simple-data-types"),
+    test31_D_("response-status")
 )

src/testInt/resources/tests/bean-validation-introspected/outputs.yaml

@@ -1,3 +1,4 @@
+prefix: generated
 items:
   - outputs/api/Api.java
-  - outputs/<model>/Foo.java
+  - outputs/model/<model>/Foo.java

src/testInt/resources/tests/bean-validation-introspected/outputs/api/Api.java

@@ -2,14 +2,17 @@
 
 import generated.model.Foo;
 import generated.support.Generated;
+import io.micronaut.http.HttpStatus;
 import io.micronaut.http.annotation.Body;
 import io.micronaut.http.annotation.Post;
+import io.micronaut.http.annotation.Status;
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
 
 @Generated(value = "openapi-processor-micronaut", version = "test")
 public interface Api {
 
+    @Status(HttpStatus.NO_CONTENT)
     @Post(uri = "/endpoint", consumes = {"application/json"})
     void postEndpoint(@Body @Valid @NotNull Foo body);