do not use 'multi' wrapper in model

Author: hauner

src/main/groovy/com/github/hauner/openapi/spring/converter/ApiConverter.groovy

@@ -62,6 +62,7 @@ class ApiConverter {
     private DataTypeConverter dataTypeConverter
     private ResultDataTypeWrapper dataTypeWrapper
     private SingleDataTypeWrapper singleDataTypeWrapper
+    private MultiDataTypeWrapper multiDataTypeWrapper
     private MappingFinder mappingFinder
     private ApiOptions options
 
@@ -75,6 +76,7 @@ class ApiConverter {
         dataTypeConverter = new DataTypeConverter(this.options)
         dataTypeWrapper = new ResultDataTypeWrapper(this.options)
         singleDataTypeWrapper = new SingleDataTypeWrapper(this.options)
+        multiDataTypeWrapper = new MultiDataTypeWrapper(this.options)
         mappingFinder = new MappingFinder (typeMappings: this.options.typeMappings)
     }
 
@@ -235,11 +237,16 @@ class ApiConverter {
 
     private ModelRequestBody createRequestBody (String contentType, SchemaInfo info, boolean required, DataTypes dataTypes) {
         DataType dataType = dataTypeConverter.convert (info, dataTypes)
-        DataType singleDataType = singleDataTypeWrapper.wrap (dataType, info)
+        DataType changedType
+        if (!info.isArray ()) {
+            changedType = singleDataTypeWrapper.wrap (dataType, info)
+        } else {
+            changedType = multiDataTypeWrapper.wrap (dataType, info)
+        }
 
         new ModelRequestBody(
             contentType: contentType,
-            requestBodyType: singleDataType,
+            requestBodyType: changedType,
             required: required)
     }
 
@@ -282,8 +289,13 @@ class ApiConverter {
                 resolver: resolver)
 
             DataType dataType = dataTypeConverter.convert (info, dataTypes)
-            DataType singleDataType = singleDataTypeWrapper.wrap (dataType, info)
-            DataType resultDataType = dataTypeWrapper.wrap (singleDataType, info)
+            DataType changedType
+            if (!info.isArray ()) {
+                changedType = singleDataTypeWrapper.wrap (dataType, info)
+            } else {
+                changedType = multiDataTypeWrapper.wrap (dataType, info)
+            }
+            DataType resultDataType = dataTypeWrapper.wrap (changedType, info)
 
             def resp = new ModelResponse (
                 contentType: contentType,

src/main/groovy/com/github/hauner/openapi/spring/converter/MappingFinder.groovy

@@ -29,7 +29,7 @@ import com.github.hauner.openapi.spring.converter.mapping.TypeMapping
 
 /**
  * find mapping in type mapping list for a schema info.
- * 
+ *
  * @author Martin Hauner
  */
 class MappingFinder {
@@ -129,7 +129,16 @@ class MappingFinder {
         }
 
     }
-    
+
+    class MultiTypeMatcher extends BaseVisitor {
+
+        @Override
+        boolean match (TypeMapping mapping) {
+            mapping.sourceTypeName == 'multi'
+        }
+
+    }
+
     class AddParameterMatcher extends BaseVisitor {
 
         @Override
@@ -185,7 +194,7 @@ class MappingFinder {
 
         filterMappings (new TypeMatcher (schema: info), ep)
     }
-    
+
     /**
      * find any matching (global) io mapping for the given schema info.
      *
@@ -285,7 +294,7 @@ class MappingFinder {
 
         []
     }
-    
+
     /**
      * find (global) single type mapping.
      *
@@ -295,14 +304,51 @@ class MappingFinder {
     List<Mapping> findSingleMapping (SchemaInfo info) {
         List<Mapping> ep = filterMappings (new SingleTypeMatcher (schema: info), typeMappings)
 
-        
         if (!ep.empty) {
             return ep
         }
 
         []
     }
-    
+
+    /**
+     * find endpoint multi type mapping.
+     *
+     * @param info schema info of the OpenAPI schema.
+     * @return the multi type mapping.
+     */
+    List<Mapping> findEndpointMultiMapping (SchemaInfo info) {
+        List<Mapping> ep = filterMappings (new EndpointMatcher (schema: info), typeMappings)
+
+        def matcher = new MultiTypeMatcher (schema: info)
+        def result = ep.findAll {
+            it.matches (matcher)
+        }
+
+        if (!result.empty) {
+            return result
+        }
+
+        []
+    }
+
+    /**
+     * find (global) multi type mapping.
+     *
+     * @param info schema info of the OpenAPI schema.
+     * @return the multi type mapping.
+     */
+    List<Mapping> findMultiMapping (SchemaInfo info) {
+        List<Mapping> ep = filterMappings (new MultiTypeMatcher (schema: info), typeMappings)
+
+
+        if (!ep.empty) {
+            return ep
+        }
+
+        []
+    }
+
     /**
      * check if the given endpoint should b excluded.
      *
@@ -339,5 +385,5 @@ class MappingFinder {
                 it.childMappings
             }
     }
-    
+
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/MultiDataTypeWrapper.groovy

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.converter
+
+import com.github.hauner.openapi.spring.converter.mapping.AmbiguousTypeMappingException
+import com.github.hauner.openapi.spring.converter.mapping.Mapping
+import com.github.hauner.openapi.spring.converter.mapping.TargetType
+import com.github.hauner.openapi.spring.converter.mapping.TargetTypeMapping
+import com.github.hauner.openapi.spring.model.datatypes.DataType
+import com.github.hauner.openapi.spring.model.datatypes.MappedCollectionDataType
+import com.github.hauner.openapi.spring.model.datatypes.NoneDataType
+import com.github.hauner.openapi.spring.model.datatypes.SingleDataType
+
+/**
+ * replaces a collection wrapper with the 'multi' data mapping.
+ * 
+ * Used to replace the collection wrapper at Responses or RequestBody's with  {@code Flux<>} or
+ * similar types.
+ *
+ * @author Martin Hauner
+ */
+class MultiDataTypeWrapper {
+    
+    private ApiOptions options
+    private MappingFinder finder
+
+    MultiDataTypeWrapper (ApiOptions options) {
+        this.options = options
+        this.finder = new MappingFinder(typeMappings: options.typeMappings)
+    }
+    
+    /**
+     * replaces an (converted) array data type with a multi data type (like {@code Flux< >})
+     * wrapping the collection item.
+     *
+     * If the configuration for the result type is 'plain' or not defined the source data type
+     * is not changed.
+     *
+     * @param dataType the data type to wrap
+     * @param schemaInfo the open api type with context information
+     * @return the resulting java data type
+     */
+    DataType wrap (DataType dataType, SchemaInfo schemaInfo) {
+        if (!schemaInfo.isArray ()) {
+            return dataType
+        }
+
+        def targetType = getMultiDataType (schemaInfo)
+        if (!targetType) {
+            return dataType
+        }
+        
+        if (targetType.typeName == 'plain') {
+            return dataType
+        }
+
+        DataType item = dataType.item
+
+        def multiType = new MappedCollectionDataType (
+            type: targetType.name,
+            pkg: targetType.pkg,
+            item: item
+        )
+        return multiType
+    }
+
+    private TargetType getMultiDataType (SchemaInfo info) {
+        // check endpoint multi mapping
+        List<Mapping> endpointMatches = finder.findEndpointMultiMapping (info)
+
+        if (!endpointMatches.empty) {
+
+            if (endpointMatches.size () != 1) {
+                throw new AmbiguousTypeMappingException (endpointMatches)
+            }
+
+            TargetType target = (endpointMatches.first() as TargetTypeMapping).targetType
+            if (target) {
+                return target
+            }
+        }
+
+        // find global multi mapping
+        List<Mapping> typeMatches = finder.findMultiMapping (info)
+        if (typeMatches.isEmpty ()) {
+            return null
+        }
+
+        if (typeMatches.size () != 1) {
+            throw new AmbiguousTypeMappingException (typeMatches)
+        }
+
+        def match = typeMatches.first () as TargetTypeMapping
+        return match.targetType
+    }
+
+    private DataType checkNone (DataType dataType) {
+        if (dataType instanceof NoneDataType) {
+            return dataType.wrappedInResult ()
+        }
+
+        dataType
+    }
+    
+}