Struct Store 

pub struct Store { /* private fields */ }

A PostgreSQL-backed snapshot store with configurable policy.

This implementation stores snapshots in a dedicated PostgreSQL table (es_snapshots), using the same database as the event store for consistency.

Schema

The store uses the following table schema (created by migrate()):

CREATE TABLE IF NOT EXISTS es_snapshots (
    aggregate_kind TEXT NOT NULL,
    aggregate_id   UUID NOT NULL,
    position       BIGINT NOT NULL,
    data           JSONB NOT NULL,
    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (aggregate_kind, aggregate_id)
)

Example

use sourcery_postgres::{Store as EventStore};
use sourcery_postgres::snapshot::Store as SnapshotStore;
use sourcery_core::Repository;

let pool = PgPool::connect("postgres://...").await?;
let event_store = EventStore::new(pool.clone());
let snapshot_store = SnapshotStore::every(pool, 100);

// Run migrations
event_store.migrate().await?;
snapshot_store.migrate().await?;

let repo = Repository::new(event_store).with_snapshots(snapshot_store);

Implementations

impl Store

pub const fn always(pool: PgPool) -> Self

Create a snapshot store that saves after every command.

Best for aggregates with expensive replay or many events. See the policy guidelines in SnapshotPolicy for choosing an appropriate cadence.

pub const fn every(pool: PgPool, n: u64) -> Self

Create a snapshot store that saves every N events.

Recommended for most use cases. Start with n = 50-100 and tune based on your aggregate’s replay cost.

pub const fn never(pool: PgPool) -> Self

Create a snapshot store that never saves (load-only).

Use for read replicas, short-lived aggregates, or when managing snapshots externally.

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

Apply the snapshot schema (idempotent).

This uses CREATE TABLE IF NOT EXISTS style DDL so it can be run on startup alongside the event store migrations.

Errors

Returns a sqlx::Error if the schema creation query fails.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Store

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SnapshotStore<Uuid> for Store

type Error = Error

Error type for snapshot operations.

type Position = i64

Position type for tracking snapshot positions.

async fn load<T>( &self, kind: &str, id: &Uuid, ) -> Result<Option<Snapshot<Self::Position, T>>, Self::Error>

where T: DeserializeOwned,

Load the most recent snapshot for an aggregate.

async fn offer_snapshot<CE, T, Create>( &self, kind: &str, id: &Uuid, events_since_last_snapshot: u64, create_snapshot: Create, ) -> Result<SnapshotOffer, OfferSnapshotError<Self::Error, CE>>

where CE: Error + Send + Sync + 'static, T: Serialize, Create: FnOnce() -> Result<Snapshot<Self::Position, T>, CE>,

Whether to store a snapshot, with lazy snapshot creation.