Add pattern validator with regex

Author: bargergo

src/main/kotlin/com/papsign/ktor/openapigen/annotations/type/string/pattern/RegularExpression.kt

@@ -0,0 +1,9 @@
+package com.papsign.ktor.openapigen.annotations.type.string.pattern
+
+import com.papsign.ktor.openapigen.schema.processor.SchemaProcessorAnnotation
+import com.papsign.ktor.openapigen.validation.ValidatorAnnotation
+
+@Target(AnnotationTarget.TYPE, AnnotationTarget.PROPERTY)
+@SchemaProcessorAnnotation(RegularExpressionProcessor::class)
+@ValidatorAnnotation(RegularExpressionProcessor::class)
+annotation class RegularExpression(val pattern: String, val message: String = "")

src/main/kotlin/com/papsign/ktor/openapigen/annotations/type/string/pattern/RegularExpressionConstraintProcessor.kt

@@ -0,0 +1,61 @@
+package com.papsign.ktor.openapigen.annotations.type.string.pattern
+
+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.schema.processor.SchemaProcessor
+import com.papsign.ktor.openapigen.validation.Validator
+import com.papsign.ktor.openapigen.validation.ValidatorBuilder
+import java.lang.Exception
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+abstract class RegularExpressionConstraintProcessor<A: Annotation>(): SchemaProcessor<A>, ValidatorBuilder<A> {
+
+    private val log = classLogger()
+
+    val types = listOf(getKType<String>().withNullability(true), getKType<String>().withNullability(false))
+
+    abstract fun process(model: SchemaModel.SchemaModelLitteral<*>, annotation: A): SchemaModel.SchemaModelLitteral<*>
+
+    abstract fun getConstraint(annotation: A): RegularExpressionConstraint
+
+    private class RegularExpressionConstraintValidator(private val constraint: RegularExpressionConstraint): Validator {
+        override fun <T> validate(subject: T?): T? {
+            if (subject is String?) {
+                if (subject == null || !constraint.pattern.toRegex().containsMatchIn(subject)) {
+                    throw RegularExpressionConstraintViolation(subject, constraint)
+                }
+            } else {
+                throw NotAStringViolation(subject)
+            }
+            return subject
+        }
+    }
+
+    override fun build(type: KType, annotation: A): Validator {
+        return if (types.contains(type)) {
+            RegularExpressionConstraintValidator(getConstraint(annotation))
+        } else {
+            error("${annotation::class} can only be used on types: $types")
+        }
+    }
+
+    override fun process(model: SchemaModel<*>, type: KType, annotation: A): SchemaModel<*> {
+        return if (model is SchemaModel.SchemaModelLitteral<*> && types.contains(type)) {
+            process(model, annotation)
+        } else {
+            log.warn("${annotation::class} can only be used on types: $types")
+            model
+        }
+    }
+}
+
+data class RegularExpressionConstraint(val pattern: String, val errorMessage: String? = null)
+
+open class ConstraintViolation(message: String, cause: Throwable? = null): Exception(message, cause)
+
+class RegularExpressionConstraintViolation(val actual: String?, val constraint: RegularExpressionConstraint): ConstraintViolation(constraint.errorMessage ?: "Constraint violation: the string " +
+"\'$actual\' does not match the regular expression ${constraint.pattern}")
+
+class NotAStringViolation(val value: Any?): ConstraintViolation("Constraint violation: $value is not a string")

src/main/kotlin/com/papsign/ktor/openapigen/annotations/type/string/pattern/RegularExpressionProcessor.kt

@@ -0,0 +1,17 @@
+package com.papsign.ktor.openapigen.annotations.type.string.pattern
+
+import com.papsign.ktor.openapigen.model.schema.SchemaModel
+
+object RegularExpressionProcessor : RegularExpressionConstraintProcessor<RegularExpression>() {
+    override fun process(model: SchemaModel.SchemaModelLitteral<*>, annotation: RegularExpression): SchemaModel.SchemaModelLitteral<*> {
+        @Suppress("UNCHECKED_CAST")
+        return (model as SchemaModel.SchemaModelLitteral<Any?>).apply {
+            pattern = annotation.pattern
+        }
+    }
+
+    override fun getConstraint(annotation: RegularExpression): RegularExpressionConstraint {
+        val errorMessage = if (annotation.message.isNotEmpty()) annotation.message else null
+        return RegularExpressionConstraint(annotation.pattern, errorMessage)
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/model/schema/SchemaModel.kt

@@ -57,6 +57,7 @@ sealed class SchemaModel<T>: DataModel {
         var maximum: T? = null,
         var minLength: Int? = null,
         var maxLength: Int? = null,
+        var pattern: String? = null,
         override var example: T? = null,
         override var examples: List<T>? = null,
         override var description: String? = null