3

I'm learning DDD and Hexagonal architecture, I think I got the basics. However, there's one thing I'm not sure how to solve: how am I showing data to the user?

So, for example, I got a simple domain with a Worker entity with some functionality (some methods cause the entity to change) and a WorkerRepository so I can persist Workers. I got an application layer with some commands and command bus to manipulate the domain (like creating Workers and updating their work hours, persisting the changes), and an infrastructure layer which has the implementation of the WorkerRepository and a GUI application.

In this application I want to show all workers with some of their data, and be abe to modify them. How do I show the data?

  1. I could give it a reference to the implementation of WorkerRepository. I think it's not a good solution because this way I could insert new Workers in the repository skipping the command bus. I want all changes going through the command bus.
  2. Okay then, I'd split the WorkerRepository into WorkerQueryRepository and WorkerCommandRepository (as per CQRS), and give reference only to the WorkerQueryRepository. It's still not a good solution because the repo gives back Worker entities which have methods that change them, and how are these changes will be persisted?
  3. Should I create two type of Repositories? One would be used in the domain and application layer, and the other would be used only for providing data to the outside world. The second one wouldn't return full-fledged Worker entities, only WorkerDTOs containing only the data the GUI needs. This way, the GUI has no other way to change Workers, only through the command bus.

Is the third approach the right way? Or am I wrong forcing that the changes must go through the command bus?

bhaclash
  • 33
  • 3

1 Answers1

2

Should I create two type of Repositories? One would be used in the domain and application layer, and the other would be used only for providing data to the outside world. The second one wouldn't return full-fledged Worker entities, only WorkerDTOs containing only the data the GUI needs.

That's the CQRS approach; it works pretty well.

Greg Young (2010)

CQRS is simply the creation of two objects where there was previously only one. The separation occurs based upon whether the methods are a command or a query (the same definition that is used by Meyer in Command and Query Separation, a command is any method that mutates state and a query is any method that returns a value).

The current term for the WorkerDTO you propose is "Projection". You'll often have more than one; that is to say, you can have a separate projection for each view of a worker in the GUI. (That has the neat side effect of making the view easier -- it doesn't need to think about the data that it is given, because the data is already formatted usefully).

Another way of thinking of this, is that you have a "write-only" representation (the aggregate) and "read-only" representations (the projections). In both cases, you are reading the current state from the book of record (via the repository), and then using that state to construct the representation you need.

As the read models don't need to be saved, you are probably better off thinking factory, rather than repository, on the read side. (In 2009, Greg Young used "provider", for this same reason.)

Once you've taken the first step of separating the two objects, you can start to address their different use cases independently.

For instance, if you need to scale out read performance, you have the option to replicate the book of record to a bunch of slave copies, and have your projection factory load from the slaves, instead of the master. Or to start exploring whether a different persistence store (key value store, graph database, full text indexer) is more appropriate. Udi Dahan reviews a number of these ideas in CQRS - but different (2015).

"read models don't need to be saved" Is not correct.

It is correct; but it isn't perhaps as clear and specific as it could be.

We don't need to create a durable representation of a read model, because all of the information that describes the variance between instances of the read model has already been captured by our writes.

We will often want to cache the read model (or a representation of it), so that we can amortize the work of creating the read model across many queries. And various trade offs may indicate that the cached representations should be stored durably.

But if a meteor comes along and destroys our cache of read models, we lose a work investment, but we don't lose information.

VoiceOfUnreason
  • 52,766
  • 5
  • 49
  • 91
  • I now realize that I slightly misinterpreted CQRS, but your answer cleared that up. And thank you for pushing me to the right direction with projections and read model factories! – bhaclash May 04 '16 at 07:56
  • "you are reading the current state from the book of record (via the repository)"... That's not what CQRS is at all. CQRS means independent read and a write models. If you do not bypass the domain model entirely for queries then the 2 are bound and cannot evolve completely independently of each other. I'm not saying constructing DTOs from the domain model is necessarily bad, but then you cannot say you are using a CQRS architecture. – plalx May 04 '16 at 10:19
  • "read models don't need to be saved" Is not correct. Read and write models must be independent. Events are projected onto the read model causing mutations, so you must save it on each event. You could of course project the whole event stream onto the read model every time, but that is not CQRS, and would simply not be fast enough for most use cases. – istepaniuk Sep 25 '18 at 14:52