Struct PostgresInboxStore 

#[non_exhaustive]
pub struct PostgresInboxStore { /* private fields */ }

Reliar’s PostgreSQL inbox provider (inbox contract §3). A separate type from crate::PostgresOutboxStore: the inbox stores no payload, so it needs no Serializer type parameter and none of the outbox’s lease/ordering/retention settings. Same crate, same schema, same crate::migrate. Cheap to clone — wraps a PgPool; no outer Arc required.

Implementations

impl PostgresInboxStore

pub async fn connect( pool: PgPool, settings: PostgresInboxSettings, ) -> Result<Self, PostgresInboxError>

Verifies the server version (ADR 0041) and then the search_path (ADR 0018/§20.1), in that order — exactly as crate::PostgresOutboxStore::connect does: a wrong server version explains a missing relation, and the reverse is never true. Logs a tracing::warn! when a same-named table also exists in another schema on the path.

Errors

Returns PostgresInboxError::UnsupportedServerVersion, PostgresInboxError::NotMigrated (the relation itself is missing), PostgresInboxError::SchemaNotOnSearchPath (it exists, but not on the configured schema), or PostgresInboxError::Database for a connection failure during verification.

use reliar_store_postgres::{PostgresInboxSettings, PostgresInboxStore};
use sqlx::postgres::PgPoolOptions;

let pool = PgPoolOptions::new()
    .connect(&std::env::var("DATABASE_URL")?)
    .await?;
let store = PostgresInboxStore::connect(pool, PostgresInboxSettings::default()).await?;

Trait Implementations

impl Clone for PostgresInboxStore

fn clone(&self) -> PostgresInboxStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PostgresInboxStore

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

Formats the value using the given formatter.

impl InboxDeadLetters for PostgresInboxStore

fn list_dead( &self, query: InboxDeadQuery, ) -> impl Future<Output = Result<Vec<InboxRecord>, Self::Error>> + Send

ORDER BY dead_at, id is normative: database-authored death time is the keyset’s leading column, and the unique row id breaks ties.

type Error = PostgresInboxError

A failure of the call.

fn retry_dead( &self, ids: &[InboxRecordId], ) -> impl Future<Output = Result<u64, Self::Error>> + Send

Clears dead_at, resets attempts to 0, keeps last_error for audit, sets updated_at = now(). Affects only rows with dead_at IS NOT NULL. Returns the number of rows affected.

fn purge_dead( &self, ids: &[InboxRecordId], ) -> impl Future<Output = Result<u64, Self::Error>> + Send

Deletes dead rows by id, regardless of retention. Returns the number of rows affected.

impl<'c> InboxStore<Transaction<'c, Postgres>> for PostgresInboxStore

fn claim( &self, tx: &mut Transaction<'c, Postgres>, scope: &InboxScope, message: InboxMessage<'_>, ) -> impl Future<Output = Result<InboxClaim, Self::Error>> + Send

The three-statement claim (inbox contract §3.1): the in-flight advisory-lock guard, the INSERT … ON CONFLICT DO NOTHING claim, and — only when nothing was inserted — the state read that decides AlreadyCompleted/Dead vs. Claimed.

fn complete( &self, tx: &mut Transaction<'c, Postgres>, scope: &InboxScope, id: MessageId, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Marks the row completed in the caller’s transaction. Zero rows affected ⇒ NotClaimed (including a row that has since gone dead — the guard is completed_at IS NULL AND dead_at IS NULL).

fn fail( &self, scope: &InboxScope, message: InboxMessage<'_>, error: &(dyn Error + 'static), ) -> impl Future<Output = Result<InboxFailure, Self::Error>> + Send

Records a failed attempt on this store’s own pool, guarded by completed_at IS NULL, and bounds it at settings.max_attempts atomically with the increment (ADR 0042 A.2.4).

async fn find( &self, scope: &InboxScope, id: MessageId, ) -> Result<Option<InboxRecord>, Self::Error>

Reads a row for diagnostics. No Reliar code path calls it. No span — the inbox contract’s observability table (§4) does not list find, since no Reliar code path calls it.

fn purge( &self, request: InboxPurgeRequest, ) -> impl Future<Output = Result<InboxPurgeReport, Self::Error>> + Send

One bounded pass, three statements, each capped at request.batch_size: the completed-row, incomplete-row and dead-row deletes.

type Error = PostgresInboxError

What inbox operations fail with. Classify so a caller can log a permanent failure differently from a transient one without a downcast.

fn process<H>( &self, tx: &mut Tx, scope: &InboxScope, message: InboxMessage<'_>, handler: &H, ) -> impl Future<Output = Result<InboxOutcome<<H as InboxHandler<Tx>>::Output>, InboxProcessError<Self::Error, <H as InboxHandler<Tx>>::Error>>> + Send

where H: InboxHandler<Tx> + Sync, Tx: Send,

The happy path in one call: claim, branch, run handler, complete.