rebuilt validation system

added validators on min/max/clamp

Author: Wicpar

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id "org.jetbrains.kotlin.jvm" version "1.3.61"
+    id "org.jetbrains.kotlin.jvm" version "$kotlin_version"
 }
 
 group 'com.papsign.ktor'

gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 ktor_version=1.2.6
 logback_version=1.2.1
-kotlin_version=1.3.61
+kotlin_version=1.3.70

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

@@ -1,9 +1,12 @@
 package com.papsign.ktor.openapigen
 
-import kotlin.reflect.KType
+import java.lang.reflect.Field
+import kotlin.reflect.*
 import kotlin.reflect.full.createType
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.javaField
 import kotlin.reflect.jvm.jvmErasure
-import kotlin.reflect.typeOf
 
 val unitKType = getKType<Unit>()
 
@@ -20,3 +23,24 @@ fun KType.strip(nullable: Boolean = isMarkedNullable): KType {
 fun KType.deepStrip(nullable: Boolean = isMarkedNullable): KType {
     return jvmErasure.createType(arguments.map { it.copy(type = it.type?.deepStrip()) }, nullable)
 }
+
+data class KTypeProperty(
+    val name: String,
+    val type: KType,
+    val source: KProperty1<*, *>
+)
+
+val KType.memberProperties: List<KTypeProperty>
+    get() {
+        val typeParameters = jvmErasure.typeParameters.zip(arguments).associate { Pair(it.first.name, it.second.type) }
+        return jvmErasure.memberProperties.map {
+            val retType = it.returnType
+            val properType = when (val classifier = retType.classifier) {
+                is KTypeParameter -> typeParameters[classifier.name] ?: it.returnType
+                else -> it.returnType
+            }
+            KTypeProperty(it.name, properType, it)
+        }
+    }
+
+val KClass<*>.isInterface get() = java.isInterface

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

@@ -12,7 +12,7 @@ import com.papsign.ktor.openapigen.modules.openapi.HandlerModule
 import com.papsign.ktor.openapigen.openAPIGen
 import com.papsign.ktor.openapigen.parameters.util.buildParameterHandler
 import com.papsign.ktor.openapigen.route.response.Responder
-import com.papsign.ktor.openapigen.validators.ValidationHandler
+import com.papsign.ktor.openapigen.validation.util.ValidationHandler
 import io.ktor.application.ApplicationCall
 import io.ktor.application.call
 import io.ktor.http.ContentType
@@ -40,8 +40,8 @@ abstract class OpenAPIRoute<T : OpenAPIRoute<T>>(val ktorRoute: Route, val provi
             it.configure(apiGen, provider)
         }
 
-        val BHandler = ValidationHandler<B>(provider)
-        val PHandler = ValidationHandler<P>(provider)
+        val BHandler = ValidationHandler.build<B>()
+        val PHandler = ValidationHandler.build<P>()
 
         ktorRoute.apply {
             getAcceptMap(R::class).let {

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/FinalSchemaBuilder.kt

@@ -4,6 +4,6 @@ import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.schema.builder.SchemaBuilder
 import kotlin.reflect.KType
 
-interface FinalSchemaBuilder: SchemaBuilder {
-    fun build(type: KType): SchemaModel<*>
+interface FinalSchemaBuilder {
+    fun build(type: KType, annotations: List<Annotation> = listOf()): SchemaModel<*>
 }

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/SchemaBuilder.kt

@@ -13,7 +13,7 @@ interface SchemaBuilder {
     /**
      * @throws error when type is unexpected
      */
-    fun build(type: KType, builder: SchemaBuilder): SchemaModel<*>
+    fun build(type: KType, builder: FinalSchemaBuilder): SchemaModel<*>
 
     fun checkType(type: KType) {
         if (!type.isSubtypeOf(superType)) error("${this::class} cannot build type $type, only subtypes of $superType are supported")

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/provider/DefaultCollectionSchemaProvider.kt

@@ -6,6 +6,7 @@ import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.modules.DefaultOpenAPIModule
 import com.papsign.ktor.openapigen.modules.ModuleProvider
+import com.papsign.ktor.openapigen.schema.builder.FinalSchemaBuilder
 import com.papsign.ktor.openapigen.schema.builder.SchemaBuilder
 import kotlin.reflect.KType
 import kotlin.reflect.full.withNullability
@@ -39,9 +40,9 @@ object DefaultCollectionSchemaProvider: SchemaBuilderProviderModule, OpenAPIGenM
 
     private data class Builder(override val superType: KType, private val getter: (KType) -> KType) :
         SchemaBuilder {
-        override fun build(type: KType, builder: SchemaBuilder): SchemaModel<*> {
+        override fun build(type: KType, builder: FinalSchemaBuilder): SchemaModel<*> {
             checkType(type)
-            return SchemaModel.SchemaModelArr<Any?>(builder.build(getter(type), builder), type.isMarkedNullable)
+            return SchemaModel.SchemaModelArr<Any?>(builder.build(getter(type)), type.isMarkedNullable)
         }
     }
 }

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/provider/DefaultEnumSchemaProvider.kt

@@ -5,6 +5,7 @@ import com.papsign.ktor.openapigen.OpenAPIGenModuleExtension
 import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
+import com.papsign.ktor.openapigen.schema.builder.FinalSchemaBuilder
 import com.papsign.ktor.openapigen.schema.builder.SchemaBuilder
 import kotlin.reflect.KType
 import kotlin.reflect.jvm.jvmErasure
@@ -13,7 +14,7 @@ object DefaultEnumSchemaProvider: SchemaBuilderProviderModule, OpenAPIGenModuleE
 
     private object Builder: SchemaBuilder {
         override val superType: KType = getKType<Enum<*>>()
-        override fun build(type: KType, builder: SchemaBuilder): SchemaModel<*> {
+        override fun build(type: KType, builder: FinalSchemaBuilder): SchemaModel<*> {
             checkType(type)
             return SchemaModel.SchemaModelEnum<Any?>(
                 type.jvmErasure.java.enumConstants.map { it.toString() },

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/provider/DefaultMapSchemaProvider.kt

@@ -5,6 +5,7 @@ import com.papsign.ktor.openapigen.OpenAPIGenModuleExtension
 import com.papsign.ktor.openapigen.getKType
 import com.papsign.ktor.openapigen.model.schema.SchemaModel
 import com.papsign.ktor.openapigen.modules.ModuleProvider
+import com.papsign.ktor.openapigen.schema.builder.FinalSchemaBuilder
 import com.papsign.ktor.openapigen.schema.builder.SchemaBuilder
 import kotlin.reflect.KType
 
@@ -16,13 +17,13 @@ object DefaultMapSchemaProvider: SchemaBuilderProviderModule, OpenAPIGenModuleEx
 
     private object Builder : SchemaBuilder {
         override val superType: KType = getKType<Map<*, *>?>()
-        override fun build(type: KType, builder: SchemaBuilder): SchemaModel<*> {
+        override fun build(type: KType, builder: FinalSchemaBuilder): SchemaModel<*> {
             checkType(type)
             if (type.arguments[0].type != getKType<String>()) error("bad type $type: Only maps with string keys are supported")
             val valueType = type.arguments[1].type ?: error("bad type $type: star projected types are not supported")
             @Suppress("UNCHECKED_CAST")
             return SchemaModel.SchemaModelMap(
-                builder.build(valueType, builder) as SchemaModel<Any?>,
+                builder.build(valueType) as SchemaModel<Any?>,
                 type.isMarkedNullable
             )
         }

src/main/kotlin/com/papsign/ktor/openapigen/schema/builder/provider/DefaultObjectSchemaProvider.kt

@@ -1,20 +1,16 @@
 package com.papsign.ktor.openapigen.schema.builder.provider
 
-import com.papsign.ktor.openapigen.OpenAPIGen
-import com.papsign.ktor.openapigen.OpenAPIGenModuleExtension
+import com.papsign.ktor.openapigen.*
 import com.papsign.ktor.openapigen.classLogger
-import com.papsign.ktor.openapigen.getKType
 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.schema.builder.FinalSchemaBuilder
 import com.papsign.ktor.openapigen.schema.builder.SchemaBuilder
 import com.papsign.ktor.openapigen.schema.namer.DefaultSchemaNamer
 import com.papsign.ktor.openapigen.schema.namer.SchemaNamer
 import kotlin.reflect.KType
-import kotlin.reflect.KTypeParameter
 import kotlin.reflect.KVisibility
-import kotlin.reflect.full.declaredMemberProperties
-import kotlin.reflect.full.memberProperties
 import kotlin.reflect.full.starProjectedType
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.jvm.jvmErasure
@@ -37,30 +33,28 @@ object DefaultObjectSchemaProvider : SchemaBuilderProviderModule, OpenAPIGenModu
 
         private val refs = HashMap<KType, SchemaModel.SchemaModelRef<*>>()
 
-        override fun build(type: KType, builder: SchemaBuilder): SchemaModel<*> {
+        override fun build(type: KType, builder: FinalSchemaBuilder): SchemaModel<*> {
             checkType(type)
             val nonNullType = type.withNullability(false)
             return refs[nonNullType] ?: {
                 val erasure = nonNullType.jvmErasure
                 val name = namer[nonNullType]
                 val ref = SchemaModel.SchemaModelRef<Any?>("#/components/schemas/$name")
                 refs[nonNullType] = ref // needed to prevent infinite recursion
-                val existing = apiGen.api.components.schemas[name]
                 val new = if (erasure.isSealed) {
-                    SchemaModel.OneSchemaModelOf(erasure.sealedSubclasses.map { builder.build(it.starProjectedType, builder) })
+                    SchemaModel.OneSchemaModelOf(erasure.sealedSubclasses.map { builder.build(it.starProjectedType) })
                 } else {
-                    val typeParameters = erasure.typeParameters.zip(type.arguments).associate { Pair(it.first.name, it.second.type) }
-                    val memberMap = erasure.declaredMemberProperties.filter { it.visibility == KVisibility.PUBLIC }.associateWith {
-                        val retType = it.returnType
-                        when(val classifier = retType.classifier) {
-                            is KTypeParameter -> typeParameters[classifier.name] ?: it.returnType
-                            else -> it.returnType
-                        }
-                    }.mapKeys { (key, _) -> key.name }
-                    val required = memberMap.entries.filter { !it.value.isMarkedNullable }.map { it.key }
-                    val memberModels = memberMap.mapValues { (_, value) -> builder.build(value, builder) }
-                    SchemaModel.SchemaModelObj<Any?>(memberModels, required)
+                    val props = type.memberProperties.filter { it.source.visibility == KVisibility.PUBLIC }
+                    SchemaModel.SchemaModelObj<Any?>(
+                        props.associate {
+                            Pair(it.name, builder.build(it.type, it.source.annotations))
+                        },
+                        props.filter {
+                            !it.type.isMarkedNullable
+                        }.map { it.name }
+                    )
                 }
+                val existing = apiGen.api.components.schemas[name]
                 if (existing != null && existing != new) log.error("Schema with name $name already exists, and is not the same as the new one, replacing...")
                 apiGen.api.components.schemas[name] = new
                 ref