# datum-persistence
`datum-persistence` provides event-sourced and durable-state actor behaviors, byte-oriented storage
SPIs, schema adapters, CQRS query capabilities, and production PostgreSQL and RocksDB backends for
Datum. Behavior construction is side-effect-free; recovery and storage I/O begin at `spawn`.
## Features
| `protobuf` | Yes | `ProstSerializer` for explicit-id, explicit-manifest `prost::Message` payloads |
| `postgres` | No | `PostgresPersistence`: journal, snapshots, and durable state through SQLx/Tokio |
| `rocksdb` | No | `RocksDbBackend`: embedded journal, snapshots, and durable state with configurable WAL durability |
| `cassandra` | No | `CassandraPersistence`: journal, snapshots, and LWT durable state over the async `scylla` CQL driver |
| `sharding` | No | `sharding::EventSourcedEntity::register` integration with `datum-cluster-sharding` |
## Minimal event-sourced behavior
```rust
use std::sync::Arc;
use datum_persistence::{
Effect, EventSourcedBehavior, EventSourcedRuntime, IdentityAdapter, MemoryJournal,
PersistenceError, PersistenceId, PersistenceResult, PersistenceSerializer, SerializerCatalog,
SerializerId,
};
#[derive(Clone, Copy)]
struct I64Serializer;
impl PersistenceSerializer<i64> for I64Serializer {
fn serializer_id(&self) -> SerializerId {
SerializerId::new(41)
}
fn manifest(&self, _value: &i64) -> String {
"counter-i64-v1".into()
}
fn serialize(&self, value: &i64) -> PersistenceResult<Vec<u8>> {
Ok(value.to_be_bytes().to_vec())
}
fn deserialize(&self, manifest: &str, payload: &[u8]) -> PersistenceResult<i64> {
if manifest != "counter-i64-v1" || payload.len() != 8 {
return Err(PersistenceError::Serialization("invalid counter frame".into()));
}
let mut bytes = [0_u8; 8];
bytes.copy_from_slice(payload);
Ok(i64::from_be_bytes(bytes))
}
}
#[tokio::main]
async fn main() -> PersistenceResult<()> {
let behavior = EventSourcedBehavior::new(
PersistenceId::new("counter", "counter-1")?,
0_i64,
|_state, delta: i64| Effect::persist(delta),
|state: &i64, event: &i64| state + event,
)
.with_event_adapter(
IdentityAdapter,
SerializerCatalog::new(I64Serializer),
);
let handle = behavior
.spawn(EventSourcedRuntime::new(Arc::new(MemoryJournal::new())))
.await?;
handle.tell(2)?;
handle.tell(3)?;
let current = handle.state().await?;
assert_eq!(current.state, 5);
assert_eq!(current.sequence_nr.as_u64(), 2);
handle.stop();
Ok(())
}
```
See the [Persistence guides](../../docs/guides/persistence.md) for event sourcing, durable state,
backend setup, read-side projections, schema evolution, and cookbook recipes.