Struct SqlOutbox 

pub struct SqlOutbox { /* private fields */ }

A durable Outbox backed by a relational table on an AnyPool.

Clone-cheap: holds only the pool handle (itself an Arc internally).

Implementations

impl SqlOutbox

pub const DEFAULT_TABLE: &'static str = "outbox"

Default table name used when constructed with SqlOutbox::new.

pub const CREATE_TABLE_SQL: &'static str = "\ CREATE TABLE IF NOT EXISTS outbox ( id TEXT NOT NULL PRIMARY KEY, aggregate_type TEXT NOT NULL, aggregate_id TEXT NOT NULL, event_type TEXT NOT NULL, sequence BIGINT NOT NULL, payload TEXT NOT NULL, occurred_at TEXT NOT NULL, published INTEGER NOT NULL DEFAULT 0, published_at TEXT )"

Portable DDL for the outbox table (default table name), created only if absent. Run once at startup via SqlOutbox::ensure_schema, or apply it through your migration tooling.

pub fn new(pool: AnyPool) -> Self

Wrap an existing pool, using the DEFAULT_TABLE table name.

pub fn pool(&self) -> &AnyPool

Borrow the underlying pool.

pub async fn ensure_schema(&self) -> Result<(), DataError>

Create the outbox table if it does not exist.

Uses the bundled CREATE_TABLE_SQL; safe to call repeatedly. For non-default table names, run equivalent DDL yourself.

pub async fn fetch_unpublished_skip_locked( &self, limit: usize, ) -> Result<Vec<OutboxEntry>, DataError>

Claim up to limit unpublished rows on PostgreSQL using FOR UPDATE SKIP LOCKED, so concurrent relay pollers receive disjoint batches.

This must run inside the caller’s transaction for the row locks to hold until commit; here it locks within an implicit single-statement transaction, which is enough to demonstrate the claim semantics. Pair it with mark_published before committing.

Available only under the postgres feature, since SKIP LOCKED is not portable across all backends.

Trait Implementations

impl Clone for SqlOutbox

fn clone(&self) -> SqlOutbox

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Outbox for SqlOutbox

fn enqueue<'life0, 'async_trait>( &'life0 self, entries: Vec<OutboxEntry>, ) -> Pin<Box<dyn Future<Output = Result<(), DataError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Persist a batch of entries (idempotent on id is the implementation’s responsibility; the in-memory impl simply appends).

fn fetch_unpublished<'life0, 'async_trait>( &'life0 self, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<OutboxEntry>, DataError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return up to limit unpublished entries, oldest first.

fn mark_published<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [OutboxId], ) -> Pin<Box<dyn Future<Output = Result<(), DataError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark the given entries published (no-op for ids that are absent or already published).