Hume is a library for building event-sourced state machines in Elixir.

It provides a framework for defining state machines that can handle events, maintain state, and take snapshots of their state for efficient recovery.

The library leverages Elixir's GenServer for process management and can use ETS for event storage. It also includes a mechanism for transferring ETS table ownership using a "heir" process.

Features

• Define state machines using a simple behaviour.
• Handle events and update state accordingly.
• Persist events to an event store (in-memory or ETS).
• Take snapshots of the current state for efficient recovery.
• Transfer ETS table ownership using a dedicated heir process.

Getting Started

To get started with Hume, you can define a state machine by creating a module that uses Hume.Projection and implements the required callbacks. You can then start the state machine process and send events to it.

Example

defmodule MyProjection do
  use Hume.Projection, use_ets: true, store: Hume.EventStore.ETS

  @impl true
  def init_state(_), do: %{}

  @impl true
  def handle_event({:add, key, value}, state),
    do: {:ok, Map.put(state || %{}, key, value)}

  @impl true
  def handle_event({:remove, key}, state),
    do: {:ok, Map.delete(state || %{}, key)}
end

Hume.EventStore.ETS.start_link([])
{:ok, pid} = Hume.start_link(MyProjection, stream: MyStream, projection: MyProjection)

{:ok, _} = Hume.publish(Hume.EventStore.ETS, MyStream, {:add, :foo, 42})
%{foo: 42} = Hume.state(pid)
{:ok, _} = Hume.publish(Hume.EventStore.ETS, MyStream, {:remove, :foo})
%{} = Hume.state(pid)