hi everyone
how can one create domain models for such responses below?
{
"wrapper": {
"results": 2,
"dynamicKey": [
"Item1",
"Item2"
]
}
}
{
"wrapper": {
"results": 1,
"someOtherKey": {
"different":"object"
}
}
}what I am trying to do is like below;
case class DomainResponse[T](results:Long, body:T)
object DomainResponse {
def decoder[B:Decoder](key:String): Decoder[DomainResponse[B]] = Decoder.instance { c =>
for {
results <- c.downField("wrapper").downField("results").as[Long]
body <- c.downField("wrapper").downField(key).as[B]
} yield DomainResponse(results, body)
}
}
case class Endpoint1Body(???)
object Endpoint1Body {
implicit val decoder: Decoder[Endpoint1Body] = deriveDecoder
}
client.get(uri / "someEndpoint")(_.attemptAs[DomainResponse[Endpoint1Body]])not sure how I should create the decoder since the key is dynamic
I am doing something like this now but have no idea what would be good way
def dsl[F[_]: Sync](client: Client[F], config: DomainConfig): F[Domain[F]] =
Sync[F].delay {
implicit val endpoint1Decoder: Decoder[DomainResponse[Endpoint1Body]] = DomainResponse.decoder[Endpoint1Body]("dynamicKey")
new Domain[F] {
def endpoint1: F[DomainResponse[Endpoint1Body]] = {
val request = Request[F](
Method.GET,
config.uri / "endpoint1"
)
client.expect[DomainResponse[Endpoint1Body]](request)
}
}
}
you're better off getting rid of the DomainResponse class/decoder altogether I think, and provide a function (much like
DomainResponse.decoder). For example:object Endpoint1Body {
def wrapperDecoder[B](bDecoder: Decoder[B], key:String): Decoder[B] = Decoder.instance { c =>
for {
results <- c.downField("wrapper").downField("results").as[Long]
body <- c.downField("wrapper").downField(key).as[B](bDecoder)
} yield DomainResponse(results, body)
}
val endpoint1BodyInnerDecoder = deriveDecoder[Endpoint1Body]
implicit val decoder: Decoder[Endpoint1Body] = wrapperDecoder(endpoint1BodyInnerDecoder, "dynamicKey")
}
java.lang.NullPointerException
at io.circe.Printer$PrintingFolder.onString(Printer.scala:320)
at io.circe.Printer$PrintingFolder.onString(Printer.scala:303)
at io.circe.Json$JString.foldWith(Json.scala:359)
at io.circe.JsonObject$LinkedHashMapJsonObject.appendToFolder(JsonObject.scala:343)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:370)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:303)
at io.circe.Json$JObject.foldWith(Json.scala:421)
at io.circe.JsonObject$LinkedHashMapJsonObject.appendToFolder(JsonObject.scala:343)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:370)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:303)
at io.circe.Json$JObject.foldWith(Json.scala:421)
at io.circe.Printer$PrintingFolder.onArray(Printer.scala:356)
at io.circe.Printer$PrintingFolder.onArray(Printer.scala:303)
at io.circe.Json$JArray.foldWith(Json.scala:390)
at io.circe.JsonObject$MapAndVectorJsonObject.appendToFolder(JsonObject.scala:450)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:370)
at io.circe.Printer$PrintingFolder.onObject(Printer.scala:303)
at io.circe.Json$JObject.foldWith(Json.scala:421)
at io.circe.Printer.print(Printer.scala:194)
at io.circe.Json.spaces2(Json.scala:128)
On 0.13.0
I'm guessing this means I have a string value of null somewhere?
Unfortunately they're out of my control
That is, if I can without SBT yelling at me
I've found a coursier bug in the midst of this :(
this is what you want, right? circe/circe#374
that links to circe/circe#1117 so maybe i'm wrong and it is supported by now.
import io.circe.generic.auto._
import io.circe.generic.semiauto._
import io.circe.generic.extras.auto._
import io.circe.generic.extras.semiauto._
sealed abstract class Foo(val label: String)
sealed case class Bar(override val label: String) extends Foo(label)
val t: Encoder[Foo] = deriveConfiguredEncoder
I've reduced my above problem to that
What's the preferred approach then?
I only need the abstract class for programming -- for (de)serialization I just want to (de)serialize all the concrete child case classes
you need it if you want to use deriveConfiguredEncoder
(also, keep only import io.circe.generic.extras.semiauto._. That's all you need in this example)
basically if you're using circe-generic-extras package, you don't really need circe-generic as the former is a superset (just slower to compile I guess because it has more features)
alright, thanks
circe is kidding me...
so I had a
@ConfiguredJsonCodec sealed abstract class Foo(...) { ... } with object Foo { ... } and @ConfiguredJsonCodec sealed case class Bar(...) { ... } with object Bar { ... } and Circe would fail on val enc: Encoder[Foo] = deriveConfiguredEncoder.
After removing the companion objects, it worked.
so at least a note would have been nice
The reason why it is deprecated is precisely because the name clashes and causes trouble :)
that is a bit confusing to newcomers :-)
Yeah the worst is the error messages because it's unclear whether you're missing a Configuration in scope or an encoder/decoder instance for one of your fields. Oh and duplicate implicits will trigger the same error too :D
This is a scala issue in general (with missing implicits). Super happy it's fixed in Scala 3
