Is it possible to limit to size of a List in Reads - playframework-2.6

Question

My controller receives a json. One of the elements in the json is an array of strings. I have written the following validation for the json
implicit val pQ:Reads[PQ] = (
(JsPath \ "id").readNullable[UUID] and
(JsPath \ "description").read[String] and
(JsPath \ "h").read[List[String]] and
(JsPath \ "i").read[List[String]] and
(JsPath \ "s").read[String] and
(JsPath \ "t").read[Set[String]] and
)(PQ.apply _)
Is it possible to write a Reads or Validate such that the json gets rejected if the size of a List is more than a specified value (say the size of i list should not be more than 3?

Answer 1

I might write another answer where the code is more functional and organised. Happy to accept other answers as well.
The way to customize validating json is to extend Reads trait and implement its reads method.
abstract def reads(json: JsValue): JsResult[A]
I want to achieve two things
1) validate the the json has all the required fields
2) ensure that some of the fields have max-size limit (eg. no. of images which could be sent).
Json validation works by calling validate or validateOpt method of JsValue. These methods expect an implicit Reads and pass the JsValue to it.
def validate[T](implicit rds: Reads[T]): JsResult[T] = rds.reads(this)
So to validate json and map it to my PQ class, I had to create a Reads[PQ]. But because I want validation beyond just the structure of the json, I have to extends Reads and implement my own reads.
To do step 1, I created Reads[PQ] the normal way (just checking that all the required fields are present and can map to my PQ class
implicit val pQStructurallyCorrect:Reads[PQ] = (
(JsPath \ "id").readNullable[UUID] and
(JsPath \ "description").read[String] and
(JsPath \ "h").read[List[String]] and
(JsPath \ "i").read[List[String]] and
(JsPath \ "s").read[String] and
(JsPath \ "t").read[Set[String]] and
)(PQ.apply _)
To add step 2, I created another Reads[PQ] by extending Read[PQ] and by overriding the reads
implicit object PQReads extends Reads[PQ] {
def reads(json:JsValue):JsResult[PQ] = {
//check that the structure of the json is correct by utilizing the Reads created for step 1
val structurallyValidated = json.validateOpt[PQ](pQStructurallyCorrect)
structurallyValidated match {
case JsSuccess(pQOpt,path)=>{ //structure is correct. now check content
val result = pQOpt.map(pq=>{
if(pq.image.length <0 || pq.image.length > 3)
{
JsError("invalid no. of images")
}
else {
JsSuccess(pq)
}
}).getOrElse(JsError("Error in validating Json"))
result
}
case JsError(errors) =>{
JsError(errors)
}
}
}
}
Now to validate the json, I use PQReads object
implicit val qReads:Reads[Q] = (JsPath \ "p-q").read[PQ](PQReads)
.map((x:PQ)=>Q.apply (x))
What is happening above is when my application receives the json,
1) It first gets the body as json from the incoming request
val jsonBodyOption = body.asJson
2) Then the json is validated
val qOption = jsonBody.validateOpt[Q] //this uses qReads:Reads available implicitly
qReads uses PQReads to validate the json. PQReads first calls validateOpt passing pQStructurallyCorrect which checks the structure. If the structure is correct, then the length of image List is checked.