Changed module provider to work with KTypes to allow for generic specialization

Changed module provider to guarantee insertion order is preserved, and last insertion is at the end
added status info

Author: Wicpar

src/main/kotlin/com/papsign/ktor/openapigen/OpenAPIGen.kt

@@ -13,6 +13,7 @@ import io.ktor.application.call
 import io.ktor.request.path
 import io.ktor.util.AttributeKey
 import org.reflections.Reflections
+import kotlin.reflect.full.starProjectedType
 
 class OpenAPIGen(
         config: Configuration,
@@ -37,7 +38,7 @@ class OpenAPIGen(
             }
         }
         config.removeModules.forEach(globalModuleProvider::unRegisterModule)
-        config.addModules.forEach(globalModuleProvider::registerModule)
+        config.addModules.forEach { globalModuleProvider.registerModule(it, it::class.starProjectedType) }
     }
 
     class Configuration(val api: OpenAPIModel) {

src/main/kotlin/com/papsign/ktor/openapigen/OpenAPIGenModuleExtension.kt

@@ -1,13 +1,14 @@
 package com.papsign.ktor.openapigen
 
 import com.papsign.ktor.openapigen.modules.OpenAPIModule
+import kotlin.reflect.full.starProjectedType
 
 /**
  * implement this to automatically register an object as [OpenAPIModule] in the global context
  * only works if the object is in a package declared in [OpenAPIGen.Configuration.scanPackagesForModules]
  */
 interface OpenAPIGenModuleExtension: OpenAPIModule, OpenAPIGenExtension {
     override fun onInit(gen: OpenAPIGen) {
-        gen.globalModuleProvider.registerModule(this)
+        gen.globalModuleProvider.registerModule(this, this::class.starProjectedType)
     }
 }

src/main/kotlin/com/papsign/ktor/openapigen/content/type/ktor/KtorContentProvider.kt

@@ -1,6 +1,5 @@
 package com.papsign.ktor.openapigen.content.type.ktor
 
-import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.unitKType
 import com.papsign.ktor.openapigen.OpenAPIGen
 import com.papsign.ktor.openapigen.OpenAPIGenModuleExtension
@@ -12,7 +11,7 @@ import com.papsign.ktor.openapigen.content.type.ResponseSerializer
 import com.papsign.ktor.openapigen.model.operation.MediaTypeModel
 import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
-import com.papsign.ktor.openapigen.modules.ofClass
+import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.schema.builder.provider.FinalSchemaBuilderProviderModule
 import io.ktor.application.ApplicationCall
 import io.ktor.application.call
@@ -58,7 +57,7 @@ object KtorContentProvider : ContentTypeProvider, BodyParser, ResponseSerializer
             }
         }
         val contentTypes = initContentTypes(apiGen) ?: return null
-        val schemaBuilder = provider.ofClass<FinalSchemaBuilderProviderModule>().last().provide(apiGen, provider)
+        val schemaBuilder = provider.ofType<FinalSchemaBuilderProviderModule>().last().provide(apiGen, provider)
         @Suppress("UNCHECKED_CAST")
         val media =  MediaTypeModel(schemaBuilder.build(type) as SchemaModel<T>, example)
         return contentTypes.associateWith { media.copy() }

src/main/kotlin/com/papsign/ktor/openapigen/content/type/multipart/MultipartFormDataContentProvider.kt

@@ -9,7 +9,7 @@ import com.papsign.ktor.openapigen.model.operation.MediaTypeEncodingModel
 import com.papsign.ktor.openapigen.model.operation.MediaTypeModel
 import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
-import com.papsign.ktor.openapigen.modules.ofClass
+import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.schema.builder.provider.FinalSchemaBuilderProviderModule
 import io.ktor.application.ApplicationCall
 import io.ktor.http.ContentType
@@ -140,7 +140,7 @@ object MultipartFormDataContentProvider : BodyParser, OpenAPIGenModuleExtension
                         .mapValues { MediaTypeEncodingModel(it.value!!.contentType) }
             }.toMap()
         }
-        val schemaBuilder = provider.ofClass<FinalSchemaBuilderProviderModule>().last().provide(apiGen, provider)
+        val schemaBuilder = provider.ofType<FinalSchemaBuilderProviderModule>().last().provide(apiGen, provider)
         @Suppress("UNCHECKED_CAST")
         return mapOf(ContentType.MultiPart.FormData to MediaTypeModel(schemaBuilder.build(type) as SchemaModel<T>, example, null, contentTypes))
     }

src/main/kotlin/com/papsign/ktor/openapigen/interop/StatusPages.kt

@@ -2,6 +2,7 @@ package com.papsign.ktor.openapigen.interop
 
 import com.papsign.ktor.openapigen.APIException.Companion.apiException
 import com.papsign.ktor.openapigen.OpenAPIGen
