Automatically populate event_type in EventStore.EventData

[OleMchls]

Hey there,

This is really a neat project! While I am digging into the codebase and the usage of this I was wondering why I need to set event_type in EventStore.EventData especially when data is a Struct. The library could internally call Atom.to_string/1 and only optionally allow an overwrite via setting event_type.

Would you folks be open to a PR?

[slashdotdash]

The event_type string can be optionally used when deserializing events by your configured serializer module.

Typically you'd create a module per event you persist:

events = [
  %EventData{
    event_type: "Elixir.ExampleEvent",
    data: %ExampleEvent{..},
    metadata: %{"user" => "user@example.com"}
  }
]

:ok = EventStore.append_to_stream(source_stream_uuid, 0, events)

The deserialize/2 function in the EventStore.Serializer behaviour module is passed the event_type for you to use as necessary in your serializer.

defmodule EventStore.RecordedEvent do
  def deserialize(%RecordedEvent{} = recorded_event, serializer) do
    %RecordedEvent{data: data, metadata: metadata, event_type: event_type} = recorded_event

    %RecordedEvent{
      recorded_event
      | data: serializer.deserialize(data, type: event_type),
        metadata: serializer.deserialize(metadata, [])
    }
  end
end

The example JSON serializer, using the Poison library, deserializes events using the type option as follows:

defmodule EventStore.JsonSerializer do
  @behaviour EventStore.Serializer

  def serialize(term) do
    Poison.encode!(term)
  end

  def deserialize(binary, config) do
    type =
      case Keyword.get(config, :type, nil) do
        nil -> []
        type -> type |> String.to_existing_atom() |> struct
      end

    Poison.decode!(binary, as: type)
  end
end

Populating the event_type field is not done automatically to allow you use your own preferred serialization and type name mapping. However, this is all done for you automatically when using Commanded with the EventStore.

[OleMchls]

I was thinking about something along the lines of

  defp map_to_recorded_event(
         %EventData{
           data: %{__struct__: event_type},
           event_type: nil
         } = event,
         created_at,
         serializer
       ) do
    %{event | event_type: Atom.to_string(event_type)}
    |> map_to_recorded_event(created_at, serializer)
  end

in lib/stream.ex line 169 before the current map_to_recorded_event definition.

That way you can remove event_type from all examples and let the Library figure out the correct event_type.

I'm happy to file a PR for this.

[slashdotdash]

Right, I understand what you're proposing thanks to the code example. Yes, it would be useful to allow the event_type to be defaulted as you suggest when nil.