Add validator to codec generated from refined type

Author: Luc DUZAN

refined/src/main/scala/sttp/tapir/codec/refined/TapirCodecRefined.scala

@@ -2,16 +2,52 @@ package sttp.tapir.codec.refined
 
 import sttp.tapir._
 import eu.timepit.refined.api.{Refined, Validate}
+import eu.timepit.refined.collection.NonEmpty
 import eu.timepit.refined.refineV
+import eu.timepit.refined.string.MatchesRegex
+import shapeless.Witness
 
-trait TapirCodecRefined {
-  implicit def codecForRefined[V, P, CF <: CodecFormat, R](implicit tm: Codec[V, CF, R], validator: Validate[V, P]): Codec[V Refined P, CF, R] =
+import scala.reflect.ClassTag
+
+trait RefinedValidatorTranslation[V, P] {
+  def tapirValidator: Validator[V]
+  def listError(value: V, refinedErrorMessage: String): List[ValidationError[_]]
+}
+
+object RefinedValidatorTranslation {
+  def fromPrimitiveValidator[V, P](validator: Validator.Primitive[V]) = new RefinedValidatorTranslation[V, P] {
+    override def tapirValidator: Validator[V] = validator
+    override def listError(value: V, refinedErrorMessage: String): List[ValidationError[_]] = List(ValidationError[V](validator, value))
+  }
+}
+
+trait TapirCodecRefined extends ImplicitGenericRefinedValidator {
+  implicit def codecForRefined[V, P, CF <: CodecFormat, R](implicit tm: Codec[V, CF, R], refinedValidator: Validate[V, P], refinedValidatorTranslation: RefinedValidatorTranslation[V, P]): Codec[V Refined P, CF, R] = {
     implicitly[Codec[V, CF, R]]
+      .validate(refinedValidatorTranslation.tapirValidator) // in reality if this validator has to fail, it will fail before in mapDecode while trying to construct refined type
       .mapDecode { v: V =>
         refineV[P](v) match {
           case Right(refined) => DecodeResult.Value(refined)
-          //TODO: exploit error
-          case Left(_) => DecodeResult.InvalidValue(List())
+          case Left(errorMessage) => {
+            DecodeResult.InvalidValue(refinedValidatorTranslation.listError(v, errorMessage))
+          }
         }
       }(_.value)
+  }
+
+  implicit val nonEmptyStringRefinedTranslator: RefinedValidatorTranslation[String, NonEmpty] =
+    RefinedValidatorTranslation.fromPrimitiveValidator[String, NonEmpty](Validator.minLength(1))
+
+  implicit def matchesRegexRefinedTranslator[S <: String](implicit ws: Witness.Aux[S]): RefinedValidatorTranslation[String, MatchesRegex[S]] =
+    RefinedValidatorTranslation.fromPrimitiveValidator(Validator.pattern(ws.value))
+}
+
+trait ImplicitGenericRefinedValidator {
+  implicit def genericRefinedValidatorTranslation[V, P: ClassTag](implicit refinedValidator: Validate[V, P]): RefinedValidatorTranslation[V, P] = new RefinedValidatorTranslation[V, P] {
+    override val tapirValidator: Validator.Custom[V] = Validator.Custom(
+      refinedValidator.isValid(_),
+      implicitly[ClassTag[P]].runtimeClass.toString) //for the moment there is no way to get a human description of a predicate/validator without having a concrete value to run it
+
+    override def listError(value: V, refinedErrorMessage: String): List[ValidationError[_]] = List(ValidationError[V](tapirValidator.copy(message = refinedErrorMessage), value))
+  }
 }

refined/src/test/scala/sttp/tapir/codec/refined/TapirCodecRefinedTest.scala

@@ -1,21 +1,42 @@
 package sttp.tapir.codec.refined
 
+import eu.timepit.refined.api.Refined
 import eu.timepit.refined.collection.NonEmpty
-import eu.timepit.refined.refineMV
+import eu.timepit.refined.string.{IPv4, MatchesRegex}
+import eu.timepit.refined.{W, refineMV, refineV}
 import eu.timepit.refined.types.string.NonEmptyString
 import org.scalatest.{FlatSpec, Matchers}
 import sttp.tapir.Codec.PlainCodec
-import sttp.tapir.DecodeResult
+import sttp.tapir.{DecodeResult, ValidationError, Validator}
 
 class TapirCodecRefinedTest extends FlatSpec with Matchers with TapirCodecRefined {
 
   val nonEmptyStringCodec = implicitly[PlainCodec[NonEmptyString]]
 
-  it should "return DecodResult.Invalid if subtype can't be refined" in {
-    nonEmptyStringCodec.decode("") should matchPattern{case DecodeResult.InvalidValue(_) =>}
+
+  "Generated codec" should "return DecodResult.Invalid if subtype can't be refined with correct tapir validator if available" in {
+    val expectedValidator: Validator[String] = Validator.minLength(1)
+    nonEmptyStringCodec.decode("") should matchPattern{case DecodeResult.InvalidValue(List(ValidationError(validator, "", _))) if validator == expectedValidator=>}
   }
 
   it should "correctly delegate to raw parser and refine it" in {
     nonEmptyStringCodec.decode("vive le fromage") shouldBe DecodeResult.Value(refineMV[NonEmpty]("vive le fromage"))
   }
+
+  it should "return DecodResult.Invalid if subtype can't be refined with derived tapir validator if non tapir validator available" in {
+    type IPString = String Refined IPv4
+    val IPStringCodec = implicitly[PlainCodec[IPString]]
+
+    val expectedMsg = refineV[IPv4]("192.168.0.1000").left.get
+    IPStringCodec.decode("192.168.0.1000") should matchPattern{case DecodeResult.InvalidValue(List(ValidationError(Validator.Custom(_, `expectedMsg`), "192.168.0.1000", _)))=>}
+  }
+
+  "Generated codec for MatchesRegex" should "use tapir Validator.Pattern" in {
+    type VariableConstraint = MatchesRegex[W.`"[a-zA-Z][-a-zA-Z0-9_]*"`.T]
+    type VariableString = String Refined VariableConstraint
+    val identifierCodec = implicitly[PlainCodec[VariableString]]
+
+    val expectedValidator: Validator[String] = Validator.pattern("[a-zA-Z][-a-zA-Z0-9_]*")
+    identifierCodec.decode("-bad") should matchPattern{case DecodeResult.InvalidValue(List(ValidationError(validator, "-bad", _))) if validator == expectedValidator=>}
+  }
 }