Offloading write facet with a learn mannequin

Think about the next enterprise requirement:

All of the merchandise needs to be reserved for a buyer on order submission.
Merely including objects to the cart doesn’t assure product availability.
Nevertheless, the shopper shouldn’t be ready so as to add a product that’s already unavailable.

Truly, it’s not any fancy requirement. I used to work on e-commmerce mission with such a characteristic.
When diving deeper into Area-driven design, I began eager about tips on how to correctly meet this requirement with DDD constructing blocks.

At first, the rule “the shopper shouldn’t be ready so as to add to the cart a product which is already out of inventory” gave the impression of an intuitive invariant to me.
I’ve even carried out a Stock::CheckAvailability command which was invoked on Stock::InventoryEntry combination root.

def check_availability!(desired_quantity)
  return except stock_level_defined?
  elevate InventoryNotAvailable if desired_quantity > availability
finish

In reality, It was doing nothing with the combination’s inner state. This methodology was simply elevating an error if the product was out of inventory.
It was a horrible candidate for a command. It obfuscated the combination’s code, which ought to keep minimalistic, and did no adjustments inside the system.

After I realized that my command made nothing however the learn, I began in search of an answer within the learn mannequin.
An environment friendly learn mannequin is finally constant. It isn’t an issue in our case.
In reality, putting an order simply after checking availability instantly on the combination root neither ensures success. Simply 1 ms after checking, it may change.
That’s simply because that command didn’t have an effect on the combination’s state.

So, I ready ProductsAvailability learn mannequin, which subscribes to Stock::AvailabilityChanged occasions.
I exploit it as a sort of validation if invoking Ordering::AddItemToBasket command makes any sense.

def add_item
  if Availability::Product.exists?(["uid = ? and available < ?", params[:product_id], params[:quantity]])
    redirect_to edit_order_path(params[:id]),
                alert: "Product not out there in requested amount!" and return
  finish
  command_bus.(Ordering::AddItemToBasket.new(order_id: params[:id], product_id: params[:product_id]))
  head :okay
finish

Classes that I’ve realized:

• Began to differentiate laborious enterprise guidelines which associate with some state change inside the system.
  Necessities of this sort are, actually, good candidates for aggregates invariants.
• Observed that some necessities enhance person expertise however aren’t so essential to affecting combination design.
  Checking these, we don’t look after 100% consistency with a write facet.
• It’s OK to have some learn fashions that aren’t strict for viewing functions.