Hello @gregjohnson,
Come join us on the Elixir Slack: https://elixir-lang.slack.com/ in the #commanded channel if you are looking for more timely help. There are a number of us there.
If you are wanting to wait for an event handler to catch up to a particular event, one way to do it would be to publish an event over PubSub and wait for that event before moving on.
As an example, say you want to dispatch an OrderWidget command and wait for your OrderHandler to project an OrderSummary record for a corresponding WidgetOrdered event. For the example the order is received via a REST API controller:
defmodule Foo.OrderController do
def create(conn, order_params) do
# listen for all order summary events
Phoenix.PubSub.subscribe(Foo.PubSub, "order_summaries")
# dispatch the command
{:ok, %{aggregate_version: version}} =
Foo.CommandedApp.dispatch(command, include_execution_result: true)
# wait for the handler to process up to the event
receive do
{:order_summarized, v} when v >= version ->
# the handler has run at least as far as we want
# query for the summary and return a result
after
5000 ->
# we've waited long enough
# tell the caller that we accepted their order, but
# we're having trouble... =(
end
# we're done listening for events
Phoenix.PubSub.unsubscribe(Foo.PubSub, "order_summaries")
end
end
The handler might look something like:
defmodule Foo.OrderHandler
use Commanded.Event.Handler,
application: Foo.CommandedApp,
name: "OrderHandler"
def handle(%WidgetOrdered{} = event, metadata) do
# write the OrderSummary record to the database
summary = ...
# broadcast over pubsub that we've handled this event
Phoenix.PubSub.broadcast(Foo.PubSub, "order_summaries", {:order_summarized, metadata.stream_version})
:ok
end
You could use strong consistency as mentioned in the docks, but that try to avoid that where possible.
Finally, you might also try to get away with returning the input params as result: if you have successfully dispatched the command, then we know the input params were good:
defmodule Foo.AddressController do
def update(conn, %{"id" => id, "street" => street, "city" => city}) do
command = %ChangeAddress{address_id: id, street: street, city: city}
:ok = Foo.CommandedApp.dispatch(command)
# we know street and city have been accepted, so we can safely return them
json(conn, %{address_id: id, street: street, city: city})
end
end
