use serde::Serialize;
use serde::de::DeserializeOwned;
use crate::manifest::{
BlobFetcher, BlobManifest, BlobSource, list_manifests, load_manifest, save_manifest,
};
use crate::schema::{
Hash, ManifestId, PrivacyClass, ProvenanceRecord, SchemaRef, Timestamp, TrustEnvelope,
};
use crate::seal::{PayloadSealer, resolve_sealed_blob, seal_payload_for_store};
use crate::{Error, Result, Store};
pub trait TypedPayload: Serialize + DeserializeOwned + Sized {
fn schema_ref() -> SchemaRef;
fn serialize_to_bytes(&self) -> Result<Vec<u8>> {
serde_json::to_vec(self).map_err(|e| Error::new(format!("typed serialize: {e}")))
}
fn deserialize_from_bytes(bytes: &[u8]) -> Result<Self> {
serde_json::from_slice(bytes).map_err(|e| Error::new(format!("typed deserialize: {e}")))
}
}
pub async fn save_typed<T: TypedPayload>(
store: &mut dyn Store,
value: &T,
additional_sources: Vec<BlobSource>,
privacy: PrivacyClass,
provenance: ProvenanceRecord,
trust: TrustEnvelope,
created_at: Timestamp,
) -> Result<ManifestId> {
save_typed_sealed(
store,
None,
value,
additional_sources,
privacy,
provenance,
trust,
created_at,
)
.await
}
#[allow(clippy::too_many_arguments)] pub async fn save_typed_sealed<T: TypedPayload>(
store: &mut dyn Store,
sealer: Option<&dyn PayloadSealer>,
value: &T,
additional_sources: Vec<BlobSource>,
privacy: PrivacyClass,
provenance: ProvenanceRecord,
trust: TrustEnvelope,
created_at: Timestamp,
) -> Result<ManifestId> {
let bytes = value.serialize_to_bytes()?;
let hash = Hash::of(&bytes);
let id = ManifestId::from_hash(hash);
let local_key = format!("blob:{}", hash.to_hex());
let mut sources = Vec::with_capacity(1 + additional_sources.len());
sources.push(BlobSource::Local {
key: local_key.clone(),
});
sources.extend(additional_sources);
let mut manifest = BlobManifest {
id,
schema: T::schema_ref(),
content_hash: hash,
byte_size: bytes.len() as u64,
created_at,
last_accessed: None,
sources,
privacy,
provenance,
trust,
schema_metadata: serde_json::Value::Null,
manifest_version: BlobManifest::CURRENT_VERSION,
};
let stored = seal_payload_for_store(sealer, &mut manifest, &bytes)?;
store.put(&local_key, &stored).await?;
save_manifest(store, &manifest).await?;
Ok(id)
}
pub async fn list_typed<T: TypedPayload>(store: &mut dyn Store) -> Result<Vec<BlobManifest>> {
list_manifests(store, Some(T::schema_ref())).await
}
pub async fn load_typed<T: TypedPayload>(
store: &mut dyn Store,
fetcher: &mut dyn BlobFetcher,
id: ManifestId,
) -> Result<Option<T>> {
load_typed_sealed(store, fetcher, None, id).await
}
pub async fn load_typed_sealed<T: TypedPayload>(
store: &mut dyn Store,
fetcher: &mut dyn BlobFetcher,
sealer: Option<&dyn PayloadSealer>,
id: ManifestId,
) -> Result<Option<T>> {
let Some(manifest) = load_manifest(store, id).await? else {
return Ok(None);
};
if manifest.schema != T::schema_ref() {
return Err(Error::new(format!(
"schema mismatch loading manifest {}: declared {}, requested {}",
id,
manifest.schema,
T::schema_ref()
)));
}
let bytes = resolve_sealed_blob(store, fetcher, sealer, &manifest).await?;
let value = T::deserialize_from_bytes(&bytes)?;
Ok(Some(value))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::manifest::NoFetcher;
use crate::schema::{
ManifestId, ModerationState, ProvenanceOrigin, ProvenanceRecord, SchemaRef, Timestamp,
TrustLevel,
};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use muniment::MemoryBackend as InMemoryStore;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
struct Greeting {
salutation: String,
recipient: String,
}
impl TypedPayload for Greeting {
fn schema_ref() -> SchemaRef {
SchemaRef::from_id(ManifestId::of_blob(b"schema:test-greeting/v1"))
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
struct Counter {
ticks: u64,
}
impl TypedPayload for Counter {
fn schema_ref() -> SchemaRef {
SchemaRef::from_id(ManifestId::of_blob(b"schema:test-counter/v1"))
}
}
fn test_provenance() -> ProvenanceRecord {
ProvenanceRecord {
origin: ProvenanceOrigin::Generated,
upstream: Vec::new(),
tooling: Some("eidetic-test/0.0.1".to_string()),
generated_at: Timestamp(1_700_000_000_000),
}
}
fn test_trust() -> TrustEnvelope {
TrustEnvelope {
level: TrustLevel::SelfAsserted,
signatures: Vec::new(),
moderation_state: ModerationState::Unreviewed,
}
}
#[test]
fn save_then_load_round_trips_value() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let original = Greeting {
salutation: "Hello".to_string(),
recipient: "world".to_string(),
};
let id = save_typed(
&mut store,
&original,
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(1_700_000_000_000),
)
.await
.unwrap();
let mut fetcher = NoFetcher;
let loaded: Greeting = load_typed(&mut store, &mut fetcher, id)
.await
.unwrap()
.expect("manifest present after save");
assert_eq!(loaded, original);
});
}
#[test]
fn load_typed_returns_none_for_unknown_id() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let mut fetcher = NoFetcher;
let unknown = ManifestId::of_blob(b"never-saved");
let result: Option<Greeting> =
load_typed(&mut store, &mut fetcher, unknown).await.unwrap();
assert!(result.is_none());
});
}
#[test]
fn schema_mismatch_load_returns_error() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let id = save_typed(
&mut store,
&Greeting {
salutation: "Hi".to_string(),
recipient: "you".to_string(),
},
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
let mut fetcher = NoFetcher;
let result: Result<Option<Counter>> = load_typed(&mut store, &mut fetcher, id).await;
assert!(result.is_err());
assert!(format!("{}", result.unwrap_err()).contains("schema mismatch"));
});
}
#[test]
fn multiple_schemas_coexist_in_one_store() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let mut fetcher = NoFetcher;
let greeting_id = save_typed(
&mut store,
&Greeting {
salutation: "Yo".to_string(),
recipient: "everyone".to_string(),
},
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
let counter_id = save_typed(
&mut store,
&Counter { ticks: 42 },
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
assert_ne!(
greeting_id, counter_id,
"different content -> different ids"
);
let g: Greeting = load_typed(&mut store, &mut fetcher, greeting_id)
.await
.unwrap()
.unwrap();
assert_eq!(g.salutation, "Yo");
let c: Counter = load_typed(&mut store, &mut fetcher, counter_id)
.await
.unwrap()
.unwrap();
assert_eq!(c.ticks, 42);
});
}
#[test]
fn list_typed_returns_only_matching_schema_manifests() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
save_typed(
&mut store,
&Greeting {
salutation: "Yo".to_string(),
recipient: "alice".to_string(),
},
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
save_typed(
&mut store,
&Greeting {
salutation: "Hi".to_string(),
recipient: "bob".to_string(),
},
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
save_typed(
&mut store,
&Counter { ticks: 7 },
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
let greetings = list_typed::<Greeting>(&mut store).await.unwrap();
assert_eq!(greetings.len(), 2);
for m in &greetings {
assert_eq!(m.schema, Greeting::schema_ref());
}
let counters = list_typed::<Counter>(&mut store).await.unwrap();
assert_eq!(counters.len(), 1);
assert_eq!(counters[0].schema, Counter::schema_ref());
});
}
#[test]
fn load_typed_rejects_blob_whose_hash_no_longer_matches_manifest() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let original = Greeting {
salutation: "Hi".to_string(),
recipient: "you".to_string(),
};
let id = save_typed(
&mut store,
&original,
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
let blob_key = format!("blob:{}", id.0.to_hex());
store
.put(&blob_key, b"not the original bytes")
.await
.unwrap();
let mut fetcher = NoFetcher;
let result: Result<Option<Greeting>> = load_typed(&mut store, &mut fetcher, id).await;
assert!(result.is_err());
assert!(format!("{}", result.unwrap_err()).contains("content hash mismatch"));
});
}
struct XorSealer;
impl PayloadSealer for XorSealer {
fn seal(
&self,
_content_hash: &Hash,
cleartext: &[u8],
) -> Result<(Vec<u8>, crate::seal::SealedBlobRef)> {
Ok((
cleartext.iter().map(|b| b ^ 0xAA).collect(),
crate::seal::SealedBlobRef {
epoch: crate::seal::SealEpochId([1u8; 16]),
format: "xor-test".to_string(),
},
))
}
fn unseal(
&self,
_content_hash: &Hash,
_marker: &crate::seal::SealedBlobRef,
sealed: &[u8],
) -> Result<Vec<u8>> {
Ok(sealed.iter().map(|b| b ^ 0xAA).collect())
}
}
#[test]
fn sealed_typed_round_trips_and_stores_non_cleartext() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let original = Greeting {
salutation: "secret".to_string(),
recipient: "you".to_string(),
};
let id = save_typed_sealed(
&mut store,
Some(&XorSealer),
&original,
Vec::new(),
PrivacyClass::LocalOnly,
test_provenance(),
test_trust(),
Timestamp(0),
)
.await
.unwrap();
let blob_key = format!("blob:{}", id.0.to_hex());
let stored = store.get(&blob_key).await.unwrap().unwrap();
assert_ne!(stored, original.serialize_to_bytes().unwrap());
let mut fetcher = NoFetcher;
let got: Greeting = load_typed_sealed(&mut store, &mut fetcher, Some(&XorSealer), id)
.await
.unwrap()
.unwrap();
assert_eq!(got, original);
let err = load_typed::<Greeting>(&mut store, &mut fetcher, id)
.await
.unwrap_err();
assert!(err.to_string().contains("sealed"), "got: {err}");
});
}
}