Turn your Event Models into Verified Contracts.

context Ordering {

  type ItemList = Item[]
  type Reason = String

  command PlaceOrder {
    items: ItemList
  }

  command CancelOrder {
    reason: Reason
  }

  command ShipOrder {
    trackingId: String
  }

  event OrderPlaced {
    items: ItemList
    total: Number
  }

  event OrderCancelled {
    reason: Reason
  }

  event OrderShipped {
    trackingId: String
  }

  decider Order {
    commands: PlaceOrder, CancelOrder, ShipOrder
    events:   OrderPlaced, OrderCancelled, OrderShipped
    state:    Draft | Placed(items: ItemList) | Shipped | Cancelled
    initial:  Draft
    terminal: Shipped, Cancelled

    decide(PlaceOrder, Draft) {
      require items.length > 0
        else reject "Order must have items"
      require total >= 10.00
        else reject "Minimum order: 10 EUR"

      -> [OrderPlaced { items, total }]
    }

    decide(CancelOrder, Placed) {
      require not shipped
        else reject "Already shipped"

      -> [OrderCancelled { reason }]
    }

    decide(ShipOrder, Placed)
      -> [OrderShipped { trackingId }]

    evolve(Draft, OrderPlaced)      -> Placed { items: items }
    evolve(Placed, OrderCancelled)  -> Cancelled
    evolve(Placed, OrderShipped)    -> Shipped

  }
}