JSON encoding of case classes with the same name in different packages

I’m working with a large collection of case classes that extend a sealed trait. In order to avoid naming collisions these case classes are grouped into different objects (they could also be grouped in packages).

For instance I have an object of type Tabs.OnCreated and another of type Windows.OnCreated. The JSON representation only contains the simple class name though, so it’s impossible to distinguish the two types. The decoder just creates an instance of the first type.

I know this is probably a very special case. Still I’m wondering if there’s a way to support that kind of structure in Circe. I guess we’d need something like the full class name as discriminator in the JSON representation.

Minimal example below:

import io.circe.parser.decode
import io.circe.syntax._
import io.circe.generic.auto._

sealed trait Event
object Tabs { // could also be package tabs, same result
  case class OnCreated(id: String) extends Event
}
object Windows {
  case class OnCreated(id: String) extends Event
}

object CirceEval extends App {
  val tabOnCreated: Event = Tabs.OnCreated("tab created")
  val tabOnCreatedJson = tabOnCreated.asJson.toString()
  val decodedTabEvent = decode[Event](tabOnCreatedJson)
  println(tabOnCreatedJson)
  println(decodedTabEvent)
  println(decodedTabEvent.map(_.getClass))

  val windowOnCreated: Event = Windows.OnCreated("window created")
  val windowOnCreatedJson = windowOnCreated.asJson.toString()
  val decodedWindowEvent = decode[Event](windowOnCreatedJson)
  println(windowOnCreatedJson)
  println(decodedWindowEvent)
  println(decodedWindowEvent.map(_.getClass))
}

Output:

{
  "OnCreated" : {
    "id" : "tab created"
  }
}
Right(OnCreated(tab created))
Right(class CirceEval$Tabs$OnCreated)

{
  "OnCreated" : {
    "id" : "window created"
  }
}
Right(OnCreated(window created))
Right(class CirceEval$Tabs$OnCreated)

[travisbrown]

I’d be inclined not to provide special support for this case, since Shapeless’s generic representation doesn’t include the necessary information, and since there are potentially lots of ways the discriminator key could be chosen. Writing explicit instances for the top level isn’t too bad:

import cats.syntax.functor._
import io.circe.{ Decoder, Encoder, Json }
import io.circe.generic.auto._
import io.circe.parser.decode
import io.circe.syntax._

sealed trait Event

object Tabs {
  case class OnCreated(id: String) extends Event
}

object Windows {
  case class OnCreated(id: String) extends Event
}

object Event {
  implicit val encodeEvent: Encoder[Event] = Encoder.instance {
    case e @ Tabs.OnCreated(_)    => Json.obj("Tabs.OnCreated"    -> e.asJson)
    case e @ Windows.OnCreated(_) => Json.obj("Windows.OnCreated" -> e.asJson)
  }

  private val decodeT = Decoder[Tabs.OnCreated].prepare(_.downField("Tabs.OnCreated"))
  private val decodeW = Decoder[Windows.OnCreated].prepare(_.downField("Windows.OnCreated"))

  implicit val decodeEvent: Decoder[Event] = decodeT.or(decodeW.widen[Event])
}

What do you think?

[travisbrown]

I’m going to go ahead and close this since I don’t want to stray too far from Shapeless’s generic representation for the basic case, and since master now supports transforming the constructor name via implicit configuration after #648 / #684.