mod slice;
use std::{pin::Pin, sync::Arc};
use datum::{Flow, Source, StreamError};
use futures_core::Stream;
use futures_util::StreamExt;
use crate::{
EventAdapter, PersistenceId, PersistenceResult, Revision, SequenceNr, SerializedPayload,
SerializerCatalog, Tag,
};
pub use slice::{SLICE_COUNT, SliceRange, slice_for, slice_ranges};
pub type QueryStream<T> = Pin<Box<dyn Stream<Item = PersistenceResult<T>> + Send + 'static>>;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Offset {
#[default]
NoOffset,
Sequence(u64),
Timestamp {
epoch_micros: i64,
seq_nr: u64,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum QueryMode {
Live,
Current,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EventEnvelope {
pub offset: Offset,
pub persistence_id: PersistenceId,
pub sequence_nr: SequenceNr,
pub timestamp_ms: i64,
pub adapter_manifest: String,
pub payload: SerializedPayload,
pub metadata: Option<SerializedPayload>,
pub tags: Vec<Tag>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UpdatedDurableState {
pub offset: Offset,
pub persistence_id: PersistenceId,
pub revision: Revision,
pub state: SerializedPayload,
pub timestamp_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DeletedDurableState {
pub offset: Offset,
pub persistence_id: PersistenceId,
pub revision: Revision,
pub timestamp_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DurableStateChange {
Updated(UpdatedDurableState),
Deleted(DeletedDurableState),
}
impl DurableStateChange {
#[must_use]
pub const fn offset(&self) -> Offset {
match self {
Self::Updated(change) => change.offset,
Self::Deleted(change) => change.offset,
}
}
#[must_use]
pub fn persistence_id(&self) -> &PersistenceId {
match self {
Self::Updated(change) => &change.persistence_id,
Self::Deleted(change) => &change.persistence_id,
}
}
#[must_use]
pub const fn revision(&self) -> Revision {
match self {
Self::Updated(change) => change.revision,
Self::Deleted(change) => change.revision,
}
}
}
#[async_trait::async_trait]
pub trait EventsByPersistenceIdQuery: Send + Sync {
async fn events_by_persistence_id(
&self,
persistence_id: &PersistenceId,
from_sequence_nr: SequenceNr,
to_sequence_nr: SequenceNr,
mode: QueryMode,
) -> PersistenceResult<QueryStream<EventEnvelope>>;
}
#[async_trait::async_trait]
pub trait EventsByTagQuery: Send + Sync {
async fn events_by_tag(
&self,
tag: &Tag,
offset: Offset,
mode: QueryMode,
) -> PersistenceResult<QueryStream<EventEnvelope>>;
}
#[async_trait::async_trait]
pub trait EventsBySlicesQuery: Send + Sync {
async fn events_by_slices(
&self,
entity_type: &str,
min_slice: u16,
max_slice: u16,
offset: Offset,
mode: QueryMode,
) -> PersistenceResult<QueryStream<EventEnvelope>>;
}
#[async_trait::async_trait]
pub trait PersistenceIdsQuery: Send + Sync {
async fn persistence_ids(
&self,
mode: QueryMode,
) -> PersistenceResult<QueryStream<PersistenceId>>;
}
#[async_trait::async_trait]
pub trait DurableStateChangesQuery: Send + Sync {
async fn changes(
&self,
tag: &Tag,
offset: Offset,
mode: QueryMode,
) -> PersistenceResult<QueryStream<DurableStateChange>>;
}
#[must_use]
pub fn into_source<T>(stream: QueryStream<T>) -> Source<T>
where
T: Send + 'static,
{
let stream = Arc::new(tokio::sync::Mutex::new(stream));
Source::unfold_async(stream, |stream| async move {
let next = {
let mut stream = stream.lock().await;
stream.next().await
};
match next {
Some(Ok(item)) => Ok(Some((stream, item))),
Some(Err(error)) => Err(StreamError::Failed(error.to_string())),
None => Ok(None),
}
})
}
#[must_use]
pub fn decode_envelopes<D, J, A>(
catalog: SerializerCatalog<J>,
adapter: A,
) -> Flow<EventEnvelope, D>
where
D: Send + 'static,
J: Send + 'static,
A: EventAdapter<D, J>,
{
let catalog = Arc::new(catalog);
let adapter = Arc::new(adapter);
Flow::identity().try_map_concat(move |envelope: EventEnvelope| {
let journal_event = catalog
.decode(&envelope.payload)
.map_err(|error| StreamError::Failed(error.to_string()))?;
adapter
.from_journal_events(&envelope.adapter_manifest, journal_event)
.map_err(|error| StreamError::Failed(error.to_string()))
})
}