Merge branch 'master' into security-scheme-generation-test

Author: Sigmund Marius Nilssen

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

@@ -1,50 +1,45 @@
 package com.papsign.ktor.openapigen.modules
 
 import java.util.*
+import kotlin.collections.ArrayList
 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 ofType(type: KType): Collection<Any> {
-        return modules[type]?.toList() ?: listOf()
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.isSupertypeOf
+
+class CachingModuleProvider(previous: Iterable<Pair<KType, OpenAPIModule>> = listOf()) : ModuleProvider<CachingModuleProvider> {
+
+    private val modules: MutableList<Pair<KType, OpenAPIModule>> = Collections.synchronizedList( synchronized(previous) { previous.toMutableList() } )
+
+    override fun ofType(type: KType): Collection<OpenAPIModule> {
+        val set = LinkedHashSet<OpenAPIModule>()
+        synchronized(modules) {
+            modules.filter {
+                it.first.isSubtypeOf(type)
+            }
+        }.forEach {
+            set.remove(it.second)
+            set.add(it.second)
+        }
+        return set
     }
 
-    @Synchronized
     override fun registerModule(module: OpenAPIModule, type: KType) {
-        registerModuleForClass(type, module)
         if (module is DependentModule) {
-            module.handlers.forEach { registerModule(it, it::class.starProjectedType) }
+            module.handlers.forEach { (depType, depModule) ->
+                if (synchronized(modules) { modules.find { it.second == depModule } } == null) {
+                    registerModule(depModule, depType)
+                }
+            }
         }
+        modules.add(type to module)
     }
 
-    @Synchronized
     override fun unRegisterModule(module: OpenAPIModule) {
-        modules.values.forEach { it.remove(module) }
-    }
-
-    @Synchronized
-    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)
-        }
+        synchronized(modules) { modules.removeIf { it.second == module } }
     }
 
-    private val modules = HashMap<KType, LinkedHashSet<OpenAPIModule>>()
-
-    @Synchronized
     override fun child(): CachingModuleProvider {
-        val new = CachingModuleProvider()
-        modules.forEach { (t: KType, u) ->
-            new.modules[t] = LinkedHashSet(u)
-        }
-        return new
+        return CachingModuleProvider(modules)
     }
 }

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

@@ -1,5 +1,14 @@
 package com.papsign.ktor.openapigen.modules
 
