在另一个聚合根的上下文中创建聚合根

Question

i'm currently struggling with the creation of instances in the ddd context. i have read and searched alot and sometimes thought that i have found the answer only to realize that it doesnt feel right while programming it.

This is my situation:

• I have two aggregate roots Scenario and Step . I made those AR because they encapsulate related elements of the domain and each AR should be in a consistent state.
• Multiple Steps can exist in the context of a Scenario . They can not exist on their own.
• The "name/natural id" of each Step in the context of its Scenario has to be unique. Changes in Scenario do not automatically influence its Steps and vice versa (eg Step doesnt care if Scenario changes some descriptions or images).
• Different Steps of a Scenario can be used, edited, etc. at the same time.

At the moment, each Step holds a reference to its Scenario by the corresponding natural identifier. The Scenario class doesnt know anything about its Steps , so it does not hold a collection with Step references.

How would i create a new Step for a given Scenario ?

1. Should i load the Scenario and call something like createNewStep(...) on it? That would not enforce the uniqueness constraint (that is in fact a business constraint and not a technical one), because Scenario doesnt know about its Steps . I would probably have to go with some kind of a "disconnected domain model" then or pass a repsoitory or service to the method to perform the checks.
2. Should i use a domain service that enforces the constraint, queries the repository, and finally creates and returns the Step ?
3. Should Scenario simply know about its Steps ? I think i would like to avoid this one, since that would create a ugly-to-maintain bidirectional relationship.

One could imagine other use cases like a Step shall be classified by options that are provided by the specific Scenario . In this case and if there would be no constraints regarding the "collection" of Steps , i would probably go with the first "solution". Then again: if the classification is changed afterwards, the access to the scenario would be necessary to check for the allowed classifications. That brings me to a possible 4th solution:

4. Using some kind of "combination" of some possible solutions. Would it be a good idea to create the domain service (accessing everything needed) and use it as an argument of the method that needs it? The method would then call the service where needed and the "domain logic" stays in the entity/model.

Thank you in advance!

---

I'll just edit instead of copy paste answering ;)

Thank you all for your responses! :)

Pushing the steps back into the scenario would lead to some pretty big objects which i'm trying to avoid (the current running application really suffers from this). It seems that its pretty much alike the Scrum-Example of Vaughns "Effective Aggregate Design" where he is using DomainServices to get smaller aggregates (i really dont know why i'm so uncertain about using domain services). Looks like i'll have to use domainservices or split the aggregates up into "StepName" and "StepDetails" as suggested.

Answer 1

For background, you should read what Greg Young has to say about set validation (via WaybackMachine ). In particular, you really need to evaluate, in the context of your solution, what is the business impact of having a failure?

Accept the failure and escalate is by far your easiest option. In what follows, I assume that the business impact of the failure is large, so we need to prevent it from happening.

The "name/natural id" of each Step in the context of its Scenario has to be unique

That's a classic set validation concern.

The first thing to do is challenge the assumptions in your model

Is your model the book of record for "name"? If your model isn't the authority, you have to be very cautious about introducing constraints. Understanding the boundaries of your model's authority is really important.

Is there an invariant that couples the name of a step to any other part of its state? Aggregate design discipline says that two pieces of state coupled by an invariant need to be in the same aggregate, but its silent about properties that don't participate in an invariant.

Is it reasonable to reject a name change while accepting other changes to a step? This is really a variation of the previous -- can tasks be split into two different commands (one involving name, one not) that can succeed or fail independently?

In short, the invariant may be telling you that "step name", as a piece of state, belongs in the scenario aggregate rather than in the step aggregate.

If you think about the problem from the perspective of a relational model, we're looking at a tuple (scenarioId, name, stepId), and the constraint says that (scenarioId, name) form a unique key. That's a hint that step name belongs to the scenario. In code, that signature looks like a scenario data structure that includes a Map<ScenarioName, ScenarioId> .

That won't necessarily solve all of your problems of course, but it is a step toward aligning the model with your actual business.

When that doesn't work...

The "real" answer is to move the step entity back into the scenario aggregate. One way to think about it is this -- all of the entities taken together form "the model" that we are keeping consistent. The aggregates aren't part of the business, per se; they are artificial, independent subdivisions within the model -- we identify and isolate aggregates as a performance optimization ; we can perform concurrent edits, and evaluate the validity of a command while loading a much smaller data set.

If the failures make the performance optimization too expensive, you take it out. So you can see that we have an estimate, of sorts, for what it means that the business impact is "large"; it needs to be bigger than the savings we get from using aggregates on the happy path.

Another possibility is to shift where you enforce the invariant. Relational databases are really really good at set validation. So maybe the right answer is to split the enforcement concern: put the invariant into your schema as a constraint, and ignore that constraint in code.

This isn't ideal for a number of reasons -- you've effectively "hidden" the constraint, you've introduced a constraint on the kind of data store that you use for your aggregates, you've introduced a constraint that requires that you store your step aggregates in the same database as the scenario they belong to, and so on. If you squint, you'll see that this is really just the "make the step entities part of the scenario" solution, but in disguise.

But keep in mind: part of the point of domain-driven-design is that we can push back on the business when the code is telling us that the business model itself is wrong . Where's the cost benefit analysis?

Here's the thing about uniqueness constraints: the model enforces uniqueness, not correctness . Imagine a data race, two different commands that each claim the same "name" for a different step in the scenario -- perhaps caused by a data entry error. The model, presumably, can't tell which command is "right", so it's going to make some arbitrary guess (most likely, first command wins). If the model guesses wrong, it has effectively blocked the client that provided correct data!

In cases where the model is the authority, uniqueness constraints can make sense -- the SeatMap aggregate can enforce the constraint that only one ticket can be assigned to a seat at any given time, because it is the authority for assignment.