@callback ack_event(adapter_meta(), pid(), Commanded.EventStore.RecordedEvent.t()) :: :ok

Acknowledge receipt and successful processing of the given event received from a subscription to an event stream.

@callback append_to_stream(
  adapter_meta(),
  stream_uuid(),
  expected_version(),
  events :: [Commanded.EventStore.EventData.t()]
) :: :ok | {:error, :wrong_expected_version} | {:error, error()}

Append one or more events to a stream atomically.

@callback child_spec(application(), config()) ::
  {:ok, [:supervisor.child_spec() | {module(), term()} | module()],
   adapter_meta()}

Return a child spec defining all processes required by the event store.

@callback delete_snapshot(adapter_meta(), source_uuid()) :: :ok | {:error, error()}

Delete a previously recorded snapshot for a given source

@callback delete_subscription(
  adapter_meta(),
  stream_uuid() | :all,
  subscription_name()
) :: :ok | {:error, :subscription_not_found} | {:error, error()}

Delete an existing subscription.

@callback read_snapshot(adapter_meta(), source_uuid()) ::
  {:ok, Commanded.EventStore.SnapshotData.t()} | {:error, :snapshot_not_found}

Read a snapshot, if available, for a given source.

@callback record_snapshot(adapter_meta(), Commanded.EventStore.SnapshotData.t()) ::
  :ok | {:error, error()}

Record a snapshot of the data and metadata for a given source

@callback stream_forward(
  adapter_meta(),
  stream_uuid(),
  start_version :: non_neg_integer(),
  read_batch_size :: non_neg_integer()
) :: Enumerable.t() | {:error, :stream_not_found} | {:error, error()}

Streams events from the given stream, in the order in which they were originally written.

@callback subscribe(adapter_meta(), stream_uuid() | :all) :: :ok | {:error, error()}

Create a transient subscription to a single event stream.

The event store will publish any events appended to the given stream to the subscriber process as an {:events, events} message.

The subscriber does not need to acknowledge receipt of the events.

@callback subscribe_to(
  adapter_meta(),
  stream_uuid() | :all,
  subscription_name(),
  subscriber(),
  start_from(),
  options()
) ::
  {:ok, subscription()}
  | {:error, :subscription_already_exists}
  | {:error, error()}

Create a persistent subscription to an event stream.

@callback unsubscribe(adapter_meta(), subscription()) :: :ok

Unsubscribe an existing subscriber from event notifications.

This should not delete the subscription.