Trait StateTransactionBackend 

pub trait StateTransactionBackend: Send + 'static {
    // Required methods
    fn load(
        &mut self,
        key: StateKey,
    ) -> impl Future<Output = Result<Option<StateRecordSnapshot>, StateStoreError>> + Send + '_;
    fn put(
        &mut self,
        record: StateRecord,
    ) -> impl Future<Output = Result<(), StateStoreError>> + Send + '_;
    fn delete(
        &mut self,
        key: StateKey,
    ) -> impl Future<Output = Result<(), StateStoreError>> + Send + '_;
    fn commit(self) -> impl Future<Output = Result<(), StateStoreError>> + Send
       where Self: Sized;
    fn rollback(
        self,
    ) -> impl Future<Output = Result<(), StateStoreError>> + Send
       where Self: Sized;
}

A unique, lifetime-free transaction; commit and rollback consume the owner.

Successful commits atomically publish every staged mutation with a serializable read/write outcome, including missing-key observations. Reads see this transaction’s preceding writes and tombstones. A failed or cancelled nonterminal operation invalidates further writes/commit and requires rollback cleanup. Dropping an uncommitted owner never commits. An admitted commit retains finalization authority after waiter loss.

The trait deliberately has no list or native snapshot operation. Upper consumers build history from their own immutable records and fenced heads.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
assert!(transaction.load(key.clone()).await?.is_some());
transaction.rollback().await?;
assert!(store.load(key).await?.is_none());

Required Methods

fn load( &mut self, key: StateKey, ) -> impl Future<Output = Result<Option<StateRecordSnapshot>, StateStoreError>> + Send + '_

Loads through the transaction, including earlier writes and tombstones.

Errors

Returns StateStoreError for a conflict, timeout, decoding failure, or unavailable transaction. A failed nonterminal operation invalidates the transaction; roll it back or drop it instead of attempting commit.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
let observed = transaction.load(key).await?.expect("staged record is visible");
assert_eq!(observed.record.value.as_ref(), &serde_json::json!(42));
transaction.rollback().await?;

fn put( &mut self, record: StateRecord, ) -> impl Future<Output = Result<(), StateStoreError>> + Send + '_

Stages a present record and advances its key revision by exactly one.

The first put or delete starts at revision one. Repeated writes count individually, including equal values; a retained tombstone is not a fresh key. Rollback discards staged revisions with the staged values.

Errors

Returns StateStoreError for a revision boundary, serialization failure, conflict, timeout, or unavailable transaction. A failure invalidates the transaction, so earlier staged writes cannot subsequently commit.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
assert_eq!(transaction.load(key).await?.expect("staged record").revision.get(), 1);
transaction.commit().await?;

fn delete( &mut self, key: StateKey, ) -> impl Future<Output = Result<(), StateStoreError>> + Send + '_

Stages a tombstone and advances the revision, including for an absent key.

Loads then return None. A later put increments the retained revision instead of resetting it, preventing delete/recreate ABA equality.

Errors

Returns StateStoreError for a revision boundary, conflict, timeout, or unavailable transaction. A failure invalidates the transaction.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.delete(key.clone()).await?;
assert!(transaction.load(key.clone()).await?.is_none());
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
assert_eq!(transaction.load(key).await?.expect("recreated record").revision.get(), 2);
transaction.commit().await?;

fn commit(self) -> impl Future<Output = Result<(), StateStoreError>> + Send

where Self: Sized,

Atomically commits all staged mutations and completes native cleanup.

Ok(()) proves commit. A conflict proves no mutations committed. A timeout, transport/finalization error or lost waiter can leave the outcome uncertain; it does not prove rollback. Reconcile an upper consumer’s durable receipt before retrying potentially committed work. Dropping the future after admission cannot revoke commit authority.

Errors

StateStoreError::TransactionConflict proves this transaction did not publish. Timeout, transport, or finalization errors can leave the outcome uncertain; inspect a durable application receipt before retrying. A previously failed nonterminal operation cannot publish its staged writes.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
transaction.commit().await?;
assert!(store.load(key).await?.is_some());

fn rollback(self) -> impl Future<Output = Result<(), StateStoreError>> + Send

where Self: Sized,

Rolls back all staged mutations and completes rollback cleanup.

Success leaves every committed key and revision unchanged. A primary failure must remain distinguishable from a cleanup failure.

Errors

Returns StateStoreError if native rollback or resource cleanup fails. Preserve any earlier operation failure as the primary error when reporting a separate rollback failure.

Examples

use storage_kit::{StateStore, StateStoreBackend, StateTransactionBackend};
use storage_kit::state::config::{StateStoreConfig, LanceStateStoreConfig};
use storage_kit::state::record::{StateKey, StateRecord};
let store = StateStore::connect(StateStoreConfig::lance(LanceStateStoreConfig::memory())).await?;
let key = StateKey::new("workflow", "run/1")?;
let mut transaction = store.begin_transaction().await?;
transaction.put(StateRecord::new(key.clone(), serde_json::json!(42))).await?;
transaction.rollback().await?;
assert!(store.load(key).await?.is_none());

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl StateTransactionBackend for StateTransaction