use happenstance_core::{Event, EventId, RecordedAt, SequencedEvent, StoreId, Tag, Tags};
use crate::event_store::{SqliteEventStoreError, position_from_row};
const UNIT: u8 = 0x1f;
pub(crate) const COLUMNS: &str = "position, event_type, data, metadata, tags, \
origin_store, origin_position, recorded_at";
pub(crate) fn encode_tags(tags: &Tags) -> Vec<u8> {
let mut out = Vec::with_capacity(tags.len() * 16 + 1);
out.push(UNIT);
for tag in tags {
out.extend_from_slice(tag.as_str().as_bytes());
out.push(UNIT);
}
out
}
pub(crate) fn decode_tags(raw: &[u8]) -> Result<Tags, SqliteEventStoreError> {
let text = core::str::from_utf8(raw).map_err(|_| SqliteEventStoreError::CorruptTags)?;
text.split(UNIT as char)
.filter(|part| !part.is_empty())
.map(|part| Tag::new(part).map_err(SqliteEventStoreError::StoredTag))
.collect::<Result<Vec<Tag>, _>>()
.map(|tags| tags.into_iter().collect())
}
pub(crate) fn to_event(row: &rusqlite::Row<'_>) -> Result<SequencedEvent, SqliteEventStoreError> {
let position: i64 = row.get(0)?;
let event_type: String = row.get(1)?;
let data: Vec<u8> = row.get(2)?;
let metadata: Option<Vec<u8>> = row.get(3)?;
let tags: Vec<u8> = row.get(4)?;
let origin_store: Option<Vec<u8>> = row.get(5)?;
let origin_position: Option<i64> = row.get(6)?;
let recorded_at: i64 = row.get(7)?;
let position = position_from_row(position)?;
let (origin_store, origin_position) = origin_store
.zip(origin_position)
.ok_or(SqliteEventStoreError::UnstampedEvent { position })?;
let origin_bytes: [u8; 16] = origin_store.as_slice().try_into().map_err(|_| {
SqliteEventStoreError::MalformedIdentity {
len: origin_store.len(),
}
})?;
let origin = position_from_row(origin_position)?;
let mut event = Event::new(event_type, data)
.map_err(SqliteEventStoreError::StoredEventType)?
.with_tags(decode_tags(&tags)?);
if let Some(metadata) = metadata {
event = event.with_metadata(metadata);
}
Ok(SequencedEvent::new(
position,
EventId::new(StoreId::from_bytes(origin_bytes), origin),
RecordedAt::from_millis(recorded_at),
event,
))
}