Struct AckableEvent 

pub struct AckableEvent {
    pub event: ChangeEvent,
    /* private fields */
}

Event with acknowledgment capability for correct resume token semantics.

This type ensures that resume tokens are persisted AFTER the user successfully processes the event, providing at-least-once delivery semantics.

Important

You MUST call .ack() after successfully processing the event. If you don’t call .ack(), the resume token will not be persisted, and the stream cannot reliably resume after a crash.

Examples

use rigatoni_core::stream::{ChangeStreamListener, ChangeStreamConfig};
use futures::StreamExt;

let mut listener = ChangeStreamListener::new(
    collection,
    ChangeStreamConfig::default(),
    |_| Box::pin(async { Ok(()) }),
).await?;

while let Some(ackable) = listener.next().await {
    let ackable = ackable?;

    // Access the event
    let event = ackable.event_ref();
    println!("Processing: {:?}", event.operation);

    // Process the event
    process_event(event).await?;

    // IMPORTANT: Acknowledge after successful processing
    ackable.ack();
}

Fields

event: ChangeEvent

The change event

Implementations

impl AckableEvent

pub fn ack(self)

Acknowledge processing of this event, persisting the resume token.

Call this AFTER successfully processing the event to ensure at-least-once semantics. The token will be sent to a background persistence task asynchronously.

This method also updates the internal last_resume_token used for reconnection, ensuring that reconnection only resumes from successfully processed events.

If the persistence task has stopped, this will log a warning but not fail.

pub fn event_ref(&self) -> &ChangeEvent

Get a reference to the change event without consuming the AckableEvent.

Use this to access the event data while keeping the ability to call .ack() later.

pub fn into_event(self) -> ChangeEvent

Consume the AckableEvent and return the inner ChangeEvent.

Warning

After calling this, you cannot call .ack(). Only use this if you don’t want to persist the resume token.

Trait Implementations

impl Clone for AckableEvent

fn clone(&self) -> AckableEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AckableEvent

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

Formats the value using the given formatter.