Enum EnqueueError 

#[non_exhaustive]
pub enum EnqueueError<E> {
    Serialize {
        source: E,
    },
    Duplicate {
        id: MessageId,
    },
    Database {
        source: Error,
    },
}

crate::PostgresOutboxStore’s reliar_outbox::OutboxEnqueue::enqueue_envelope failures. Enqueuing runs on the host’s write path, where the host decides whether to retry its own transaction, so this implements Classify on the same rules as PostgresOutboxError rather than making the host re-derive which SQLSTATEs are worth retrying.

A duplicate reliar_core::MessageId aborts the caller’s transaction rather than silently losing the message. The bare PostgresOutboxStore below leans on its default type parameter, gated on the default json feature; without it this block still shows the shape but is not compiled.

use reliar_core::{Classify, Message};
use reliar_outbox::OutboxEnqueue;

#[derive(serde::Serialize, serde::Deserialize)]
struct OrderPlaced;
impl Message for OrderPlaced {
    const TYPE: &'static str = "orders.placed";
    const VERSION: u16 = 1;
}

let mut tx = pool.begin().await?;
if let Err(err) = store.enqueue(&mut tx, OrderPlaced).await {
    eprintln!("enqueue failed ({:?}): {err}", err.kind());
    tx.rollback().await?;
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Serialize

The configured reliar_core::Serializer rejected the body. Permanent — the same body serializes the same way every time.

Fields

source: E

The serializer’s own error.

Duplicate

The envelope’s MessageId already exists (ix_outbox_message_id violation, ADR 0044 §1) — enqueue uses a plain INSERT with no ON CONFLICT, so a reused id aborts the caller’s transaction rather than silently losing a message. Permanent — the id is already taken.

Fields

id: MessageId

The id the caller tried to reuse.

Database

Any other sqlx failure, classified by SQLSTATE exactly as PostgresOutboxError::Database (including 42P01, which classifies permanent under the 42* rule).

Fields

source: Error

The underlying sqlx error.

Trait Implementations

impl<E: Error + Send + Sync + 'static> Classify for EnqueueError<E>

fn kind(&self) -> FailureKind

Whether the failure this error represents can succeed on retry.

impl<E: Debug> Debug for EnqueueError<E>

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

Formats the value using the given formatter.

impl<E: Display> Display for EnqueueError<E>

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

Formats the value using the given formatter.

impl<E: Error + 'static> Error for EnqueueError<E>

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.