#![doc(html_root_url = "https://docs.rs/eidetic/0.0.1")]
use serde::{Deserialize, Serialize};
pub mod browsing;
pub mod bundle;
pub mod deleted;
pub mod engram;
pub mod manifest;
pub mod models;
pub mod pack;
pub mod schema;
pub mod schema_def;
pub mod seal;
pub mod typed;
pub use browsing::{
BROWSING_TRACE_SCHEMA_REF, BrowsingMemory, BrowsingTrace, PageRef, TraceEvent, TraceTransition,
bootstrap_browsing_schema, save_trace,
};
pub use bundle::{
BUNDLE_SCHEMA_REF, Bundle, BundleMember, bundle_schema_ref, load_bundle, save_bundle,
verify_required_members,
};
pub use deleted::{DeletedNode, clear_deleted, list_deleted, purge_deleted, record_deleted};
pub use engram::{Engram, TimeBounds};
pub use manifest::{BlobFetcher, BlobManifest, BlobSource, NoFetcher, delete_manifest};
pub use models::{ModelComponents, ModelLibrary, ModelManifest};
pub use schema::{
Hash, ManifestId, ModerationState, PrivacyClass, ProvenanceOrigin, ProvenanceRecord, SchemaRef,
SignatureRef, Timestamp, TrustEnvelope, TrustLevel,
};
pub use schema_def::{
JsonLdValidator, JsonSchemaValidator, META_SCHEMA_REF, MereNativeFieldSpec,
MereNativeSchemaBody, MereNativeSchemaBuilder, MereNativeValidator, SchemaDefinition,
SchemaFormat, SchemaValidator, bootstrap_meta_schema, find_schema_by_id, load_schema,
meta_schema_engram, meta_schema_ref, save_schema, validate_against_schema, validate_payload,
};
pub use seal::{
PayloadSealer, SealEpochId, SealedBlobRef, is_private_lane, resolve_sealed_blob, seal_marker,
seal_payload_for_store,
};
pub use typed::{
TypedPayload, list_typed, load_typed, load_typed_sealed, save_typed, save_typed_sealed,
};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Request {
LoadBlob { key: String },
SaveBlob { key: String, value: Vec<u8> },
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Response {
BlobLoaded { key: String, value: Option<Vec<u8>> },
BlobSaved { key: String },
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Error {
pub message: String,
}
impl Error {
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
}
impl std::fmt::Display for Error {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(&self.message)
}
}
impl std::error::Error for Error {}
pub type Result<T> = std::result::Result<T, Error>;
pub use muniment::{Backend, Backend as Store, MemoryBackend, WriteOp};
impl From<muniment::error::StoreError> for Error {
fn from(err: muniment::error::StoreError) -> Self {
Error::new(err.to_string())
}
}
pub async fn bootstrap(store: &mut dyn Store) -> Result<()> {
bootstrap_meta_schema(store).await
}
pub async fn dispatch(store: &mut dyn Store, request: &Request) -> Result<Response> {
match request {
Request::LoadBlob { key } => Ok(Response::BlobLoaded {
key: key.clone(),
value: store.get(key).await?,
}),
Request::SaveBlob { key, value } => {
store.put(key, value).await?;
Ok(Response::BlobSaved { key: key.clone() })
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use async_trait::async_trait;
use muniment::error::StoreError;
use muniment::MemoryBackend as InMemoryStore;
#[test]
fn dispatch_round_trips_save_then_load() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let saved = dispatch(
&mut store,
&Request::SaveBlob {
key: "k".into(),
value: b"hello".to_vec(),
},
)
.await
.unwrap();
assert_eq!(
saved,
Response::BlobSaved {
key: "k".to_string()
}
);
let loaded = dispatch(&mut store, &Request::LoadBlob { key: "k".into() })
.await
.unwrap();
assert_eq!(
loaded,
Response::BlobLoaded {
key: "k".to_string(),
value: Some(b"hello".to_vec()),
}
);
});
}
#[test]
fn dispatch_load_returns_none_for_unknown_key() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
let loaded = dispatch(
&mut store,
&Request::LoadBlob {
key: "missing".into(),
},
)
.await
.unwrap();
assert_eq!(
loaded,
Response::BlobLoaded {
key: "missing".to_string(),
value: None,
}
);
});
}
#[test]
fn dispatch_propagates_store_errors() {
struct FailingStore;
type R<T> = std::result::Result<T, StoreError>;
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
impl Backend for FailingStore {
async fn get(&self, _key: &str) -> R<Option<Vec<u8>>> {
Err(StoreError::Backend("disk on fire".into()))
}
async fn put(&self, _key: &str, _bytes: &[u8]) -> R<()> {
Err(StoreError::Backend("disk on fire".into()))
}
async fn delete(&self, _key: &str) -> R<()> {
Err(StoreError::Backend("disk on fire".into()))
}
async fn list(&self, _prefix: &str) -> R<Vec<String>> {
Err(StoreError::Backend("disk on fire".into()))
}
async fn scan(&self, _start: &str, _end: &str) -> R<Vec<String>> {
Err(StoreError::Backend("disk on fire".into()))
}
async fn apply(&self, _ops: &[WriteOp]) -> R<()> {
Err(StoreError::Backend("disk on fire".into()))
}
}
pollster::block_on(async {
let err = dispatch(&mut FailingStore, &Request::LoadBlob { key: "k".into() })
.await
.unwrap_err();
assert_eq!(err.message, "backend: disk on fire");
});
}
}