Merge pull request #32 from SerVB/reworked-model

Wicpar · web-flow · commit 650c4d4e7204 · 2020-04-01T12:24:31.000+02:00
Add header parameters support
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/annotations/parameters/HeaderParam.kt b/src/main/kotlin/com/papsign/ktor/openapigen/annotations/parameters/HeaderParam.kt
@@ -0,0 +1,15 @@
+package com.papsign.ktor.openapigen.annotations.parameters
+
+import com.papsign.ktor.openapigen.model.operation.ParameterLocation
+import com.papsign.ktor.openapigen.parameters.HeaderParamStyle
+
+@Target(AnnotationTarget.FIELD, AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER)
+@Retention(AnnotationRetention.RUNTIME)
+@APIParam(ParameterLocation.header)
+annotation class HeaderParam(
+    val description: String,
+    val style: HeaderParamStyle = HeaderParamStyle.simple,
+    val explode: Boolean = true,
+    val allowEmptyValues: Boolean = false,
+    val deprecated: Boolean = false
+)
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/annotations/parameters/ParamAnnotationUtil.kt b/src/main/kotlin/com/papsign/ktor/openapigen/annotations/parameters/ParamAnnotationUtil.kt
@@ -2,6 +2,9 @@ package com.papsign.ktor.openapigen.annotations.parameters
 
 import kotlin.reflect.full.findAnnotation
 
+internal val HeaderParam.apiParam: APIParam
+    get() = annotationClass.findAnnotation()!!
+
 internal val QueryParam.apiParam: APIParam
     get() = annotationClass.findAnnotation()!!
 
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/HeaderParamStyle.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/HeaderParamStyle.kt
@@ -0,0 +1,10 @@
+package com.papsign.ktor.openapigen.parameters
+
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderFactory
+import com.papsign.ktor.openapigen.parameters.parsers.builders.header.simple.SimpleBuilderFactory
+
+
+enum class HeaderParamStyle(override val factory: BuilderFactory<Builder<HeaderParamStyle>, HeaderParamStyle>): ParameterStyle<HeaderParamStyle> {
+    simple(SimpleBuilderFactory)
+}
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/ModularParameterHander.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/ModularParameterHander.kt
@@ -1,6 +1,7 @@
 package com.papsign.ktor.openapigen.parameters.handlers
 
 import com.papsign.ktor.openapigen.OpenAPIGen
+import com.papsign.ktor.openapigen.annotations.parameters.HeaderParam
 import com.papsign.ktor.openapigen.annotations.parameters.PathParam
 import com.papsign.ktor.openapigen.annotations.parameters.QueryParam
 import com.papsign.ktor.openapigen.annotations.parameters.apiParam
@@ -11,6 +12,7 @@ import com.papsign.ktor.openapigen.modules.ModuleProvider
 import com.papsign.ktor.openapigen.modules.ofClass
 import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
 import com.papsign.ktor.openapigen.schema.builder.provider.FinalSchemaBuilderProviderModule
+import io.ktor.http.Headers
 import io.ktor.http.Parameters
 import io.ktor.util.toMap
 import kotlin.reflect.KFunction
