Publishing events without a command or aggregate with commanded

Tam

Hi all, relatively new to using commanded and event sourcing, so trying to wrap my head around things.

Regarding event-centric Domain Driven Design, I’ve come to understand that events are the backbone of things that happen in a system, so everything should be modeled with them. It’s only at certain points where a decision must be made that a command should be used to drive that event.

I’d like to use commanded to facilitate writing those events into code, however I’m running into a bit of an issue: I haven’t found a way to publish events without a corresponding command and aggregate. This is not ideal, as the domains I’ve modeled do not all use aggregates.

Rather than hacking in one-time-use aggregates and fake commands, I would really rather have a way to publish events appropriately.

Is there any way that this can be done? Thank you to anyone for any help that they can give.

3 comments

#commanded

0 2058 3

2022-01-10 14:42:45 UTC

Showing Posts 1 to 3

Show Best Posts
Show All (oldest first)
Show All (newest first)

Tam

Ok, I figured it out after reading more carefully the Aggregate code.

The trick was that my original attempt at using EventStore.append_to_stream was missing event correlation and causation metadata. All I needed to do was use the Mapper to add that data back in and viola, I no longer need to keep an aggregate.

Here’s module I wrote that works for me.

Replace Core.Cmd.Evt with whatever you want to name the event dispatcher, and replace Core.Cmd with the module that has use Commanded.Application

defmodule Core.Cmd.Evt do
  alias Commanded.EventStore
  alias Commanded.Event.Mapper

  def dispatch(e) do
    dispatch(e, [])
  end

  def dispatch(event, opts) when is_struct(event) do
    dispatch([event], opts)
  end

  def dispatch(events, opts) when is_list(events) do
    EventStore.append_to_stream(
      Core.Cmd,
      Keyword.get(opts, :stream_id, "manual_event_stream"),
      Keyword.get(opts, :version, 0),
      Mapper.map_to_event_data(events,
        correlation_id: Keyword.get(opts, :correlation_id, UUID.uuid4()),
        causation_id: Keyword.get(opts, :causation_id, UUID.uuid4()),
        metadata: Keyword.get(opts, :metadata, %{})
      )
    )
  end
end

Post #1

Tam

Just wanted to note an update because it seems our posts are immutable (as expected for an Elixir community): the :version can probably be better off having :any_version instead of 0.

defmodule Core.Cmd.Evt do
  alias Commanded.EventStore
  alias Commanded.Event.Mapper

  def dispatch(e) do
    dispatch(e, [])
  end

  def dispatch(event, opts) when is_struct(event) do
    dispatch([event], opts)
  end

  def dispatch(events, opts) when is_list(events) do
    EventStore.append_to_stream(
      Core.Cmd,
      Keyword.get(opts, :stream_id, "manual_event_stream"),
      Keyword.get(opts, :version, :any_version),
      Mapper.map_to_event_data(events,
        correlation_id: Keyword.get(opts, :correlation_id, UUID.uuid4()),
        causation_id: Keyword.get(opts, :causation_id, UUID.uuid4()),
        metadata: Keyword.get(opts, :metadata, %{})
      )
    )
  end
end

The unfortunate downside with this technique is that the InMemoryEventStore can’t really be used for testing, but the positive side is that Mox can be a better substitute with the appropriate behaviour defined.

defmodule Core.Cmd.Evt.Behaviour do
  @callback dispatch(event :: map() | struct() | list(struct())) ::
              :ok | {:ok, term()} | {:error, reason :: term()}
  @callback dispatch(event :: list(struct()), opts :: keyword()) ::
              :ok | {:ok, term()} | {:error, reason :: term()}
end

with

# test/support/test_helper.exs
Mox.defmock(MockEvt, for: Core.Cmd.Evt.Behaviour)

and with functions that take in an event dispatcher parameter.

Post #2

slashdotdash

You should be able to use the Commanded.EventStore.append_to_stream/4 function to append one or more events to an event stream using the event store configured for the Commanded Application. The function expects a list of Commanded.EventStore.EventData structs to be given.

Using this function will allow different event stores to be used for different Mix environments, such as using the in-memory event store in the test enironment.

Post #3

— All posts loaded —