chore(core): move wrapper logic for MultiFormatSchema to MultiFormatSchema, change back public api method from registerSimpleSchema to registerSchema to prevent breaking change, rename SwaggerSchemaService.postProcessSimpleSchema to postProcessSchemaWithoutRef to clarify the intention of the method

Co-authored-by: Timon Back <timonback@users.noreply.github.com>

Author: sam0r040

springwolf-asyncapi/src/main/java/io/github/springwolf/asyncapi/v3/model/schema/MultiFormatSchema.java

@@ -49,4 +49,12 @@ public class MultiFormatSchema extends ExtendableObject {
      */
     @JsonProperty(value = "schema")
     private Object schema;
+
+    public static MultiFormatSchema of(Object schema) {
+        // if payloadSchema.payload is already an instance of MultiFormatSchema, do not wrap again.
+        return (schema instanceof MultiFormatSchema mfs)
+                ? mfs
+                : MultiFormatSchema.builder().schema(schema).build();
+
+    }
 }

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

@@ -41,10 +41,10 @@ public interface ComponentsService {
 
     /**
      * registers the given schema with this {@link ComponentsService}
-     * @param headers the schema to register, typically a header schema
+     * @param schemaWithoutRef the schema to register, typically a header schema
      * @return the title attribute of the given schema
      */
-    String registerSimpleSchema(SchemaObject headers);
+    String registerSchema(SchemaObject schemaWithoutRef);
 
     /**
      * Provides a map of all registered messages.

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

@@ -8,8 +8,8 @@
 import io.github.springwolf.asyncapi.v3.model.schema.SchemaFormat;
 import io.github.springwolf.asyncapi.v3.model.schema.SchemaObject;
 import io.github.springwolf.core.asyncapi.schemas.SwaggerSchemaService;
-import io.github.springwolf.core.configuration.properties.PayloadSchemaFormat;
 import io.github.springwolf.core.configuration.properties.SpringwolfConfigProperties;
+import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 import java.lang.reflect.Type;
@@ -23,10 +23,11 @@
  * in the resulting AsyncApi object.
  */
 @Slf4j
+@AllArgsConstructor
 public class DefaultComponentsService implements ComponentsService {
 
     private final SwaggerSchemaService schemaService;
-    private final SchemaFormat payloadSchemaFormat;
+    private final SpringwolfConfigProperties springwolfConfigProperties;
 
     /**
      * maps a schema name (key) to a detected corresponding {@link ComponentSchema}.
@@ -35,15 +36,6 @@ public class DefaultComponentsService implements ComponentsService {
 
     private final Map<String, Message> messages = new HashMap<>();
 
-    public DefaultComponentsService(
-            SwaggerSchemaService schemaService, SpringwolfConfigProperties springwolfConfigProperties) {
-        this.schemaService = schemaService;
-
-        PayloadSchemaFormat payloadSchemaFormat =
-                springwolfConfigProperties.getDocket().getPayloadSchemaFormat();
-        this.payloadSchemaFormat = payloadSchemaFormat.getSchemaFormat();
-    }
-
     /**
      * Provides a map of all registered schemas.
      *
@@ -64,7 +56,8 @@ public Map<String, ComponentSchema> getSchemas() {
      */
     @Override
     public ComponentSchema resolvePayloadSchema(Type type, String contentType) {
-
+        SchemaFormat payloadSchemaFormat =
+                springwolfConfigProperties.getDocket().getPayloadSchemaFormat().getSchemaFormat();
         SwaggerSchemaService.ExtractedSchemas payload =
                 schemaService.resolveSchema(type, contentType, payloadSchemaFormat);
         payload.referencedSchemas().forEach(schemas::putIfAbsent);
@@ -75,21 +68,21 @@ public ComponentSchema resolvePayloadSchema(Type type, String contentType) {
      * registers the given schema with this {@link ComponentsService}.
      * <p>NOTE</p>
      * Use only with schemas with max. one level of properties. Providing {@link SchemaObject}s with deep
-     * property hierarchy will result in an corrupted result.
+     * property hierarchy will result in a corrupted result.
      * <br/>
      * A typical usecase for this method is registering of header schemas, which have typically a simple structure.
      *
-     * @param headers the schema to register, typically a header schema
+     * @param schemaWithoutRef the schema to register, typically a header schema
      * @return the title attribute of the given schema
      */
     @Override
-    public String registerSimpleSchema(SchemaObject headers) {
-        log.debug("Registering schema for {}", headers.getTitle());
+    public String registerSchema(SchemaObject schemaWithoutRef) {
+        log.debug("Registering schema for {}", schemaWithoutRef.getTitle());
 
-        ComponentSchema processedSchema = schemaService.postProcessSimpleSchema(headers);
-        this.schemas.putIfAbsent(headers.getTitle(), processedSchema);
+        ComponentSchema processedSchema = schemaService.postProcessSchemaWithoutRef(schemaWithoutRef);
+        this.schemas.putIfAbsent(schemaWithoutRef.getTitle(), processedSchema);
 
-        return headers.getTitle();
+        return schemaWithoutRef.getTitle();
     }
 
     /**

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

@@ -37,17 +37,13 @@ public MessageObject buildMessage(AsyncOperation operationData, Method method) {
         PayloadSchemaObject payloadSchema = payloadAsyncOperationService.extractSchema(operationData, method);
 
         SchemaObject headerSchema = AsyncAnnotationUtil.getAsyncHeaders(operationData, stringValueResolver);
-        String headerSchemaName = this.componentsService.registerSimpleSchema(headerSchema);
+        String headerSchemaName = this.componentsService.registerSchema(headerSchema);
 
         Map<String, MessageBinding> messageBinding =
                 AsyncAnnotationUtil.processMessageBindingFromAnnotation(method, messageBindingProcessors);
 
-        // if payloadSchema.payload is already an instance of MultiFormatSchema, do not wrap again.
-        MultiFormatSchema multiFormatSchema = (payloadSchema.payload() instanceof MultiFormatSchema mfs)
-                ? mfs
-                : MultiFormatSchema.builder().schema(payloadSchema.payload()).build();
-
-        var messagePayload = MessagePayload.of(multiFormatSchema);
+        MultiFormatSchema multiFormatSchema = MultiFormatSchema.of(payloadSchema.payload());
+        MessagePayload messagePayload = MessagePayload.of(multiFormatSchema);
 
         var builder = MessageObject.builder()
                 .messageId(payloadSchema.name())

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

@@ -31,7 +31,7 @@ public MessageObject buildMessage(
             MethodAnnotation annotation, PayloadSchemaObject payloadSchema, SchemaObject headers) {
         SchemaObject headerSchema = asyncHeadersBuilder.buildHeaders(payloadSchema);
         SchemaObject mergedHeaderSchema = HeaderSchemaObjectMerger.merge(headerSchema, headers);
-        String headerModelName = componentsService.registerSimpleSchema(mergedHeaderSchema);
+        String headerModelName = componentsService.registerSchema(mergedHeaderSchema);
 
         Map<String, MessageBinding> messageBinding = bindingFactory.buildMessageBinding(annotation, mergedHeaderSchema);
 

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

@@ -62,7 +62,7 @@ private MessageObject buildMessage(ClassAnnotation classAnnotation, Method metho
         SchemaObject headerSchema = asyncHeadersBuilder.buildHeaders(payloadSchema);
         SchemaObject headers = headerClassExtractor.extractHeader(method, payloadSchema);
         SchemaObject mergedHeaderSchema = HeaderSchemaObjectMerger.merge(headerSchema, headers);
-        String headerSchemaName = componentsService.registerSimpleSchema(mergedHeaderSchema);
+        String headerSchemaName = componentsService.registerSchema(mergedHeaderSchema);
 
         Map<String, MessageBinding> messageBinding = bindingFactory.buildMessageBinding(classAnnotation, headerSchema);
 

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/scanners/common/payload/internal/PayloadService.java

@@ -55,7 +55,7 @@ public PayloadSchemaObject buildSchema(String contentType, Type payloadType) {
     public PayloadSchemaObject useUnusedPayload() {
         ComponentSchema schema = PAYLOAD_NOT_USED.schema();
         if (schema != null && schema.getSchema() != null) {
-            this.componentsService.registerSimpleSchema(schema.getSchema());
+            this.componentsService.registerSchema(schema.getSchema());
         }
         return PAYLOAD_NOT_USED;
     }

springwolf-core/src/main/java/io/github/springwolf/core/asyncapi/schemas/SwaggerSchemaService.java

@@ -64,27 +64,27 @@ public record ExtractedSchemas(ComponentSchema rootSchema, Map<String, Component
      * postprocessors and converts the result back to a {@link SchemaObject}
      * <p>NOTE</p>
      * The conversion between the AsyncApi {@link SchemaObject} and Swagger schema instance is not a 'full conversion'. Only
-     * root attributes of the schema an the first level of properties a converted. Providing {@link SchemaObject}s with deep
-     * property hierarchy will result in an corrupted result.
+     * root attributes of the schema and the first level of properties are converted. Providing {@link SchemaObject}s with deep
+     * property hierarchy will result in a corrupted result.
      * <br/>
      * A typical usecase for this method is postprocessing of header schemas, which have typically a simple structure.
      *
-     * @param headers
+     * @param schemaWithoutRef
      * @return
      */
-    public ComponentSchema postProcessSimpleSchema(SchemaObject headers) {
-        String schemaName = headers.getTitle();
+    public ComponentSchema postProcessSchemaWithoutRef(SchemaObject schemaWithoutRef) {
+        String schemaName = schemaWithoutRef.getTitle();
 
         // create a swagger schema to invoke the postprocessors. Copy attributes vom headers to (Swagger) headerSchema
         ObjectSchema headerSchema = new ObjectSchema();
         headerSchema.setName(schemaName);
-        headerSchema.setTitle(headers.getTitle());
-        headerSchema.setDescription(headers.getDescription());
+        headerSchema.setTitle(schemaWithoutRef.getTitle());
+        headerSchema.setDescription(schemaWithoutRef.getDescription());
 
         // transform properties of headers to a properties Map of Swagger schemas.
         // (Only one level, no deep transformation, see SwaggerSchemaUtil#mapToSwagger)
         //
-        Map<String, Schema> properties = headers.getProperties().entrySet().stream()
+        Map<String, Schema> properties = schemaWithoutRef.getProperties().entrySet().stream()
                 .map((property) ->
                         Map.entry(property.getKey(), (Schema<?>) swaggerSchemaUtil.mapToSwagger(property.getValue())))
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

springwolf-core/src/test/java/io/github/springwolf/core/asyncapi/scanners/common/message/AsyncAnnotationMessageServiceTest.java

@@ -48,7 +48,7 @@ void setUp() {
                 .when(stringValueResolver)
                 .resolveStringValue(any());
 
-        when(componentsService.registerSimpleSchema(any())).thenReturn("headerSchemaName");
+        when(componentsService.registerSchema(any())).thenReturn("headerSchemaName");
         when(messageBindingProcessor.process(any())).thenReturn(Optional.empty());
 
         when(payloadAsyncOperationService.extractSchema(any(), any())).thenReturn(payloadSchema);

springwolf-core/src/test/java/io/github/springwolf/core/asyncapi/scanners/common/payload/PayloadAsyncOperationServiceTest.java

@@ -111,6 +111,6 @@ void shouldReturnPayloadNotUsed() {
         SchemaObject schema = result.schema().getSchema();
         assertThat(schema.getTitle()).isEqualTo("PayloadNotUsed");
         assertThat(schema.getDescription()).isEqualTo("No payload specified");
-        verify(componentsService).registerSimpleSchema(PAYLOAD_NOT_USED.schema().getSchema());
+        verify(componentsService).registerSchema(PAYLOAD_NOT_USED.schema().getSchema());
     }
 }