Case class inheritance is prohibited, but how to model dependency from library? - scala

Question

I have three distinct Scala projects, one of them consists of only models which are used in both of the other Scala projects (hereinafter referred to as library). One of the three projects is a Play web application and I want to persist the models from the library in MongoDB (code resides in Play app).
So in my library I have the following model:
case class MyUser(id: UUID = UUID.randomUUID(), timestamp: Instant = Instant.now, name: String)
To persist instances of MyUser in my Play app, I would usually go with this model:
case class MyUser(var _id: Option[BSONObjectID] = None,
id: UUID,
timestamp: Instant,
name: String,
var created: Option[DateTime] = None,
var updated: Option[DateTime] = None
) extends Temporal
Now I am searching for a way to morph MyUser of my library to the corresponding class in my Play app, so I thought I would do something like this:
case class MyUser(var _id: Option[BSONObjectID] = None,
var created: Option[DateTime] = None,
var updated: Option[DateTime] = None
) extends lib.MyUser with Temporal
However, now I get the following error:
case-to-case inheritance is prohibited. To overcome this limitation, use extractors to pattern match on non-leaf nodes.
I thought about doing something like this:
case class MyUser(var _id: Option[BSONObjectID] = None,
user: lib.MyUser,
var created: Option[DateTime] = None,
var updated: Option[DateTime] = None
) extends Temporal
How can I design this the right way?

Answer 1

First, what the error tells you is that you shouldn't have a case class for a class which is extended. The thing it says about extractors is basically that, should the need arise to pattern match on a parent class (which is what the case of case class comes from, easy pattern matching), you can always write custom extractors for it.
However, this does not apply in your case, since you cannot change the fact that your lib exposes case classes.
The other solution, is to consider that there is no inheritance between your two classes. Indeed, one is the representation of a user, while the other is the representation of a storage unit containing a user. So it looks like your proposed solution has some meaning after all.
Still, it might seem cumbersome to have to add a field, both in the serialized object (in Mongo) and in the JVM class, where you will need to always do mongoUser.user to get a lib.MyUser from a MyUser...
One elegant (IMHO) solution is to keep this field user: lib.MyUser, but to have your serialization flatten this field to the top level of the BSON object, so that a serialized MyUser will look like
{
_id: ObjectId(_),
id: 123456789abc-1234-1234-1234,
...
}
as if you had inherited the fields of lib.MyUser.
deserialization
Now, whenever you want to get a lib.MyUser from Mongo, for read purposes only, you can deserialize it directly in this format, ignoring the added fields. If you need to do some updates on it however, you will have to deserialize it as a MyUser, to be able to update this particular BSON document.
scala usage
When you have deserialized the object as a MyUser (say, for an update), you might still want an easy access to all fields exposed in lib.MyUser, without having to access the field user every time. This can be done with an implicit conversion.
generalization
By the way, you can do this for any object that you want serialized, in a generic way...
To sum it all up
case class MongoRepr[T](_id: Option[BSONObjectId]
value: T,
created: Option[DateTime],
updated: Option[DateTime])
object MongoRepr {
//implement flattened (de)serialization, this depends on your
// mongo driver and what you're using for serialization (JSON/BSON)
def handler[T](implicit handlerT: BSONHandler[T]): BSONHandler[MongoRepr[T]] = ???
implicit def toValue[T](repr: MongoRepr[T]): T = repr.value
}