Struct Store 

pub struct Store<C, M> { /* private fields */ }

A PostgreSQL-backed EventStore.

Defaults are intentionally conservative:

• Positions are global and monotonic (i64, backed by BIGSERIAL).
• Metadata is stored as jsonb (M: Serialize + DeserializeOwned).

Implementations

impl<C, M> Store<C, M>

where C: Sync, M: Sync,

pub const fn new(pool: PgPool, codec: C) -> Self

pub async fn migrate(&self) -> Result<(), Error>

Apply the initial schema (idempotent).

This uses CREATE TABLE IF NOT EXISTS style DDL so it can be run on startup.

Errors

Returns a sqlx::Error if any of the schema creation queries fail.

Trait Implementations

impl<C: Clone, M: Clone> Clone for Store<C, M>

fn clone(&self) -> Store<C, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C, M> EventStore for Store<C, M>

where C: Codec + Clone + Send + Sync + 'static, M: Serialize + DeserializeOwned + Send + Sync + 'static,

type Codec = C

Serialization codec.

type Error = Error

Store-specific error type.

type Id = Uuid

Aggregate identifier type.

type Metadata = M

Metadata type for infrastructure concerns.

type Position = i64

Position type used for ordering events and version checking.

fn codec(&self) -> &Self::Codec

async fn stream_version<'a>( &'a self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, ) -> Result<Option<Self::Position>, Self::Error>

Get the current version (latest position) for an aggregate stream.

fn begin<Conc: ConcurrencyStrategy>( &mut self, aggregate_kind: &str, aggregate_id: Self::Id, expected_version: Option<Self::Position>, ) -> Transaction<'_, Self, Conc>

Begin a transaction for appending events to an aggregate.

async fn append<'a>( &'a mut self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, expected_version: Option<Self::Position>, events: Vec<PersistableEvent<Self::Metadata>>, ) -> Result<(), AppendError<Self::Position, Self::Error>>

Append events with optional version checking.

async fn load_events<'a>( &'a self, filters: &'a [EventFilter<Self::Id, Self::Position>], ) -> LoadEventsResult<Self::Id, Self::Position, Self::Metadata, Self::Error>

Load events matching the specified filters.

async fn append_expecting_new<'a>( &'a mut self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, events: Vec<PersistableEvent<Self::Metadata>>, ) -> Result<(), AppendError<Self::Position, Self::Error>>

Append events expecting an empty stream.