Finished Query Builders

Finished Converter System
Changed to experimental API to get correct KTypes for handling nullable arrays and collections, this is non negociable, it just doesn't work without

Author: Wicpar

build.gradle

@@ -31,6 +31,7 @@ dependencies {
 
 compileKotlin {
     kotlinOptions.jvmTarget = "1.6"
+    kotlinOptions.freeCompilerArgs += ["-Xuse-experimental=kotlin.ExperimentalStdlibApi"]
 }
 compileTestKotlin {
     kotlinOptions.jvmTarget = "1.6"

src/main/kotlin/com/papsign/kotlin/reflection/Reflection.kt

@@ -5,7 +5,6 @@ import kotlin.reflect.*
 import kotlin.reflect.full.createType
 import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.isSubclassOf
-import kotlin.reflect.full.withNullability
 import kotlin.reflect.jvm.jvmErasure
 
 val unitKType = getKType<Unit>()
@@ -15,7 +14,8 @@ inline fun <reified T> isNullable(): Boolean {
 }
 
 inline fun <reified T> getKType(): KType {
-    return object : SuperTypeTokenHolder<T>() { }.getKTypeImpl().withNullability(isNullable<T>())
+    return typeOf<T>()
+   // return object : SuperTypeTokenHolder<T>() {}.getKTypeImpl().withNullability(isNullable<T>())
 }
 
 // TODO: Lobby for a real kotlin ::type for types because the status quo sucks
@@ -24,7 +24,7 @@ inline fun <reified T> getKType(): KType {
 open class SuperTypeTokenHolder<T>
 
 fun SuperTypeTokenHolder<*>.getKTypeImpl(): KType =
-        javaClass.genericSuperclass.toKType().arguments.single().type!!
+    javaClass.genericSuperclass.toKType().arguments.single().type!!
 
 fun KClass<*>.toInvariantFlexibleProjection(arguments: List<KTypeProjection> = emptyList()): KTypeProjection {
     // TODO: there should be an API in kotlin-reflect which creates KType instances corresponding to flexible types
@@ -41,13 +41,15 @@ fun Type.toKTypeProjection(): KTypeProjection = when (this) {
     is Class<*> -> this.kotlin.toInvariantFlexibleProjection()
     is ParameterizedType -> {
         val erasure = (rawType as Class<*>).kotlin
-        erasure.toInvariantFlexibleProjection((erasure.typeParameters.zip(actualTypeArguments).map { (parameter, argument) ->
-            val projection = argument.toKTypeProjection()
-            projection.takeIf {
-                // Get rid of use-site projections on arguments, where the corresponding parameters already have a declaration-site projection
-                parameter.variance == KVariance.INVARIANT || parameter.variance != projection.variance
-            } ?: KTypeProjection.invariant(projection.type!!)
-        }))
+        erasure.toInvariantFlexibleProjection(
+            (erasure.typeParameters.zip(actualTypeArguments).map { (parameter, argument) ->
+                val projection = argument.toKTypeProjection()
+                projection.takeIf {
+                    // Get rid of use-site projections on arguments, where the corresponding parameters already have a declaration-site projection
+                    parameter.variance == KVariance.INVARIANT || parameter.variance != projection.variance
+                } ?: KTypeProjection.invariant(projection.type!!)
+            })
+        )
     }
     is WildcardType -> when {
         lowerBounds.isNotEmpty() -> KTypeProjection.contravariant(lowerBounds.single().toKType())
@@ -122,4 +124,4 @@ fun KType.getObjectSubtypes(): Set<KType> {
 //    println(getKType<Array<Int?>?>())
 //    println(getKType<Array<Array<String>>>())
 //    println(getKType<Unit>())
-//}
+//}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/ParameterStyle.kt

@@ -1,7 +1,5 @@
 package com.papsign.ktor.openapigen.parameters
 
-import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderFactory
-
 interface ParameterStyle<S> where S: ParameterStyle<S>, S: Enum<S> {
     val name: String
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/ObjectParameterParser.kt

@@ -1,8 +1,7 @@
 package com.papsign.ktor.openapigen.parameters.parsers
 
 import com.papsign.ktor.openapigen.parameters.QueryParamStyle
-import com.papsign.ktor.openapigen.parameters.parsers.deepobject.DeepBuilder
-import com.papsign.ktor.openapigen.parameters.parsers.deepobject.DeepBuilderFactory
+import com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject.DeepBuilderFactory
 import com.papsign.ktor.openapigen.parameters.util.ParameterInfo
 import io.ktor.http.Parameters
 import io.ktor.util.toMap

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/generic/Builder.kt renamed to src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/Builder.kt

@@ -1,9 +1,9 @@
-package com.papsign.ktor.openapigen.parameters.parsers.generic
+package com.papsign.ktor.openapigen.parameters.parsers.builders
 
 import com.papsign.ktor.openapigen.parameters.ParameterStyle
 
 interface Builder<S> where S: ParameterStyle<S>, S: Enum<S> {
     val style: S
-    val exploded: Boolean
+    val explode: Boolean
     fun build(key: String, parameters: Map<String, List<String>>): Any?
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/BuilderFactory.kt

@@ -0,0 +1,9 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders
+
+import com.papsign.ktor.openapigen.parameters.ParameterStyle
+import kotlin.reflect.KType
+
+interface BuilderFactory<out T: Builder<S>, S> where S: ParameterStyle<S>, S: Enum<S> {
+    fun buildBuilder(type: KType, explode: Boolean): T?
+    fun buildBuilderForced(type: KType, explode: Boolean): T = buildBuilder(type, explode) ?: error("No ${this.javaClass.declaringClass?.simpleName ?: this.javaClass.simpleName} Builder exists for type $type")
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/generic/BuilderSelector.kt renamed to src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/BuilderSelector.kt

@@ -1,8 +1,8 @@
-package com.papsign.ktor.openapigen.parameters.parsers.generic
+package com.papsign.ktor.openapigen.parameters.parsers.builders
 
 import kotlin.reflect.KType
 
 interface BuilderSelector<out T: Builder<*>> {
-    fun canHandle(type: KType): Boolean
+    fun canHandle(type: KType, explode: Boolean): Boolean
     fun create(type: KType, exploded: Boolean): T
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/BuilderSelectorFactory.kt

@@ -0,0 +1,11 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders
+
+import com.papsign.ktor.openapigen.parameters.ParameterStyle
+import kotlin.reflect.KType
+
+open class BuilderSelectorFactory<out T: Builder<S>, S>(vararg val selectors: BuilderSelector<T>):
+    BuilderFactory<T, S> where S: ParameterStyle<S>, S: Enum<S> {
+    override fun buildBuilder(type: KType, explode: Boolean): T? {
+        return selectors.find { it.canHandle(type, explode) }?.create(type, explode)
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/ArrayDeepBuilder.kt

@@ -0,0 +1,27 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.kotlin.reflection.toKType
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.util.ListToArray
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+class ArrayDeepBuilder(type: KType) : CollectionDeepBuilder(type) {
+
+    private val converter = ListToArray(type)
+
+    override fun transform(lst: List<Any?>): Any? {
+        return converter.cvt(lst)
+    }
+
+    companion object : BuilderSelector<ArrayDeepBuilder> {
+
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
+            return type.jvmErasure.java.isArray
+        }
+
+        override fun create(type: KType, exploded: Boolean): ArrayDeepBuilder {
+            return ArrayDeepBuilder(type)
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/CollectionDeepBuilder.kt

@@ -0,0 +1,33 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.ktor.openapigen.parameters.QueryParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.util.ListToArray
+import kotlin.reflect.KType
+
+abstract class CollectionDeepBuilder(type: KType) : DeepBuilder {
+
+    private val contentType = ListToArray.arrayComponentKType(type)
+
+    private val builder: Builder<QueryParamStyle> by lazy {
+        DeepBuilderFactory.buildBuilderForced(contentType, explode)
+    }
+
+    abstract fun transform(lst: List<Any?>): Any?
+
+    override fun build(key: String, parameters: Map<String, List<String>>): Any? {
+        val names = parameters.filterKeys { it != key && it.startsWith(key) }
+        return transform(if (names.isEmpty()) {
+            listOf()
+        } else {
+            val indices =
+                names.entries.groupBy { (k, _) -> k.substring(key.length + 1, k.indexOf("]", key.length)).toInt() }
+            indices.entries.fold(
+                ArrayList<Any?>((0..(indices.keys.max() ?: 0)).map { null })
+            ) { acc, (idx, params) ->
+                acc[idx] = builder.build("$key[$idx]", params.associate { (key, value) -> key to value })
+                acc
+            }
+        })
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/DeepBuilder.kt

@@ -0,0 +1,13 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.ktor.openapigen.parameters.QueryParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+
+interface DeepBuilder :
+    Builder<QueryParamStyle> {
+    override val style: QueryParamStyle
+        get() = QueryParamStyle.deepObject
+    override val explode: Boolean
+        get() = true
+}
+

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/DeepBuilderFactory.kt

@@ -0,0 +1,14 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.ktor.openapigen.parameters.QueryParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelectorFactory
+import com.papsign.ktor.openapigen.parameters.parsers.builders.query.form.ConverterFormBuilder
+
+object DeepBuilderFactory : BuilderSelectorFactory<Builder<QueryParamStyle>, QueryParamStyle>(
+    ConverterFormBuilder.primitive,
+    ListDeepBuilder,
+    ArrayDeepBuilder,
+    MapDeepBuilder,
+    ObjectDeepBuilder
+)

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/ListDeepBuilder.kt

@@ -0,0 +1,24 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.jvm.jvmErasure
+
+class ListDeepBuilder(type: KType) : CollectionDeepBuilder(type) {
+
+    override fun transform(lst: List<Any?>): Any? {
+        return lst
+    }
+
+    companion object : BuilderSelector<ListDeepBuilder> {
+
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
+            return type.jvmErasure.isSubclassOf(List::class)
+        }
+
+        override fun create(type: KType, exploded: Boolean): ListDeepBuilder {
+            return ListDeepBuilder(type)
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/deepobject/MapBuilder.kt renamed to src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/MapDeepBuilder.kt

@@ -1,36 +1,38 @@
-package com.papsign.ktor.openapigen.parameters.parsers.deepobject
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
 
-import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.parsers.converters.primitive.PrimitiveConverterFactory
 import com.papsign.ktor.openapigen.parameters.util.primitiveParsers
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.jvm.jvmErasure
 
-class MapBuilder(val type: KType) : DeepBuilder() {
+class MapDeepBuilder(val type: KType) : DeepBuilder {
     private val keyType = type.arguments[0].type!!
     private val valueType = type.arguments[1].type!!
-    private val keyBuilder = primitiveParsers[keyType] ?: error("Only primitives are allowed ")
+    private val keyBuilder = PrimitiveConverterFactory.buildConverterForced(keyType)
     private val valueBuilder by lazy { // must be lazy or will recurse infinitely
-        DeepBuilderFactory.buildBuilderForced(valueType, exploded)
+        DeepBuilderFactory.buildBuilderForced(valueType, explode)
     }
 
     override fun build(key: String, parameters: Map<String, List<String>>): Any? {
         val names = parameters.filterKeys { it.startsWith(key) }
         val indices = names.entries.groupBy { (k, _) -> k.substring(key.length + 1, k.indexOf("]", key.length)) }
         return indices.entries.fold(LinkedHashMap<Any?, Any?>()) { acc, (k, value) ->
-            acc[keyBuilder(k)] = valueBuilder.build("$key[$k]", value.associate { (k, v) -> k to v })
+            acc[keyBuilder.convert(k)] = valueBuilder.build("$key[$k]", value.associate { (k, v) -> k to v })
             acc
         }
     }
 
-    companion object: BuilderSelector<MapBuilder> {
+    companion object:
+        BuilderSelector<MapDeepBuilder> {
 
-        override fun canHandle(type: KType): Boolean {
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
             return type.jvmErasure.isSubclassOf(Map::class)
         }
 
-        override fun create(type: KType, exploded: Boolean): MapBuilder {
-            return MapBuilder(type)
+        override fun create(type: KType, exploded: Boolean): MapDeepBuilder {
+            return MapDeepBuilder(type)
         }
     }
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/deepobject/ObjectDeepBuilder.kt

@@ -0,0 +1,51 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.deepobject
+
+import com.papsign.ktor.openapigen.parameters.QueryParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.builders.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import java.lang.reflect.InvocationTargetException
+import kotlin.reflect.KFunction
+import kotlin.reflect.KParameter
+import kotlin.reflect.KType
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.jvmErasure
+
+class ObjectDeepBuilder(val type: KType) : DeepBuilder {
+
+    private val builderMap: Map<KParameter, Builder<QueryParamStyle>>
+    private val constructor: KFunction<Any>
+
+    init {
+        val kclass = type.jvmErasure
+        if (kclass.isData) {
+            constructor = kclass.primaryConstructor ?: error("Parameter objects must have primary constructors")
+            builderMap = constructor.parameters.associateWith { parameter ->
+                DeepBuilderFactory.buildBuilder(
+                    parameter.type,
+                    explode
+                ) ?: error("Could not find DeepObject Builders for type $type")
+            }
+        } else {
+            error("Only data classes are currently supported for deep objects")
+        }
+    }
+
+    override fun build(key: String, parameters: Map<String, List<String>>): Any? {
+        return try {
+            constructor.callBy(builderMap.mapValues { it.value.build("$key[${it.key.name}]", parameters) })
+        } catch (e: InvocationTargetException) {
+            null
+        }
+    }
+
+    companion object : BuilderSelector<ObjectDeepBuilder> {
+
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
+            return true
+        }
+
+        override fun create(type: KType, exploded: Boolean): ObjectDeepBuilder {
+            return ObjectDeepBuilder(type)
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/builders/query/delimited/ArrayPipeDelimitedBuilder.kt

@@ -0,0 +1,29 @@
+package com.papsign.ktor.openapigen.parameters.parsers.builders.query.delimited
+
+import com.papsign.ktor.openapigen.parameters.parsers.builders.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.util.ListToArray
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+class ArrayPipeDelimitedBuilder(type: KType): CollectionDelimitedBuilder(type, "|") {
+
+    private val converter = ListToArray(type)
+
+    override fun transform(lst: List<Any?>): Any? {
+        return converter.cvt(lst)
+    }
+
+    companion object : BuilderSelector<ArrayPipeDelimitedBuilder> {
+
+        override fun canHandle(type: KType, explode: Boolean): Boolean {
+            return !explode && type.jvmErasure.java.isArray
+        }
+
+        override fun create(type: KType, exploded: Boolean): ArrayPipeDelimitedBuilder {
+            return ArrayPipeDelimitedBuilder(
+                type
+            )
+        }
+    }
+}
+