Hoare.Store behaviour (hoare v0.2.0)

Copy Markdown View Source

What a transition's commit needs from the datastore.

Three operations: a transaction serialised per record, a preloaded read under it, and the status write. An Ecto.Repo satisfies update/1 as is and needs the other two added:

defmodule MyApp.Repo do
  use Ecto.Repo, otp_app: :my_app, adapter: Ecto.Adapters.Postgres
  @behaviour Hoare.Store

  @impl Hoare.Store
  def transact_with_lock(lock, fun) do
    transact(fn ->
      query!("SELECT pg_advisory_xact_lock($1)", [:erlang.phash2(lock)])
      fun.()
    end)
  end

  @impl Hoare.Store
  def read(schema, id, preloads) do
    if record = get(schema, id),
      do: {:ok, preload(record, preloads)},
      else: {:error, :not_found}
  end
end

The record's schema supplies changeset/2, which update/1 receives with the new status. Hoare.Store.Memory is the store for tests.

Summary

Types

result()
subject()

Callbacks

read(schema, id, preloads)

Reads the record by id with preloads loaded, inside the caller's transaction.

transact_with_lock(lock, fun)

Runs fun inside a transaction that no other holder of lock shares; its result is the return.

update(changeset)

Types

result()

@type result() :: {:ok, term()} | {:error, term()}

subject()

@type subject() :: %{
  :__struct__ => module(),
  :id => term(),
  :status => atom(),
  optional(atom()) => term()
}

Callbacks

read(schema, id, preloads)

@callback read(schema :: module(), id :: term(), preloads :: [term()]) ::
  {:ok, subject()} | {:error, :not_found}

Reads the record by id with preloads loaded, inside the caller's transaction.

transact_with_lock(lock, fun)

@callback transact_with_lock(lock :: term(), fun :: (-> result())) :: result()

Runs fun inside a transaction that no other holder of lock shares; its result is the return.

update(changeset)

@callback update(changeset :: term()) :: {:ok, subject()} | {:error, term()}