+import com.papsign.ktor.openapigen.getKType
+import kotlin.reflect.KType
+
 interface DependentModule {
-    val handlers: Collection<OpenAPIModule>
-}
+    val handlers: Collection<Pair<KType, OpenAPIModule>>
+
+    companion object {
+        inline fun <reified T: OpenAPIModule> handler(handler: T): Pair<KType, T> {
+            return getKType<T>() to handler
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/modules/providers/AuthProvider.kt

@@ -3,19 +3,21 @@ package com.papsign.ktor.openapigen.modules.providers
 import com.papsign.ktor.openapigen.model.Described
 import com.papsign.ktor.openapigen.model.security.SecuritySchemeModel
 import com.papsign.ktor.openapigen.modules.DependentModule
+import com.papsign.ktor.openapigen.modules.DependentModule.Companion.handler
 import com.papsign.ktor.openapigen.modules.OpenAPIModule
 import com.papsign.ktor.openapigen.modules.handlers.AuthHandler
 import com.papsign.ktor.openapigen.route.path.auth.OpenAPIAuthenticatedRoute
 import com.papsign.ktor.openapigen.route.path.normal.NormalOpenAPIRoute
 import io.ktor.application.ApplicationCall
 import io.ktor.util.pipeline.PipelineContext
+import kotlin.reflect.KType
 
 interface AuthProvider<TAuth>: OpenAPIModule, DependentModule {
     suspend fun getAuth(pipeline: PipelineContext<Unit, ApplicationCall>): TAuth
     fun apply(route: NormalOpenAPIRoute): OpenAPIAuthenticatedRoute<TAuth>
     val security: Iterable<Iterable<Security<*>>>
-    override val handlers: Collection<OpenAPIModule>
-        get() = listOf(AuthHandler)
+    override val handlers: Collection<Pair<KType, OpenAPIModule>>
+        get() = listOf(handler(AuthHandler))
 
     data class  Security<TScope>(val scheme: SecuritySchemeModel<TScope>, val requirements: List<TScope>) where TScope: Enum<TScope>, TScope: Described
 }

src/main/kotlin/com/papsign/ktor/openapigen/modules/providers/MethodProvider.kt

@@ -1,12 +1,15 @@
 package com.papsign.ktor.openapigen.modules.providers
 
+import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.modules.DependentModule
+import com.papsign.ktor.openapigen.modules.DependentModule.Companion.handler
 import com.papsign.ktor.openapigen.modules.OpenAPIModule
 import com.papsign.ktor.openapigen.modules.handlers.RouteHandler
 import io.ktor.http.HttpMethod
+import kotlin.reflect.KType
 
 interface MethodProvider : OpenAPIModule, DependentModule {
     val method: HttpMethod
-    override val handlers: Collection<OpenAPIModule>
-        get() = listOf(RouteHandler)
-}
+    override val handlers: Collection<Pair<KType, OpenAPIModule>>
+        get() = listOf(handler(RouteHandler))
+}

src/main/kotlin/com/papsign/ktor/openapigen/modules/providers/TagProviderModule.kt

@@ -1,13 +1,16 @@
 package com.papsign.ktor.openapigen.modules.providers
 
 import com.papsign.ktor.openapigen.APITag
+import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.modules.DependentModule
+import com.papsign.ktor.openapigen.modules.DependentModule.Companion.handler
 import com.papsign.ktor.openapigen.modules.OpenAPIModule
 import com.papsign.ktor.openapigen.modules.RouteOpenAPIModule
 import com.papsign.ktor.openapigen.modules.handlers.TagHandlerModule
+import kotlin.reflect.KType
 
 interface TagProviderModule: RouteOpenAPIModule, DependentModule {
     val tags: Collection<APITag>
-    override val handlers: Collection<OpenAPIModule>
-        get() = listOf(TagHandlerModule)
+    override val handlers: Collection<Pair<KType, OpenAPIModule>>
+        get() = listOf(handler(TagHandlerModule))
 }

src/main/kotlin/com/papsign/ktor/openapigen/modules/providers/ThrowInfoProvider.kt

@@ -2,11 +2,13 @@ package com.papsign.ktor.openapigen.modules.providers
 
 import com.papsign.ktor.openapigen.APIException
 import com.papsign.ktor.openapigen.modules.DependentModule
+import com.papsign.ktor.openapigen.modules.DependentModule.Companion.handler
 import com.papsign.ktor.openapigen.modules.OpenAPIModule
 import com.papsign.ktor.openapigen.modules.handlers.ThrowOperationHandler
+import kotlin.reflect.KType
 
 interface ThrowInfoProvider: OpenAPIModule, DependentModule {
     val exceptions: List<APIException<*, *>>
-    override val handlers: Collection<OpenAPIModule>
-        get() = listOf(ThrowOperationHandler)
+    override val handlers: Collection<Pair<KType, OpenAPIModule>>
+        get() = listOf(handler(ThrowOperationHandler))
 }

src/main/kotlin/com/papsign/ktor/openapigen/route/Functions.kt

@@ -3,6 +3,7 @@ package com.papsign.ktor.openapigen.route
 import com.papsign.ktor.openapigen.APITag
 import com.papsign.ktor.openapigen.annotations.Path
 import com.papsign.ktor.openapigen.content.type.ContentTypeProvider
+import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.modules.handlers.RequestHandlerModule
 import com.papsign.ktor.openapigen.modules.handlers.ResponseHandlerModule
 import com.papsign.ktor.openapigen.modules.registerModule
@@ -13,7 +14,11 @@ import io.ktor.routing.HttpMethodRouteSelector
 import io.ktor.routing.createRouteFromPath
 import io.ktor.util.pipeline.ContextDsl
 import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.KVariance
+import kotlin.reflect.full.createType
 import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.starProjectedType
 import kotlin.reflect.jvm.jvmErasure
 import kotlin.reflect.typeOf
 
@@ -141,13 +146,15 @@ internal fun <TParams : Any, TResponse : Any, TRequest : Any, TRoute : OpenAPIRo
             RequestHandlerModule.create(
                 bType,
                 exampleRequest
-            )
+            ),
+            RequestHandlerModule::class.createType(listOf(KTypeProjection(KVariance.INVARIANT, bType)))
         )
         provider.registerModule(
             ResponseHandlerModule.create(
                 rType,
                 exampleResponse
-            )
+            ),
+            ResponseHandlerModule::class.createType(listOf(KTypeProjection(KVariance.INVARIANT, rType)))
         )
         if (path != null) {
             provider.registerModule(PathProviderModule(path.path))

src/main/kotlin/com/papsign/ktor/openapigen/route/OpenAPIRoute.kt

@@ -11,6 +11,7 @@ import com.papsign.ktor.openapigen.modules.ofType
 import com.papsign.ktor.openapigen.modules.openapi.HandlerModule
 import com.papsign.ktor.openapigen.modules.registerModule
 import com.papsign.ktor.openapigen.openAPIGen
+import com.papsign.ktor.openapigen.parameters.handlers.ParameterHandler
 import com.papsign.ktor.openapigen.parameters.util.buildParameterHandler
 import com.papsign.ktor.openapigen.route.response.Responder
 import com.papsign.ktor.openapigen.validation.ValidationHandler
@@ -24,6 +25,9 @@ import io.ktor.routing.application
 import io.ktor.routing.contentType
 import io.ktor.util.pipeline.PipelineContext
 import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.KVariance
+import kotlin.reflect.full.createType
 
 abstract class OpenAPIRoute<T : OpenAPIRoute<T>>(val ktorRoute: Route, val provider: CachingModuleProvider) {
     private val log = classLogger()
@@ -37,7 +41,7 @@ abstract class OpenAPIRoute<T : OpenAPIRoute<T>>(val ktorRoute: Route, val provi
         pass: suspend OpenAPIRoute<*>.(pipeline: PipelineContext<Unit, ApplicationCall>, responder: Responder, P, B) -> Unit
     ) {
         val parameterHandler = buildParameterHandler<P>(paramsType)
-        provider.registerModule(parameterHandler)
+        provider.registerModule(parameterHandler, ParameterHandler::class.createType(listOf(KTypeProjection(KVariance.INVARIANT, paramsType))))
 
         val apiGen = ktorRoute.application.openAPIGen
         provider.ofType<HandlerModule>().forEach {