@@ -21,8 +23,8 @@ import kotlin.reflect.full.withNullability
 class ModularParameterHander<T>(val parsers: Map<KParameter, Builder<*>>, val constructor: KFunction<T>) :
     ParameterHandler<T> {
 
-    override fun parse(parameters: Parameters): T {
-        return constructor.callBy(parsers.mapValues { it.value.build(it.key.name!!, parameters.toMap()) })
+    override fun parse(parameters: Parameters, headers: Headers): T {
+        return constructor.callBy(parsers.mapValues { it.value.build(it.key.name!!, parameters.toMap() + headers.toMap()) })
     }
 
     override fun getParameters(apiGen: OpenAPIGen, provider: ModuleProvider<*>): List<ParameterModel<*>> {
@@ -40,6 +42,17 @@ class ModularParameterHander<T>(val parsers: Map<KParameter, Builder<*>>, val co
             }
         }
 
+        fun HeaderParam.createParam(param: KParameter): ParameterModel<*> {
+            val parser = parsers[param]!!
+            return createParam(param, apiParam.`in`) {
+                it.description = description
+                it.allowEmptyValue = allowEmptyValues
+                it.deprecated = deprecated
+                it.style = parser.style
+                it.explode = parser.explode
+            }
+        }
+
         fun QueryParam.createParam(param: KParameter): ParameterModel<*> {
             val parser = parsers[param]!!
             return createParam(param, apiParam.`in`) {
@@ -62,13 +75,14 @@ class ModularParameterHander<T>(val parsers: Map<KParameter, Builder<*>>, val co
         }
 
         return constructor.parameters.map {
+            it.findAnnotation<HeaderParam>()?.createParam(it) ?:
             it.findAnnotation<PathParam>()?.createParam(it) ?:
             it.findAnnotation<QueryParam>()?.createParam(it) ?:
             error("API routes with ${constructor.returnType} must have parameters annotated with one of ${paramAnnotationClasses.map { it.simpleName }}")
         }
     }
 
     companion object {
-        private val paramAnnotationClasses = hashSetOf(PathParam::class, QueryParam::class)
+        private val paramAnnotationClasses = hashSetOf(HeaderParam::class, PathParam::class, QueryParam::class)
     }
 }
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/ParameterHandler.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/ParameterHandler.kt
@@ -1,8 +1,9 @@
 package com.papsign.ktor.openapigen.parameters.handlers
 
 import com.papsign.ktor.openapigen.modules.providers.ParameterProvider
+import io.ktor.http.Headers
 import io.ktor.http.Parameters
 
 interface ParameterHandler<T>: ParameterProvider {
-    fun parse(parameters: Parameters): T
+    fun parse(parameters: Parameters, headers: Headers): T
 }
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/UnitParameterHandler.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/handlers/UnitParameterHandler.kt
@@ -3,11 +3,12 @@ package com.papsign.ktor.openapigen.parameters.handlers
 import com.papsign.ktor.openapigen.OpenAPIGen
 import com.papsign.ktor.openapigen.model.operation.ParameterModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
+import io.ktor.http.Headers
 import io.ktor.http.Parameters
 
 object UnitParameterHandler :
     ParameterHandler<Unit> {
-    override fun parse(parameters: Parameters) = Unit
+    override fun parse(parameters: Parameters, headers: Headers) = Unit
     override fun getParameters(apiGen: OpenAPIGen, provider: ModuleProvider<*>): List<ParameterModel<*>> {
         return listOf()
     }
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/header/simple/SimpleBuilder.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/header/simple/SimpleBuilder.kt
@@ -0,0 +1,29 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.header.simple
+
+import com.papsign.ktor.openapigen.parameters.HeaderParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.parsers.converters.Converter
+import com.papsign.ktor.openapigen.parameters.parsers.converters.ConverterFactory
+import kotlin.reflect.KType
+
+class SimpleBuilder(val type: KType, override val explode: Boolean): Builder<HeaderParamStyle> {
+    override val style: HeaderParamStyle = HeaderParamStyle.simple
+    private val converter: Converter = ConverterFactory.buildConverterForced(type)
+
+    override fun build(key: String, parameters: Map<String, List<String>>): Any? {
+        val value = parameters[key]?.let { it[0] } ?: return null
+        val adjusted = if (explode) value.replace('=', ',') else value
+        return converter.convert(adjusted)
+    }
+
+    companion object: BuilderSelector<SimpleBuilder> {
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
+            return true
+        }
+
+        override fun create(type: KType, explode: Boolean): SimpleBuilder {
+            return SimpleBuilder(type, explode)
+        }
+    }
+}
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/header/simple/SimpleBuilderFactory.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/header/simple/SimpleBuilderFactory.kt
@@ -0,0 +1,9 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.header.simple
+
+import com.papsign.ktor.openapigen.parameters.HeaderParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelectorFactory
+
+object SimpleBuilderFactory: BuilderSelectorFactory<Builder<HeaderParamStyle>, HeaderParamStyle>(
+    SimpleBuilder
+)
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/parameters/util/Util.kt b/src/main/kotlin/com/papsign/ktor/openapigen/parameters/util/Util.kt
@@ -1,5 +1,6 @@
 package com.papsign.ktor.openapigen.parameters.util
 
+import com.papsign.ktor.openapigen.annotations.parameters.HeaderParam
 import com.papsign.ktor.openapigen.annotations.parameters.PathParam
 import com.papsign.ktor.openapigen.annotations.parameters.QueryParam
 import com.papsign.ktor.openapigen.parameters.handlers.ModularParameterHander
@@ -18,6 +19,7 @@ inline fun <reified T : Any> buildParameterHandler(): ParameterHandler<T> {
     val constructor = t.primaryConstructor ?: error("API routes with ${t.simpleName} must have a primary constructor.")
     val parsers: Map<KParameter, Builder<*>> = constructor.parameters.associateWith { param ->
         val type = param.type
+        param.findAnnotation<HeaderParam>()?.let { a -> a.style.factory.buildBuilderForced(type, a.explode) } ?:
         param.findAnnotation<PathParam>()?.let { a -> a.style.factory.buildBuilderForced(type, a.explode) } ?:
         param.findAnnotation<QueryParam>()?.let { a -> a.style.factory.buildBuilderForced(type, a.explode) } ?:
         error("Parameters must be annotated with @PathParam or @QueryParam")
diff --git a/src/main/kotlin/com/papsign/ktor/openapigen/route/OpenAPIRoute.kt b/src/main/kotlin/com/papsign/ktor/openapigen/route/OpenAPIRoute.kt
@@ -51,15 +51,15 @@ abstract class OpenAPIRoute<T : OpenAPIRoute<T>>(val ktorRoute: Route, val provi
                 accept(acceptType) {
                     if (Unit is B) {
                         handle {
-                            val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters)
+                            val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters, call.request.headers)
                             pass(this, responder, PHandler.handle(params), Unit)
                         }
                     } else {
                         getContentTypesMap(B::class).forEach { (contentType, parsers) ->
                             contentType(contentType) {
                                 handle {
                                     val receive: B = parsers.getBodyParser(call.request.contentType()).parseBody(B::class, this)
-                                    val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters)
+                                    val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters, call.request.headers)
                                     pass(this, responder, PHandler.handle(params), BHandler.handle(receive))
                                 }
                             }
diff --git a/src/test/kotlin/TestServer.kt b/src/test/kotlin/TestServer.kt
@@ -12,6 +12,7 @@ import com.papsign.ktor.openapigen.OpenAPIGen
 import com.papsign.ktor.openapigen.annotations.Path
 import com.papsign.ktor.openapigen.annotations.Request
 import com.papsign.ktor.openapigen.annotations.Response
+import com.papsign.ktor.openapigen.annotations.parameters.HeaderParam
 import com.papsign.ktor.openapigen.annotations.parameters.PathParam
 import com.papsign.ktor.openapigen.annotations.type.`object`.example.ExampleProvider
 import com.papsign.ktor.openapigen.annotations.type.`object`.example.WithExample
@@ -148,6 +149,15 @@ object TestServer {
                     respond(StringResponse(params.a))
                 }
 
+                route("header") {
+                    get<NameParam, NameGreetingResponse>(
+                        info("Header Param Endpoint", "This is a Header Param Endpoint"),
+                        example = NameGreetingResponse("Hi, openapi!")
+                    ) { params ->
+                        respond(NameGreetingResponse("Hi, ${params.`X-Name`}!"))
+                    }
+                }
+
                 route("list") {
                     get<StringParam, List<StringResponse>>(
                         info("String Param Endpoint", "This is a String Param Endpoint"),
@@ -213,6 +223,11 @@ object TestServer {
     @Response("A String Response")
     data class StringResponse(val str: String)
 
+    data class NameParam(@HeaderParam("A simple Header Param") val `X-Name`: String)
+
+    @Response("A Response for header param example")
+    data class NameGreetingResponse(val str: String)
+
 
     @Response("A String Response")
     @Request("A String Request")

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`package com.papsign.ktor.openapigen.parameters.handlers`
`2`	`2`
`3`	`3`	`import com.papsign.ktor.openapigen.modules.providers.ParameterProvider`
	`4`	`+import io.ktor.http.Headers`
`4`	`5`	`import io.ktor.http.Parameters`
`5`	`6`
`6`	`7`	`interface ParameterHandler<T>: ParameterProvider {`
`7`		`- fun parse(parameters: Parameters): T`
	`8`	`+ fun parse(parameters: Parameters, headers: Headers): T`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,15 +51,15 @@ abstract class OpenAPIRoute<T : OpenAPIRoute<T>>(val ktorRoute: Route, val provi`
`51`	`51`	`accept(acceptType) {`
`52`	`52`	`if (Unit is B) {`
`53`	`53`	`handle {`
`54`		`- val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters)`
	`54`	`+ val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters, call.request.headers)`
`55`	`55`	`pass(this, responder, PHandler.handle(params), Unit)`
`56`	`56`	`}`
`57`	`57`	`} else {`
`58`	`58`	`getContentTypesMap(B::class).forEach { (contentType, parsers) ->`
`59`	`59`	`contentType(contentType) {`
`60`	`60`	`handle {`
`61`	`61`	`val receive: B = parsers.getBodyParser(call.request.contentType()).parseBody(B::class, this)`
`62`		`- val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters)`
	`62`	`+ val params: P = if (Unit is P) Unit else parameterHandler.parse(call.parameters, call.request.headers)`
`63`	`63`	`pass(this, responder, PHandler.handle(params), BHandler.handle(receive))`
`64`	`64`	`}`
`65`	`65`	`}`