How can I programmatically create a validation contract at compile-time?

Question

I apologize in advance if this is an XY problem.

tl;dr:

I'd like to have a compile-time map of type [Request.type, Response.type] so I can effectively say if I send message Request, a CLI should, at compile-time, know how to deserialize its expected Response, irrespective of the fact that it won't know what type of request is sent until runtime.

too long; still read:

I have a CLI which communicates with an HTTP server and depending on the type of message sent to the HTTP server, I'd like to validate the JSON response against a case case.

For instance, if I send the HTTP server an AddFoo message, I might want to validate that the JSON response can be deserialized into an AddedFoo, etc.

My current solution is quite hacky. Using play-json, I'm attempting to parse the JSON response using a mapping from config.mode (i.e., command issued to the CLI) to the expected responses' implicit Reads.

My code looks something like this:

val modeToResponseReads: Map[String, Reads[_]] = Map(
  Modes.ADD_FOO -> AddedFoo.addedFooReads,
  Modes.ADD_BOO -> AddedBoo.addedBooReads,
  Modes.GET_WOO -> GetWooResponse.getWooReads,
)

parser.parse(args, MyConfig()) match {

  case Some(config) => try {
    val exec = new MyHttpExecutor(remoteUri, config)
    val res = Await.result(exec.getResponse, 100.seconds)

    // passing `Reads` to `as` because JsValue#as[T] cannot be
    // applied at runtime -- only compile-time.
    val _ = Json.parse(res.json.toString)
                .as(modeToResponseReads(config.mode))
    
    exec.actorSystem.terminate()
    exec.wsClient.close()
  } catch {
    case t: Throwable => logger.error(t.getMessage)
  }

  case None => {
    logger.error("Bad arguments.")
    sys.exit(1)
  }
}

While this works, it's an incredible kludge that becomes increasingly unmaintainable with an increasing number of messages. Further, I've found that this pattern will need to be replicated anywhere some type of validate or conversion will need to happen (e.g., Future[Any] being converted to Future[AddedFoo]).

Surely my approach isn't the right way... how is this traditionally done? If it is the right way (please no), are there optimizations that can be made?

Answer 1

I managed to accomplish this by encoding the contract directly into the child Request classes. Namely, the child Request classes would hold a ResponseType type with the base class enforcing the covariant type.

So I can do something like this:

abstract class Response
abstract class Request[+A <: Response]

case class Foo(id: String)

object Foo {
  implicit val fooReads = Json.reads[Foo]
  implicit val fooFormat = Json.format[Foo]
}

case class FooResponse(foo: Foo) extends Response {
  def greet = println("woo hoo!")
}

object FooResponse {
  implicit val fooRespReads = Json.reads[FooResponse]
  implicit val fooRespFormat = Json.format[FooResponse]
}

case class FooRequest() extends Request[FooResponse] {
  type ResponseType = FooResponse
}

object Main extends App {
  val req: FooRequest = new FooRequest()
  val foo = Foo("12345")
  val resp = new FooResponse(foo)

  val respJsonString = Json.toJson(resp).toString
  println(Json.parse(respJsonString).as[req.ResponseType])
}