Data class property validation (#74)

example/build.gradle.kts

@@ -1,7 +1,7 @@
 plugins {
   kotlin("multiplatform") version "2.0.0"
   kotlin("plugin.serialization") version "2.0.0"
-  id("io.github.nomisrev.openapi-kt-plugin") version "0.0.6"
+  id("io.github.nomisrev.openapi-kt-plugin") version "0.0.7"
 }
 
 openApiConfig { spec("OpenAI", file("openai.yaml")) {

generation/src/main/kotlin/io/github/nomisrev/openapi/Models.kt

@@ -1,3 +1,5 @@
+@file:Suppress("UNUSED_VARIABLE")
+
 package io.github.nomisrev.openapi
 
 import com.squareup.kotlinpoet.AnnotationSpec
@@ -247,45 +249,115 @@ private fun Model.Object.toTypeSpec(): TypeSpec =
     properties.requirement()
   }
 
-data class Requirement(val predicate: String, val message: String)
+data class Requirement(val prop: Model.Object.Property, val predicate: String, val message: String)
 
 context(OpenAPIContext)
 private fun Iterable<Model.Object.Property>.requirements(): List<Requirement> =
-  mapNotNull { property ->
+  flatMap { property ->
     when (val model = property.model) {
       is Model.Enum,
       is Model.Primitive.Boolean,
       is Model.OctetStream,
       is Model.Primitive.Unit,
       is Model.Union,
-      is Model.Object -> null
+      is Model.Object -> emptyList()
       is Collection -> {
-        val constraint = model.constraint ?: return@mapNotNull null
+        val constraint = model.constraint ?: return@flatMap emptyList()
         val paramName = toParamName(Named(property.baseName))
-        val predicate = "$paramName.size in ${constraint.minItems}..${constraint.maxItems}"
-        val message =
-          "$paramName should have between ${constraint.minItems} and ${constraint.maxItems} elements"
-        Requirement(predicate, message)
+        when (constraint.minItems) {
+          0 ->
+            when (constraint.maxItems) {
+              Int.MAX_VALUE -> emptyList()
+              else ->
+                listOf(
+                  Requirement(
+                    property,
+                    "$paramName.size <= ${constraint.maxItems}",
+                    "$paramName should have at most ${constraint.maxItems} elements"
+                  )
+                )
+            }
+          else ->
+            when (constraint.maxItems) {
+              Int.MAX_VALUE ->
+                listOf(
+                  Requirement(
+                    property,
+                    "$paramName.size >= ${constraint.minItems}",
+                    "$paramName should have at least ${constraint.minItems} elements"
+                  )
+                )
+              else ->
+                listOf(
+                  Requirement(
+                    property,
+                    "$paramName.size in ${constraint.minItems}..${constraint.maxItems}",
+                    "$paramName should have between ${constraint.minItems} and ${constraint.maxItems} elements"
+                  )
+                )
+            }
+        }
       }
 
       // TODO Implement Object constraints
-      is Model.FreeFormJson -> null
-      is Model.Primitive.Double -> {
-        val constraint = model.constraint ?: return@mapNotNull null
-        property.numberRequirement(constraint) { it }
-      }
-      is Model.Primitive.Int -> {
-        val constraint = model.constraint ?: return@mapNotNull null
-        property.intRequirement(constraint)
-      }
-      is Model.Primitive.String -> {
-        val constraint = model.constraint ?: return@mapNotNull null
-        val paramName = toParamName(Named(property.baseName))
-        val predicate = "$paramName.length in ${constraint.minLength}..${constraint.maxLength}"
-        val message =
-          "$paramName should have a length between ${constraint.minLength} and ${constraint.maxLength}"
-        Requirement(predicate, message)
-      }
+      is Model.FreeFormJson -> emptyList()
+      is Model.Primitive.Double ->
+        when (val constraint = model.constraint) {
+          null -> emptyList()
+          else -> listOfNotNull(property.numberRequirement(constraint) { it })
+        }
+      is Model.Primitive.Int ->
+        when (val constraint = model.constraint) {
+          null -> emptyList()
+          else -> listOfNotNull(property.intRequirement(constraint))
+        }
+      is Model.Primitive.String ->
+        when (val constraint = model.constraint) {
+          null -> emptyList()
+          else -> {
+            val paramName = toParamName(Named(property.baseName))
+            val lengthReq =
+              when (constraint.minLength) {
+                0 ->
+                  when (constraint.maxLength) {
+                    Int.MAX_VALUE -> null
+                    else ->
+                      Requirement(
+                        property,
+                        "$paramName.${"length"} <= ${constraint.maxLength}",
+                        "$paramName should have a ${"length"} of at most ${constraint.maxLength}"
+                      )
+                  }
+                else ->
+                  when (constraint.maxLength) {
+                    Int.MAX_VALUE ->
+                      Requirement(
+                        property,
+                        "$paramName.${"length"} >= ${constraint.minLength}",
+                        "$paramName should have a ${"length"} of at least ${constraint.minLength}"
+                      )
+                    else ->
+                      Requirement(
+                        property,
+                        "$paramName.${"length"} in ${constraint.minLength}..${constraint.maxLength}",
+                        "$paramName should have a ${"length"} between ${constraint.minLength} and ${constraint.maxLength}"
+                      )
+                  }
+              }
+            val patternReq =
+              constraint.pattern?.let { pattern ->
+                val dollarEscaped = pattern.replace("$", "${'$'}")
+                // TODO Allow configuring ignoring incorrect regex
+                dollarEscaped.toRegex()
+                val tripleQ = "${'"'}${'"'}${'"'}"
+                val predicate = "$paramName.matches($tripleQ$dollarEscaped$tripleQ.toRegex())"
+                val message = "$paramName should match the pattern $dollarEscaped"
+                Requirement(property, predicate, message)
+              }
+
+            listOfNotNull(lengthReq, patternReq)
+          }
+        }
     }
   }
 
@@ -294,19 +366,25 @@ private fun Iterable<Model.Object.Property>.requirement() {
   val requirements = requirements()
   when (requirements.size) {
     0 -> Unit
-    1 -> {
-      val requirement = requirements.single()
+    1 ->
       addInitializerBlock(
-        CodeBlock.of("require(%L) { %S }", requirement.predicate, requirement.message)
+        buildCodeBlock {
+          val r = requirements.single()
+          val nullable =
+            if (r.prop.isNullable) "if (${toParamName(Named(r.prop.baseName))} != null) " else ""
+          addStatement("$nullable require(%L) { %S }", r.predicate, r.message)
+        }
       )
-    }
     else -> {
       addInitializerBlock(
         buildCodeBlock {
           addStatement("requireAll(")
           withIndent {
-            requirements.forEach { requirement ->
-              addStatement("{ require(%L) { %S } },", requirement.predicate, requirement.message)
+            requirements.forEach { r ->
+              val nullable =
+                if (r.prop.isNullable) "if (${toParamName(Named(r.prop.baseName))} != null) "
+                else ""
+              addStatement("{ $nullable require(%L) { %S } },", r.predicate, r.message)
             }
           }
           addStatement(")")
@@ -317,33 +395,50 @@ private fun Iterable<Model.Object.Property>.requirement() {
 }
 
 context(OpenAPIContext)
-private fun Model.Object.Property.intRequirement(constraint: Constraints.Number): Requirement =
-  if (!constraint.exclusiveMinimum) {
+private fun Model.Object.Property.intRequirement(constraint: Constraints.Number): Requirement? =
+  if (
+    constraint.maximum != Double.POSITIVE_INFINITY && constraint.minimum != Double.NEGATIVE_INFINITY
+  ) {
     val paramName = toParamName(Named(baseName))
     val rangeTo = if (constraint.exclusiveMaximum) "..<" else ".."
     val minimum = constraint.minimum.toInt()
     val maximum = constraint.maximum.toInt()
     val predicate = "$paramName in $minimum$rangeTo$maximum"
     val maxM = if (constraint.exclusiveMaximum) "smaller then" else "smaller or equal to"
-    val message = "$paramName should be larger or equal to $minimum and should be $maxM ${maximum}"
-    Requirement(predicate, message)
+    val message = "$paramName should be larger or equal to $minimum and should be $maxM $maximum"
+    Requirement(this, predicate, message)
   } else numberRequirement(constraint) { it.toInt() }
 
 context(OpenAPIContext)
 private fun Model.Object.Property.numberRequirement(
   constraint: Constraints.Number,
   transform: (Double) -> Number
-): Requirement {
+): Requirement? {
   val paramName = toParamName(Named(baseName))
-  val min = if (constraint.exclusiveMinimum) "<" else "<="
-  val max = if (constraint.exclusiveMaximum) "<" else "<="
   val minimum = transform(constraint.minimum)
   val maximum = transform(constraint.maximum)
-  val predicate = "$minimum $min $paramName && $paramName $max $maximum"
+  val min = if (constraint.exclusiveMinimum) "<" else "<="
+  val max = if (constraint.exclusiveMaximum) "<" else "<="
   val minM = if (constraint.exclusiveMinimum) "larger then" else "larger or equal to"
   val maxM = if (constraint.exclusiveMaximum) "smaller then" else "smaller or equal to"
-  val message = "$paramName should be $minM $minimum and should be $maxM ${maximum}"
-  return Requirement(predicate, message)
+  return when (constraint.minimum) {
+    Double.NEGATIVE_INFINITY ->
+      when (constraint.maximum) {
+        Double.POSITIVE_INFINITY -> null
+        else -> Requirement(this, "$paramName $max $maximum", "$paramName should be $maxM $maximum")
+      }
+    else ->
+      when (constraint.maximum) {
+        Double.POSITIVE_INFINITY ->
+          Requirement(this, "$minimum $min $paramName", "$paramName should be $minM $minimum")
+        else ->
+          Requirement(
+            this,
+            "$minimum $min $paramName && $paramName $max $maximum",
+            "$paramName should be $minM $minimum and should be $maxM ${maximum}"
+          )
+      }
+  }
 }
 
 context(OpenAPIContext)

generation/src/test/kotlin/io/github/nomisrev/openapi/ApiTest.kt

@@ -2,13 +2,9 @@
 
 package io.github.nomisrev.openapi
 
-import com.tschuchort.compiletesting.JvmCompilationResult
-import com.tschuchort.compiletesting.KotlinCompilation
-import com.tschuchort.compiletesting.SourceFile
 import io.ktor.http.*
 import io.ktor.http.HttpMethod.Companion.Get
 import kotlin.test.Test
-import kotlin.test.assertEquals
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
 
 class ApiTest {
@@ -63,24 +59,3 @@ class ApiTest {
       .compiles()
   }
 }
-
-fun API.compiles(): JvmCompilationResult {
-  val ctx = OpenAPIContext(GenerationConfig("", "", "io.test", "TestApi", true))
-  val filesAsSources =
-    with(ctx) {
-      Root("TestApi", emptyList(), listOf(this@compiles)).toFileSpecs().map {
-        SourceFile.kotlin("${it.name}.kt", it.asCode())
-      }
-    }
-  val result =
-    KotlinCompilation()
-      .apply {
-        val predef = SourceFile.kotlin("Predef.kt", with(ctx) { predef() }.asCode())
-        sources = filesAsSources + predef
-        inheritClassPath = true
-        messageOutputStream = System.out
-      }
-      .compile()
-  assertEquals(result.exitCode, KotlinCompilation.ExitCode.OK)
-  return result
-}

generation/src/test/kotlin/io/github/nomisrev/openapi/ConstraintsTest.kt

@@ -146,12 +146,3 @@ class ConstraintsTest {
     assertTrue(code.containsSingle(heightRequirements))
   }
 }
-
-/** Check if every text in [texts] occurs only a single time in [this]. */
-private fun String.containsSingle(texts: List<String>): Boolean = texts.all(::containsSingle)
-
-/** Check if [text] occurs only a single time in [this]. */
-private fun String.containsSingle(text: String): Boolean {
-  val indexOf = indexOf(text)
-  return indexOf != -1 && lastIndexOf(text) == indexOf
-}