add interface parameter mapping (#346)

Author: hauner

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/DataTypeConverter.kt

@@ -293,7 +293,7 @@ class DataTypeConverter(
     }
 
     private fun addInterfaces(schemaInfo: SchemaInfo, obj: ModelDataType) {
-        finder.findInterfaceTypeMappings(MappingFinderQuery(schemaInfo)).forEach { mapping ->
+        finder.findAnyInterfaceTypeMapping(MappingFinderQuery(schemaInfo)).forEach { mapping ->
             val targetType = mapping.getTargetType()
             val theInterface = InterfaceDataTypeExisting(DataTypeName(targetType.getName()), targetType.getPkg())
             obj.addInterface(theInterface)

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinder.kt

@@ -202,6 +202,47 @@ class MappingFinder(val options: ApiOptions) {
         return null
     }
 
+    /**
+     * find any interface mapping. The mappings are checked in the following order and the first match wins:
+     *
+     * - endpoint parameter type
+     * - endpoint type
+     * - global parameter type
+     * - global type
+     */
+    fun findAnyInterfaceTypeMapping(query: MappingQuery): List<InterfaceTypeMapping> {
+        val step = rootStep("looking for interface type mappings of", query)
+        try {
+            return findAnyInterfaceTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
+
+    fun findAnyInterfaceTypeMapping(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
+        val eppMapping = repository.findEndpointInterfaceParameterTypeMappings(query, step)
+        if (eppMapping.isNotEmpty()) {
+            return eppMapping
+        }
+
+        val eptMapping = repository.findEndpointInterfaceTypeMappings(query, step)
+        if (eptMapping.isNotEmpty()) {
+            return eptMapping
+        }
+
+        val gpMapping = repository.findGlobalInterfaceParameterTypeMappings(query, step)
+        if (gpMapping.isNotEmpty()) {
+            return gpMapping
+        }
+
+        val gtMapping = repository.findGlobalInterfaceTypeMappings(query, step)
+        if (gtMapping.isNotEmpty()) {
+            return gtMapping
+        }
+
+        return emptyList()
+    }
+
     // path/method/name/format/type
     fun findTypeMapping(query: MappingQuery): TypeMapping? {
         val step = rootStep("looking for type mapping of", query)
@@ -286,7 +327,7 @@ class MappingFinder(val options: ApiOptions) {
     }
 
     private fun findInterfaceTypeMapping(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
-        val epMapping = repository.findEndpointInterfaceTypeMapping(query, step)
+        val epMapping = repository.findEndpointInterfaceTypeMappings(query, step)
         if (epMapping.isNotEmpty()) {
             return epMapping
         }

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/EndpointMappings.kt

@@ -300,7 +300,7 @@ class EndpointMappings(
     fun findInterfaceParameterTypeMapping(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
         val httpMethodMappings = methodMappings[query.method]
         if (httpMethodMappings != null) {
-            val methodMapping = httpMethodMappings.findInterfaceParameterTypeMapping(
+            val methodMapping = httpMethodMappings.findInterfaceParameterTypeMappings(
                 InterfaceTypeMatcher(query),
                 step.add(MethodsStep(query)))
 
@@ -309,7 +309,7 @@ class EndpointMappings(
             }
         }
 
-        val mapping = mappings.findInterfaceParameterTypeMapping(InterfaceTypeMatcher(query), step)
+        val mapping = mappings.findInterfaceParameterTypeMappings(InterfaceTypeMatcher(query), step)
         if (mapping.isNotEmpty()) {
             return mapping
         }

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingRepository.kt

@@ -58,6 +58,10 @@ class MappingRepository(
         return globalMappings.findParameterTypeMapping(TypeMatcher(query), step.add(GlobalsStep()))
     }
 
+    fun findGlobalInterfaceParameterTypeMappings(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
+        return globalMappings.findInterfaceParameterTypeMappings(InterfaceTypeMatcher(query), step.add(GlobalsStep()))
+    }
+
     fun findGlobalAnnotationParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
         return globalMappings.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query), step.add(GlobalsStep()))
     }
@@ -111,11 +115,16 @@ class MappingRepository(
         return endpointMappings[query.path]?.findTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointInterfaceTypeMapping(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
+    fun findEndpointInterfaceTypeMappings(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
         val mappings = endpointMappings[query.path] ?: return emptyList()
         return mappings.findInterfaceTypeMappings(query, step.add(EndpointsStep(query)))
     }
 
+    fun findEndpointInterfaceParameterTypeMappings(query: MappingQuery, step: MappingStep): List<InterfaceTypeMapping> {
+        val mappings = endpointMappings[query.path] ?: return emptyList()
+        return mappings.findInterfaceParameterTypeMapping(query, step.add(EndpointsStep(query)))
+    }
+
     fun findEndpointAnnotationTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
         val pathMappings = endpointMappings[query.path] ?: return emptyList()
         return pathMappings.findAnnotationTypeMappings(query, step.add(EndpointsStep(query)))

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Mappings.kt

@@ -129,7 +129,7 @@ class Mappings(
         return mappings.first() as TypeMapping
     }
 
-    fun findInterfaceParameterTypeMapping(filter: MappingMatcher, step: MappingStep): List<InterfaceTypeMapping> {
+    fun findInterfaceParameterTypeMappings(filter: MappingMatcher, step: MappingStep): List<InterfaceTypeMapping> {
         val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep("type")))
         if (mappings.isEmpty()) {
             return emptyList()

openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterInterfacesSpec.kt

@@ -64,7 +64,7 @@ class MappingConverterInterfacesSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         val query = MappingFinderQuery(path = "/foo", name = "Foo")
-        val typeMappings = mappings.findInterfaceParameterTypeMapping(
+        val typeMappings = mappings.findInterfaceParameterTypeMappings(
             InterfaceTypeMatcher(query), ParametersStep("type"))
 
         typeMappings shouldHaveSize 2