Struct Store 

pub struct Store<S> { /* private fields */ }

Shared handle to a RawEventStore backend.

Store wraps the backend in an Arc, making it cheap to clone and safe to share across tasks. It carries no codec, upcaster, or aggregate binding — it is just a database handle.

Use repository() to obtain a RepositoryBuilder, then configure a codec and upcaster before calling .build().

Example

// Open flows left-to-right; `.into_store()` is the de-nested `Store::new`.
let store = FjallStore::builder("path").open()?.into_store();

// One per-aggregate facade per aggregate; the store is the shared substrate.
let orders = store.repository::<Order>().codec(OrderCodec).build();
let users  = store.repository::<User>().codec(UserCodec).build();

Implementations

impl<S: RawEventStore> Store<S>

pub fn repository<A>(&self) -> RepositoryBuilder<S, NeedsCodec, A>

Start building a repository facade for aggregate A over this store.

Name the aggregate once here (store.repository::<Order>()); the resulting EventStore<S, C, A> then implements Repository<A> for exactly that A, so load/save infer the aggregate with no per-call annotation. The store itself stays multi-aggregate — mint one facade per aggregate type.

The builder starts with NeedsCodec in every feature configuration — set a codec with .codec(), or, under the json feature, the .json() convenience, before calling .build(). Keeping this return type feature independent is what makes json purely additive (issue #211): a transitive dependency enabling json can never flip this signature out from under code that spelled NeedsCodec.

Example

let store = Store::new(backend);

// Custom codec:
let orders = store.repository::<Order>().codec(MyCodec).build();
let order = orders.load(id).await?;        // AggregateRoot<Order> — inferred

// Built-in JSON codec (requires the `json` feature):
let orders = store.repository::<Order>().json().build();

impl<S> Store<S>

pub fn new(raw: S) -> Self

Wrap a raw event store backend in a shared handle.

pub fn raw(&self) -> &S

Borrow the underlying raw store.

The escape hatch for users who need the substrate directly — when the Repository facade’s load / save isn’t flexible enough (e.g. you want to filter, peek, branch, or chain custom combinators during load). Hand the borrowed &S to RawEventStore::read_stream / RawEventStore::append and compose your own chain via futures::StreamExt / futures::TryStreamExt.

Users who just want “load this aggregate” should stay on the facade.

Example

Substrate-path read: convert the adapter error eagerly and drive a custom fold.

use futures::TryStreamExt;
use mnesis_store::{RawEventStore, Store, StreamKey};

async fn count_events<S: RawEventStore>(
    store: &Store<S>,
    id: &StreamKey,
    from: mnesis::Version,
) -> Result<usize, MyError> {
    let stream = store.raw().read_stream(id, from).await.map_err(MyError::Adapter)?;
    stream.map_err(MyError::Adapter).try_fold(0usize, |acc, _| async move { Ok(acc + 1) }).await
}

Trait Implementations

impl<S: AtomicAppend> AtomicAppend for Store<S>

Store<S> forwards AtomicAppend to its inner backend (issue #247). With Store<S> already a RawEventStore, this gives it EventImporter for free via the blanket impl below — so a handle holder can store.import(..) without .raw().

async fn atomic_append_many( &self, writes: &[PlannedAppend], ) -> Result<Option<Self::AllPosition>, AtomicAppendError<Self::Error>>

Append every write atomically. See the trait contract.

impl<S> Clone for Store<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Store<S>

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

Formats the value using the given formatter.

impl<S: RawEventStore> RawEventStore for Store<S>

Store<S> is itself a RawEventStore, forwarding every method to its inner backend.

This makes the handle the front door: store.append(..) / read_stream / read_all work directly, and — because EventExporter and EventImporter are blanket-impl’d for every RawEventStore (and RawEventStore + AtomicAppend) — store.export_stream(..) / store.import(..) come for free once Store<S> also forwards StreamLister / AtomicAppend (in the export / import modules). So a Store<S> holder never needs .raw() to back up or restore, and a Store<S> is substitutable wherever a RawEventStore-bounded value is expected. .raw() remains the escape hatch for reaching the concrete &S.

type Error = <S as RawEventStore>::Error

The error type for store operations.

type Stream = <S as RawEventStore>::Stream

The stream type for reading events.

type AllPosition = <S as RawEventStore>::AllPosition

The adapter-defined $all resume position. See AllPosition.

type AllStream = <S as RawEventStore>::AllStream

The stream type for an all-streams ($all) read.

async fn append( &self, id: &StreamKey, expected_version: Option<Version>, envelopes: PendingBatch<'_>, ) -> Result<Self::AllPosition, AppendError<Self::Error>>

Append events to a stream with optimistic concurrency.

async fn read_stream( &self, id: &StreamKey, from: Version, ) -> Result<Self::Stream, Self::Error>

Open a stream of events.

async fn read_all( &self, from: Option<Self::AllPosition>, ) -> Result<Self::AllStream, Self::Error>

Open a one-shot read over all streams, ordered by AllPosition.

fn into_store(self) -> Store<Self>

where Self: Sized,

Wrap this backend in a shared Store handle.

impl<S: StreamLister> StreamLister for Store<S>

Store<S> forwards StreamLister to its inner backend (issue #247), so a handle holder can store.list_streams() without .raw(). EventExporter then applies to Store<S> via the blanket impl above (Store<S> is itself a RawEventStore).

type StreamList = <S as StreamLister>::StreamList

The stream of stream ids.

async fn list_streams(&self) -> Result<Self::StreamList, Self::Error>

Open a one-shot stream over every stream id in the store, in no guaranteed order, terminating when exhausted.