refactor/use asyncapi headers schema

springwolf-core/build.gradle

@@ -14,7 +14,6 @@ dependencies {
     implementation "io.swagger.core.v3:swagger-core-jakarta:${swaggerVersion}"
 
     implementation "com.fasterxml.jackson.core:jackson-core:${jacksonVersion}"
-    implementation "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
     implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
 
     implementation "org.slf4j:slf4j-api:${slf4jApiVersion}"

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/ComponentsService.java

@@ -5,15 +5,14 @@
 import io.github.springwolf.asyncapi.v3.model.channel.message.MessageObject;
 import io.github.springwolf.asyncapi.v3.model.channel.message.MessageReference;
 import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
-import io.github.springwolf.core.asyncapi.components.headers.AsyncHeaders;
 
 import java.util.Map;
 
 public interface ComponentsService {
 
     Map<String, SchemaObject> getSchemas();
 
-    String registerSchema(AsyncHeaders headers);
+    String registerSchema(SchemaObject headers);
 
     String registerSchema(Class<?> type);
 

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/DefaultComponentsService.java

@@ -6,13 +6,12 @@
 import io.github.springwolf.asyncapi.v3.model.channel.message.MessageReference;
 import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
 import io.github.springwolf.core.asyncapi.annotations.AsyncApiPayload;
-import io.github.springwolf.core.asyncapi.components.headers.AsyncHeaders;
 import io.github.springwolf.core.asyncapi.components.postprocessors.SchemasPostProcessor;
 import io.github.springwolf.core.configuration.properties.SpringwolfConfigProperties;
 import io.swagger.v3.core.converter.ModelConverter;
 import io.swagger.v3.core.converter.ModelConverters;
 import io.swagger.v3.core.jackson.TypeNameResolver;
-import io.swagger.v3.oas.models.media.MapSchema;
+import io.swagger.v3.oas.models.media.ObjectSchema;
 import io.swagger.v3.oas.models.media.Schema;
 import io.swagger.v3.oas.models.media.StringSchema;
 import lombok.extern.slf4j.Slf4j;
@@ -62,18 +61,22 @@ public Map<String, SchemaObject> getSchemas() {
     }
 
     @Override
-    public String registerSchema(AsyncHeaders headers) {
-        log.debug("Registering schema for {}", headers.getSchemaName());
+    public String registerSchema(SchemaObject headers) {
+        log.debug("Registering schema for {}", headers.getTitle());
 
-        MapSchema headerSchema = new MapSchema();
-        headerSchema.setName(headers.getSchemaName());
+        ObjectSchema headerSchema = new ObjectSchema();
+        headerSchema.setName(headers.getTitle());
         headerSchema.setDescription(headers.getDescription());
-        headerSchema.properties(headers);
+        Map<String, Schema> properties = headers.getProperties().entrySet().stream()
+                .map((property) -> Map.entry(property.getKey(), (Schema<?>)
+                        swaggerSchemaUtil.mapToSwagger((SchemaObject) property.getValue())))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        headerSchema.setProperties(properties);
 
-        this.schemas.put(headers.getSchemaName(), headerSchema);
+        this.schemas.put(headers.getTitle(), headerSchema);
         postProcessSchema(headerSchema, DEFAULT_CONTENT_TYPE);
 
-        return headers.getSchemaName();
+        return headers.getTitle();
     }
 
     @Override

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/SwaggerSchemaUtil.java

@@ -141,4 +141,14 @@ public SchemaObject mapSchema(Schema value) {
 
         return builder.build();
     }
+
+    public Schema mapToSwagger(SchemaObject asyncApiSchema) {
+        Schema swaggerSchema = new Schema();
+        swaggerSchema.setType("string");
+        swaggerSchema.setDescription(asyncApiSchema.getDescription());
+        swaggerSchema.setExamples(asyncApiSchema.getExamples());
+        swaggerSchema.setEnum(asyncApiSchema.getEnumValues());
+
+        return swaggerSchema;
+    }
 }

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/headers/AsyncHeadersBuilder.java

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 package io.github.springwolf.core.asyncapi.components.headers;
 
+import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
+
 public interface AsyncHeadersBuilder {
-    AsyncHeaders buildHeaders(Class<?> payloadType);
+    SchemaObject buildHeaders(Class<?> payloadType);
 }

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/headers/AsyncHeadersNotDocumented.java

@@ -1,16 +1,28 @@
 // SPDX-License-Identifier: Apache-2.0
 package io.github.springwolf.core.asyncapi.components.headers;
 
+import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
+
+import java.util.List;
+import java.util.Map;
+
 public class AsyncHeadersNotDocumented implements AsyncHeadersBuilder {
     /**
      * Per default, if no headers are explicitly defined, {@link AsyncHeadersNotUsed#NOT_USED} is used.
      * There can be headers, but don't have to be.
      */
-    public static final AsyncHeaders NOT_DOCUMENTED =
-            new AsyncHeaders("HeadersNotDocumented", "There can be headers, but they are not explicitly documented.");
+    public static final SchemaObject NOT_DOCUMENTED = new SchemaObject();
+
+    static {
+        NOT_DOCUMENTED.setType("object");
+        NOT_DOCUMENTED.setTitle("HeadersNotDocumented");
+        NOT_DOCUMENTED.setDescription("There can be headers, but they are not explicitly documented.");
+        NOT_DOCUMENTED.setProperties(Map.of());
+        NOT_DOCUMENTED.setExamples(List.of(new Object()));
+    }
 
     @Override
-    public AsyncHeaders buildHeaders(Class<?> payloadType) {
+    public SchemaObject buildHeaders(Class<?> payloadType) {
         return NOT_DOCUMENTED;
     }
 }

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/components/headers/AsyncHeadersNotUsed.java

@@ -1,14 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 package io.github.springwolf.core.asyncapi.components.headers;
 
+import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
+
+import java.util.List;
+import java.util.Map;
+
 public class AsyncHeadersNotUsed implements AsyncHeadersBuilder {
     /**
      * Explicitly document that no headers are used.
      */
-    public static final AsyncHeaders NOT_USED = new AsyncHeaders("HeadersNotUsed", "No headers are present.");
+    public static final SchemaObject NOT_USED = new SchemaObject();
+
+    static {
+        NOT_USED.setType("object");
+        NOT_USED.setTitle("HeadersNotUsed");
+        NOT_USED.setDescription("No headers are present.");
+        NOT_USED.setProperties(Map.of());
+        NOT_USED.setExamples(List.of(new Object()));
+    }
 
     @Override
-    public AsyncHeaders buildHeaders(Class<?> payloadType) {
+    public SchemaObject buildHeaders(Class<?> payloadType) {
         return NOT_USED;
     }
 }

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/scanners/common/AsyncAnnotationScanner.java

@@ -11,10 +11,10 @@
 import io.github.springwolf.asyncapi.v3.model.operation.Operation;
 import io.github.springwolf.asyncapi.v3.model.operation.OperationAction;
 import io.github.springwolf.asyncapi.v3.model.schema.MultiFormatSchema;
+import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
 import io.github.springwolf.asyncapi.v3.model.schema.SchemaReference;
 import io.github.springwolf.core.asyncapi.annotations.AsyncOperation;
 import io.github.springwolf.core.asyncapi.components.ComponentsService;
-import io.github.springwolf.core.asyncapi.components.headers.AsyncHeaders;
 import io.github.springwolf.core.asyncapi.scanners.bindings.messages.MessageBindingProcessor;
 import io.github.springwolf.core.asyncapi.scanners.bindings.operations.OperationBindingProcessor;
 import io.github.springwolf.core.asyncapi.scanners.common.payload.PayloadClassExtractor;
@@ -92,7 +92,7 @@ protected MessageObject buildMessage(AsyncOperation operationData, Method method
 
         String modelName = this.componentsService.registerSchema(
                 payloadType, operationData.message().contentType());
-        AsyncHeaders asyncHeaders = AsyncAnnotationUtil.getAsyncHeaders(operationData, resolver);
+        SchemaObject asyncHeaders = AsyncAnnotationUtil.getAsyncHeaders(operationData, resolver);
         String headerModelName = this.componentsService.registerSchema(asyncHeaders);
         var headers = MessageHeaders.of(MessageReference.toSchema(headerModelName));
 

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/scanners/common/utils/AsyncAnnotationUtil.java

@@ -5,10 +5,9 @@
 import io.github.springwolf.asyncapi.v3.bindings.MessageBinding;
 import io.github.springwolf.asyncapi.v3.bindings.OperationBinding;
 import io.github.springwolf.asyncapi.v3.model.channel.message.MessageObject;
+import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
 import io.github.springwolf.core.asyncapi.annotations.AsyncMessage;
 import io.github.springwolf.core.asyncapi.annotations.AsyncOperation;
-import io.github.springwolf.core.asyncapi.components.headers.AsyncHeaderSchema;
-import io.github.springwolf.core.asyncapi.components.headers.AsyncHeaders;
 import io.github.springwolf.core.asyncapi.components.headers.AsyncHeadersNotDocumented;
 import io.github.springwolf.core.asyncapi.components.headers.AsyncHeadersNotUsed;
 import io.github.springwolf.core.asyncapi.scanners.bindings.channels.ChannelBindingProcessor;
@@ -21,7 +20,9 @@
 import org.springframework.util.StringValueResolver;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -32,7 +33,7 @@
 public class AsyncAnnotationUtil {
     private AsyncAnnotationUtil() {}
 
-    public static AsyncHeaders getAsyncHeaders(AsyncOperation op, StringValueResolver resolver) {
+    public static SchemaObject getAsyncHeaders(AsyncOperation op, StringValueResolver resolver) {
         if (op.headers().values().length == 0) {
             if (op.headers().notUsed()) {
                 return AsyncHeadersNotUsed.NOT_USED;
@@ -43,29 +44,29 @@ public static AsyncHeaders getAsyncHeaders(AsyncOperation op, StringValueResolve
         String headerDescription = StringUtils.hasText(op.headers().description())
                 ? resolver.resolveStringValue(op.headers().description())
                 : null;
-        AsyncHeaders asyncHeaders = new AsyncHeaders(op.headers().schemaName(), headerDescription);
+
+        SchemaObject headerSchema = new SchemaObject();
+        headerSchema.setType("object");
+        headerSchema.setTitle(op.headers().schemaName());
+        headerSchema.setDescription(headerDescription);
+        headerSchema.setProperties(new HashMap<>());
+
         Arrays.stream(op.headers().values())
                 .collect(groupingBy(AsyncOperation.Headers.Header::name))
                 .forEach((headerName, headers) -> {
+                    String propertyName = resolver.resolveStringValue(headerName);
+
+                    SchemaObject property = new SchemaObject();
+                    property.setType("string");
+                    property.setTitle(propertyName);
+                    property.setDescription(getDescription(headers, resolver));
                     List<String> values = getHeaderValues(headers, resolver);
-                    String exampleValue = values.stream().findFirst().orElse(null);
-                    asyncHeaders.addHeader(AsyncHeaderSchema.headerBuilder()
-                            .headerName(resolver.resolveStringValue(headerName))
-                            .description(getDescription(headers, resolver))
-                            .enumValue(values)
-                            .example(exampleValue)
-                            .build());
-
-                    // FIXME: Replace AsyncHeaders by proper AsyncAPI v3 Headers
-                    // MessageHeaders.of(
-                    //         SchemaObject.builder()
-                    //                 .description(getDescription(headers, resolver))
-                    //                 .enumValues(values)
-                    //                 .examples(value != null ? List.of(value) : null)
-                    //                 .build());
+                    property.setExamples(new ArrayList<>(values));
+                    property.setEnumValues(values);
+                    headerSchema.getProperties().put(propertyName, property);
                 });
 
-        return asyncHeaders;
+        return headerSchema;
     }
 
     private static List<String> getHeaderValues(

springwolf-core/src/test/java/io/github/springwolf/core/asyncapi/components/SwaggerSchemaUtilTest.java

@@ -7,6 +7,7 @@
 import io.swagger.v3.oas.models.ExternalDocumentation;
 import io.swagger.v3.oas.models.media.Discriminator;
 import io.swagger.v3.oas.models.media.ObjectSchema;
+import io.swagger.v3.oas.models.media.Schema;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
@@ -326,9 +327,7 @@ void mapAdditionalProperties() {
             SchemaObject componentSchema = swaggerSchemaUtil.mapSchema(schema);
 
             // then
-            assertThat(((ComponentSchema) componentSchema.getAdditionalProperties())
-                            .getSchema()
-                            .getType())
+            assertThat(componentSchema.getAdditionalProperties().getSchema().getType())
                     .isEqualTo(additionalProperties.getType());
         }
 
@@ -491,4 +490,46 @@ void mapMaxItems() {
             assertThat(componentSchema.getMaxItems()).isEqualTo(schema.getMaxItems());
         }
     }
+
+    @Nested
+    class MapToSwagger {
+        @Test
+        void mapDescription() {
+            // given
+            SchemaObject schema = new SchemaObject();
+            schema.setDescription("description");
+
+            // when
+            Schema componentSchema = swaggerSchemaUtil.mapToSwagger(schema);
+
+            // then
+            assertThat(componentSchema.getDescription()).isEqualTo(schema.getDescription());
+        }
+
+        @Test
+        void mapExamples() {
+            // given
+            SchemaObject schema = new SchemaObject();
+            schema.setExamples(List.of("example1", "example2"));
+
+            // when
+            Schema componentSchema = swaggerSchemaUtil.mapToSwagger(schema);
+
+            // then
+            assertThat(componentSchema.getExamples()).isEqualTo(schema.getExamples());
+        }
+
+        @Test
+        void mapEnum() {
+            // given
+            SchemaObject schema = new SchemaObject();
+            schema.setEnumValues(List.of("enum1", "enum2"));
+
+            // when
+            Schema componentSchema = swaggerSchemaUtil.mapToSwagger(schema);
+
+            // then
+            assertThat(componentSchema.getEnum()).isEqualTo(schema.getEnumValues());
+        }
+    }
 }