I was tweeting something about having separate “DDD” and “ORM” entities in a project in a project, and that I don’t understand this. There were some great comments and questions, thanks a lot for that! To be honest, I understand more about it now. In this article I’ll try to provide some more information about this.
I’m glad many developers want to use input from the book “Domain-Driven Design” by Eric Evans to improve their domain model. I recommend reading this book and getting your information from the source, because unfortunately the internet, tweets, e-books, including my own books, aren’t able to reflect a full, nor a correct view of everything there is to find out about this topic. All too often DDD is completely misinterpreted to be “an elitist, dogmatic approach to programming, where we use DTOs, layers, and CQRS”…
I think some programmers, myself included, want to escape from the framework-coupled, hype-inspired mess that web application development often seems to be. Unfortunately, while trying to move in the opposite direction, they end up with a lot of code that is written for the sake of decoupling. Or maybe it happens because they want to try something new and not-boring, something that can’t be generated from the command-line with make:entity.
Back in the days when Symfony 2 adopted annotations for routing, and Doctrine ORM did the same for its mapping configuration, I was one of the first to be against that, pointing out that it’s “framework coupling”. I mean, “Are you coupled to the framework?!”
Ever since I’ve been thinking, experimenting, and writing a lot about this topic (e.g. my book about application architecture, and an older article about ORMless). In the end I think our applications need framework coupling in certain areas, and in other areas, like the domain model, they are better off being decoupled.
But full decoupling is usually not the best choice. Rather, 80% decoupling is fine 😉 As an example, it seems that some would like to have DDD entities that are fully decoupled from the ORM. They interpret this to mean that you can’t have ORM annotations in your entity, or that you can’t use specialized collection classes like Doctrine ORM forces you to have. This coupling is by no means dangerous, and certainly doesn’t get in the way, as long as:
- We can instantiate and modify these entities without a runtime dependency on the database.
- We can retrieve data from these entities without a runtime dependency on the database.
Once this is the case, you can even test their behavior in a unit test, because these are the only requirements for that. It does mean that most entities-in-the-wild aren’t good entities, because calling methods on them is most likely to trigger database queries (e.g. lazy-loading for child entities or referenced entities). If you use an Active Record implementation like Eloquent, many more methods will trigger database queries.
And this is where DDD comes in, with its aggregate design rules. I often refer to an excellent series of articles on this topic, by Vaughn Vernon. In summary:
- An aggregate should guarantee its own consistency, establishing relevant domain invariants (i.e. it should prevent itself from being in an invalid or incomplete state).
- Reference other aggregates by their ID (i.e. don’t pass related entities as objects, or load them lazily).
- Aggregates should be small (i.e. don’t let it manage child entities or related entities).
We can learn a lot from these DDD patterns to make our models better, and we can in most cases accomplish this while using our current ORM and its entities or model objects. We just upgrade these existing objects with insights from the DDD book; adding intention-revealing methods, making state changes in meaningful chunks instead of on a per-field basis, throwing exceptions whenever a consistent state is in danger, etc. There may be some things we have to do to please the ORM, but nothing that messes up much with our domain model. A good rule of thumb is to focus on the public methods of the entity, and ignore what goes on behind the scenes (good old encapsulation).
There is one situation where upgrading existing ORM entities to DDD entities isn’t going to work: when you want to evolve the design of your aggregates, without also evolving the database schema. I don’t have experience with this. Whenever
Truncated by Planet PHP, read more at the original (another 1503 bytes)