+import com.papsign.ktor.openapigen.modules.registerModule
 import com.papsign.ktor.openapigen.route.ThrowsInfo
 import io.ktor.application.call
 import io.ktor.features.StatusPages

src/main/kotlin/com/papsign/ktor/openapigen/modules/CachingModuleProvider.kt

@@ -3,20 +3,22 @@ package com.papsign.ktor.openapigen.modules
 import java.util.*
 import kotlin.collections.LinkedHashSet
 import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.starProjectedType
 import kotlin.reflect.full.superclasses
 
 class CachingModuleProvider: ModuleProvider<CachingModuleProvider> {
 
     @Synchronized
-    override fun <T : OpenAPIModule> ofClass(clazz: KClass<T>): Collection<T> {
-        return modules[clazz]?.let @Suppress("UNCHECKED_CAST") { it.toSet() as Set<T> } ?: setOf()
+    override fun ofType(type: KType): Collection<Any> {
+        return modules[type]?.toList() ?: listOf()
     }
 
     @Synchronized
-    override fun registerModule(module: OpenAPIModule) {
-        registerModuleForClass(module::class, module)
+    override fun registerModule(module: OpenAPIModule, type: KType) {
+        registerModuleForClass(type, module)
         if (module is DependentModule) {
-            module.handlers.forEach(this::registerModule)
+            module.handlers.forEach { registerModule(it, it::class.starProjectedType) }
         }
     }
 
@@ -26,22 +28,21 @@ class CachingModuleProvider: ModuleProvider<CachingModuleProvider> {
     }
 
     @Synchronized
-    private fun registerModuleForClass(clazz: KClass<*>, module: OpenAPIModule) {
-        val lst = modules.getOrPut(clazz) {LinkedHashSet()}
-        if (!lst.contains(module)) {
-            lst.add(module)
-            clazz.superclasses.forEach {
-                registerModuleForClass(it, module)
-            }
+    private fun registerModuleForClass(type: KType, module: OpenAPIModule) {
+        val lst = modules.getOrPut(type) {LinkedHashSet()}
+        lst.remove(module)
+        lst.add(module)
+        (type.classifier as KClass<*>).supertypes.forEach {
+            registerModuleForClass(it, module)
         }
     }
 
-    private val modules = HashMap<KClass<*>, LinkedHashSet<OpenAPIModule>>()
+    private val modules = HashMap<KType, LinkedHashSet<OpenAPIModule>>()
 
     @Synchronized
     override fun child(): CachingModuleProvider {
         val new = CachingModuleProvider()
-        modules.forEach { (t: KClass<*>, u) ->
+        modules.forEach { (t: KType, u) ->
             new.modules[t] = LinkedHashSet(u)
         }
         return new

src/main/kotlin/com/papsign/ktor/openapigen/modules/ModuleProvider.kt

@@ -1,14 +1,19 @@
 package com.papsign.ktor.openapigen.modules
 
-import kotlin.reflect.KClass
+import com.papsign.ktor.openapigen.getKType
+import kotlin.reflect.KType
 
 interface ModuleProvider<THIS: ModuleProvider<THIS>> {
-    fun <T: OpenAPIModule> ofClass(clazz: KClass<T>): Collection<T>
-    fun registerModule(module: OpenAPIModule)
+    fun ofType(type: KType): Collection<Any>
+    fun registerModule(module: OpenAPIModule, type: KType)
     fun unRegisterModule(module: OpenAPIModule)
     fun child(): THIS
 }
 
-inline fun <reified T: OpenAPIModule> ModuleProvider<*>.ofClass(): Collection<T> {
-    return ofClass(T::class)
-}
+inline fun <reified T: OpenAPIModule> ModuleProvider<*>.ofType(): Collection<T> {
+    return ofType(getKType<T>()) as Collection<T>
+}
+
+inline fun <reified T: OpenAPIModule> ModuleProvider<*>.registerModule(module: T) {
+    return registerModule(module, getKType<T>())
+}

src/main/kotlin/com/papsign/ktor/openapigen/modules/handlers/AuthHandler.kt

@@ -4,14 +4,14 @@ import com.papsign.ktor.openapigen.OpenAPIGen
 import com.papsign.ktor.openapigen.model.operation.OperationModel
 import com.papsign.ktor.openapigen.model.security.SecurityModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
-import com.papsign.ktor.openapigen.modules.ofClass
+import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.modules.openapi.OperationModule
 import com.papsign.ktor.openapigen.modules.providers.AuthProvider
 
 object AuthHandler: OperationModule {
 
     override fun configure(apiGen: OpenAPIGen, provider: ModuleProvider<*>, operation: OperationModel) {
-        val authHandlers = provider.ofClass<AuthProvider<*>>()
+        val authHandlers = provider.ofType<AuthProvider<*>>()
         val security = authHandlers.flatMap { it.security }.distinct()
         operation.security = security.map { SecurityModel().also { sec ->
             it.forEach { sec[it.scheme.name] = it.requirements }

src/main/kotlin/com/papsign/ktor/openapigen/modules/handlers/RequestHandlerModule.kt

@@ -10,9 +10,10 @@ import com.papsign.ktor.openapigen.content.type.SelectedParser
 import com.papsign.ktor.openapigen.model.operation.OperationModel
 import com.papsign.ktor.openapigen.model.operation.RequestBodyModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
-import com.papsign.ktor.openapigen.modules.ofClass
+import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.modules.openapi.OperationModule
 import com.papsign.ktor.openapigen.modules.providers.ParameterProvider
+import com.papsign.ktor.openapigen.modules.registerModule
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.findAnnotation
@@ -26,7 +27,7 @@ class RequestHandlerModule<T : Any>(
     private val log = classLogger()
 
     override fun configure(apiGen: OpenAPIGen, provider: ModuleProvider<*>, operation: OperationModel) {
-        val map = provider.ofClass<BodyParser>().mapNotNull {
+        val map = provider.ofType<BodyParser>().mapNotNull {
             val mediaType = it.getMediaType(requestType, apiGen, provider, requestExample, ContentTypeProvider.Usage.PARSE)
                     ?: return@mapNotNull null
             provider.registerModule(SelectedParser(it))
@@ -35,7 +36,7 @@ class RequestHandlerModule<T : Any>(
 
         val requestMeta = requestClass.findAnnotation<Request>()
 
-        val parameters = provider.ofClass<ParameterProvider>().flatMap { it.getParameters(apiGen, provider) }
+        val parameters = provider.ofType<ParameterProvider>().flatMap { it.getParameters(apiGen, provider) }
         operation.parameters = operation.parameters?.let { (it + parameters).distinct() } ?: parameters
         operation.requestBody = operation.requestBody?.apply {
             map.forEach { (key, value) ->

src/main/kotlin/com/papsign/ktor/openapigen/modules/handlers/ResponseHandlerModule.kt

@@ -10,21 +10,23 @@ import com.papsign.ktor.openapigen.content.type.SelectedSerializer
 import com.papsign.ktor.openapigen.model.operation.OperationModel
 import com.papsign.ktor.openapigen.model.operation.StatusResponseModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
-import com.papsign.ktor.openapigen.modules.ofClass
+import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.modules.openapi.OperationModule
+import com.papsign.ktor.openapigen.modules.providers.StatusProvider
+import com.papsign.ktor.openapigen.modules.registerModule
 import io.ktor.http.HttpStatusCode
-import kotlin.reflect.KClass
+import kotlin.reflect.KAnnotatedElement
 import kotlin.reflect.KType
 import kotlin.reflect.full.findAnnotation
 
-class ResponseHandlerModule<T : Any>(val responseClass: KClass<T>, val responseType: KType, val responseExample: T? = null) : OperationModule {
+class ResponseHandlerModule<T>(val responseType: KType, val responseExample: T? = null) : OperationModule {
     private val log = classLogger()
     override fun configure(apiGen: OpenAPIGen, provider: ModuleProvider<*>, operation: OperationModel) {
-
-        val responseMeta = responseClass.findAnnotation<Response>()
-        val statusCode = responseMeta?.statusCode?.let { HttpStatusCode.fromValue(it) } ?: HttpStatusCode.OK
+        val responseMeta = (responseType.classifier as? KAnnotatedElement)?.findAnnotation<Response>()
+        val statusCode =  provider.ofType<StatusProvider>().lastOrNull()?.getStatusForType(responseType) ?: responseMeta?.statusCode?.let { HttpStatusCode.fromValue(it) }
+        ?: HttpStatusCode.OK
         val status = statusCode.value.toString()
-        val map = provider.ofClass<ResponseSerializer>().mapNotNull {
+        val map = provider.ofType<ResponseSerializer>().mapNotNull {
             val mediaType = it.getMediaType(responseType, apiGen, provider, responseExample, ContentTypeProvider.Usage.SERIALIZE)
                     ?: return@mapNotNull null
             provider.registerModule(SelectedSerializer(it))
@@ -44,7 +46,6 @@ class ResponseHandlerModule<T : Any>(val responseClass: KClass<T>, val responseT
     }
 
     companion object {
-        inline fun <reified T : Any> create(responseExample: T? = null) = ResponseHandlerModule(T::class,
-            getKType<T>(), responseExample)
+        inline fun <reified T : Any> create(responseExample: T? = null) = ResponseHandlerModule(getKType<T>(), responseExample)
     }
 }