use std::sync::RwLock;
use crate::memory::MemoryStorage;
use crate::traits::{
CommitStore, EpochStore, ObjectStore, RefStore, SessionStore, StorageError, TaintStore,
};
use agentstategraph_core::{Commit, Epoch, Namespace, Object, ObjectId, Session, SessionStatus};
use agentstategraph_reminders::ReminderStore;
use chrono::{DateTime, Utc};
pub struct IndexedDbStorage {
memory: MemoryStorage,
db_name: String,
pending_objects: RwLock<Vec<(String, String)>>, pending_commits: RwLock<Vec<(String, String)>>, pending_refs: RwLock<Vec<(String, String)>>, deleted_refs: RwLock<Vec<String>>, pending_epochs: RwLock<Vec<(String, String)>>, pending_sessions: RwLock<Vec<(String, String)>>, pending_commit_epochs: RwLock<Vec<(String, String)>>, pending_commit_sessions: RwLock<Vec<(String, String)>>, }
impl IndexedDbStorage {
pub fn new(db_name: &str) -> Self {
Self {
memory: MemoryStorage::new(),
db_name: db_name.to_string(),
pending_objects: RwLock::new(Vec::new()),
pending_commits: RwLock::new(Vec::new()),
pending_refs: RwLock::new(Vec::new()),
deleted_refs: RwLock::new(Vec::new()),
pending_epochs: RwLock::new(Vec::new()),
pending_sessions: RwLock::new(Vec::new()),
pending_commit_epochs: RwLock::new(Vec::new()),
pending_commit_sessions: RwLock::new(Vec::new()),
}
}
pub fn load_objects(&self, json_pairs: &[(String, String)]) -> Result<(), StorageError> {
for (_hex_id, json) in json_pairs {
let obj: Object = serde_json::from_str(json)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
self.memory.put_object(&obj)?;
}
Ok(())
}
pub fn load_commits(&self, json_pairs: &[(String, String)]) -> Result<(), StorageError> {
for (_hex_id, json) in json_pairs {
let commit: Commit = serde_json::from_str(json)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
self.memory.put_commit(&commit)?;
}
Ok(())
}
pub fn load_refs(&self, pairs: &[(String, String)]) -> Result<(), StorageError> {
let mut loaded = std::collections::HashSet::new();
for (key, hex_id) in pairs {
let bytes = hex_to_bytes(hex_id)
.ok_or_else(|| StorageError::Serialization("invalid hex id".to_string()))?;
let mut arr = [0u8; 32];
if bytes.len() != 32 {
return Err(StorageError::Serialization(
"id must be 32 bytes".to_string(),
));
}
arr.copy_from_slice(&bytes);
let id = ObjectId::from_bytes(arr);
let (ns, name) = parse_ref_key(key);
match self.memory.create_namespace(&ns) {
Ok(()) | Err(StorageError::NamespaceAlreadyExists(_)) => {}
Err(e) => return Err(e),
}
self.memory.set_ref(&ns, name, id)?;
loaded.insert(key.as_str());
}
self.pending_refs
.write()
.unwrap()
.retain(|(key, _)| !loaded.contains(key.as_str()));
Ok(())
}
pub fn drain_pending_objects(&self) -> Vec<(String, String)> {
let mut pending = self.pending_objects.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_pending_commits(&self) -> Vec<(String, String)> {
let mut pending = self.pending_commits.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_pending_refs(&self) -> Vec<(String, String)> {
let mut pending = self.pending_refs.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_deleted_refs(&self) -> Vec<String> {
let mut deleted = self.deleted_refs.write().unwrap();
std::mem::take(&mut *deleted)
}
pub fn load_epochs(&self, json_pairs: &[(String, String)]) -> Result<(), StorageError> {
for (_id, json) in json_pairs {
let epoch: Epoch = serde_json::from_str(json)
.map_err(|e| StorageError::Serialization(format!("epoch load: {}", e)))?;
self.memory.create_epoch(&epoch)?;
}
Ok(())
}
pub fn load_sessions(&self, json_pairs: &[(String, String)]) -> Result<(), StorageError> {
for (_id, json) in json_pairs {
let session: Session = serde_json::from_str(json)
.map_err(|e| StorageError::Serialization(format!("session load: {}", e)))?;
self.memory.create_session(&session)?;
}
Ok(())
}
pub fn load_commit_epochs(&self, pairs: &[(String, String)]) -> Result<(), StorageError> {
for (commit_hex, epoch_id) in pairs {
let bytes = hex_to_bytes(commit_hex)
.ok_or_else(|| StorageError::Serialization("invalid commit hex".to_string()))?;
if bytes.len() != 32 {
return Err(StorageError::Serialization("id must be 32 bytes".into()));
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
let id = ObjectId::from_bytes(arr);
self.memory.set_commit_epoch(&id, epoch_id)?;
}
Ok(())
}
pub fn load_commit_sessions(&self, pairs: &[(String, String)]) -> Result<(), StorageError> {
for (commit_hex, session_id) in pairs {
let bytes = hex_to_bytes(commit_hex)
.ok_or_else(|| StorageError::Serialization("invalid commit hex".to_string()))?;
if bytes.len() != 32 {
return Err(StorageError::Serialization("id must be 32 bytes".into()));
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
let id = ObjectId::from_bytes(arr);
self.memory.set_commit_session(&id, session_id)?;
}
Ok(())
}
pub fn drain_pending_epochs(&self) -> Vec<(String, String)> {
let mut pending = self.pending_epochs.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_pending_sessions(&self) -> Vec<(String, String)> {
let mut pending = self.pending_sessions.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_pending_commit_epochs(&self) -> Vec<(String, String)> {
let mut pending = self.pending_commit_epochs.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn drain_pending_commit_sessions(&self) -> Vec<(String, String)> {
let mut pending = self.pending_commit_sessions.write().unwrap();
std::mem::take(&mut *pending)
}
pub fn db_name(&self) -> &str {
&self.db_name
}
fn queue_epoch_snapshot(&self, id: &str) -> Result<(), StorageError> {
if let Some(epoch) = self.memory.get_epoch(id)? {
let json = serde_json::to_string(&epoch)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
self.pending_epochs
.write()
.unwrap()
.push((id.to_string(), json));
}
Ok(())
}
fn queue_session_snapshot(&self, id: &str) -> Result<(), StorageError> {
if let Some(session) = self.memory.get_session(id)? {
let json = serde_json::to_string(&session)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
self.pending_sessions
.write()
.unwrap()
.push((id.to_string(), json));
}
Ok(())
}
}
impl ObjectStore for IndexedDbStorage {
fn get_object(&self, id: &ObjectId) -> Result<Option<Object>, StorageError> {
self.memory.get_object(id)
}
fn put_object(&self, obj: &Object) -> Result<ObjectId, StorageError> {
let id = self.memory.put_object(obj)?;
let hex_id = format!("{}", id);
let json =
serde_json::to_string(obj).map_err(|e| StorageError::Serialization(e.to_string()))?;
self.pending_objects.write().unwrap().push((hex_id, json));
Ok(id)
}
fn has_object(&self, id: &ObjectId) -> Result<bool, StorageError> {
self.memory.has_object(id)
}
}
impl CommitStore for IndexedDbStorage {
fn get_commit(&self, id: &ObjectId) -> Result<Option<Commit>, StorageError> {
self.memory.get_commit(id)
}
fn put_commit(&self, commit: &Commit) -> Result<(), StorageError> {
self.memory.put_commit(commit)?;
let hex_id = format!("{}", commit.id);
let json = serde_json::to_string(commit)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
self.pending_commits.write().unwrap().push((hex_id, json));
Ok(())
}
fn has_commit(&self, id: &ObjectId) -> Result<bool, StorageError> {
self.memory.has_commit(id)
}
fn list_commits(&self, from: &ObjectId, limit: usize) -> Result<Vec<Commit>, StorageError> {
self.memory.list_commits(from, limit)
}
fn all_commit_ids(&self) -> Result<Vec<ObjectId>, StorageError> {
self.memory.all_commit_ids()
}
}
impl RefStore for IndexedDbStorage {
fn create_namespace(&self, namespace: &Namespace) -> Result<(), StorageError> {
self.memory.create_namespace(namespace)
}
fn list_namespaces(&self) -> Result<Vec<Namespace>, StorageError> {
self.memory.list_namespaces()
}
fn get_ref(&self, namespace: &Namespace, name: &str) -> Result<Option<ObjectId>, StorageError> {
self.memory.get_ref(namespace, name)
}
fn set_ref(
&self,
namespace: &Namespace,
name: &str,
target: ObjectId,
) -> Result<(), StorageError> {
self.memory.set_ref(namespace, name, target)?;
let hex_id = format!("{}", target);
self.pending_refs
.write()
.unwrap()
.push((ref_key(namespace, name), hex_id));
Ok(())
}
fn cas_ref(
&self,
namespace: &Namespace,
name: &str,
expected: ObjectId,
new: ObjectId,
) -> Result<bool, StorageError> {
let result = self.memory.cas_ref(namespace, name, expected, new)?;
if result {
let hex_id = format!("{}", new);
self.pending_refs
.write()
.unwrap()
.push((ref_key(namespace, name), hex_id));
}
Ok(result)
}
fn create_ref(
&self,
namespace: &Namespace,
name: &str,
target: ObjectId,
) -> Result<bool, StorageError> {
let created = self.memory.create_ref(namespace, name, target)?;
if created {
self.pending_refs
.write()
.unwrap()
.push((ref_key(namespace, name), format!("{}", target)));
}
Ok(created)
}
fn cas_delete_ref(
&self,
namespace: &Namespace,
name: &str,
expected: ObjectId,
) -> Result<bool, StorageError> {
let deleted = self.memory.cas_delete_ref(namespace, name, expected)?;
if deleted {
self.deleted_refs
.write()
.unwrap()
.push(ref_key(namespace, name));
}
Ok(deleted)
}
fn list_refs(
&self,
namespace: &Namespace,
prefix: &str,
) -> Result<Vec<(String, ObjectId)>, StorageError> {
self.memory.list_refs(namespace, prefix)
}
fn delete_ref(&self, namespace: &Namespace, name: &str) -> Result<bool, StorageError> {
let result = self.memory.delete_ref(namespace, name)?;
if result {
self.deleted_refs
.write()
.unwrap()
.push(ref_key(namespace, name));
}
Ok(result)
}
fn delete_namespace(&self, namespace: &Namespace) -> Result<bool, StorageError> {
self.memory.delete_namespace(namespace)
}
}
const NAMESPACE_SEPARATOR: char = '\u{1f}';
fn ref_key(namespace: &Namespace, name: &str) -> String {
if namespace.as_str() == Namespace::DEFAULT {
name.to_string()
} else {
format!("{}{}{}", namespace.as_str(), NAMESPACE_SEPARATOR, name)
}
}
fn parse_ref_key(key: &str) -> (Namespace, &str) {
if let Some((ns, name)) = key.split_once(NAMESPACE_SEPARATOR)
&& let Ok(ns) = Namespace::new(ns)
{
return (ns, name);
}
(Namespace::default_ns(), key)
}
fn hex_to_bytes(hex: &str) -> Option<Vec<u8>> {
let hex = hex.strip_prefix("sg_").unwrap_or(hex);
if !hex.len().is_multiple_of(2) {
return None;
}
(0..hex.len())
.step_by(2)
.map(|i| u8::from_str_radix(&hex[i..i + 2], 16).ok())
.collect()
}
impl EpochStore for IndexedDbStorage {
fn create_epoch(&self, epoch: &Epoch) -> Result<(), StorageError> {
self.memory.create_epoch(epoch)?;
self.queue_epoch_snapshot(&epoch.id)?;
Ok(())
}
fn seal_epoch(
&self,
id: &str,
summary: &str,
sealed_at: DateTime<Utc>,
sealed_commits: &[ObjectId],
seal_hash: &ObjectId,
) -> Result<(), StorageError> {
self.memory
.seal_epoch(id, summary, sealed_at, sealed_commits, seal_hash)?;
self.queue_epoch_snapshot(id)?;
Ok(())
}
fn assign_epoch_namespace(&self, id: &str, namespace: &str) -> Result<bool, StorageError> {
self.memory.assign_epoch_namespace(id, namespace)
}
fn list_epochs(&self) -> Result<Vec<Epoch>, StorageError> {
self.memory.list_epochs()
}
fn get_epoch(&self, id: &str) -> Result<Option<Epoch>, StorageError> {
self.memory.get_epoch(id)
}
fn set_commit_epoch(&self, commit_id: &ObjectId, epoch_id: &str) -> Result<(), StorageError> {
self.memory.set_commit_epoch(commit_id, epoch_id)?;
let hex = format!("{}", commit_id);
self.pending_commit_epochs
.write()
.unwrap()
.push((hex, epoch_id.to_string()));
self.queue_epoch_snapshot(epoch_id)?;
Ok(())
}
fn archive_epoch(&self, id: &str) -> Result<(), StorageError> {
self.memory.archive_epoch(id)?;
self.queue_epoch_snapshot(id)?;
Ok(())
}
}
impl SessionStore for IndexedDbStorage {
fn create_session(&self, session: &Session) -> Result<(), StorageError> {
self.memory.create_session(session)?;
self.queue_session_snapshot(&session.id)?;
Ok(())
}
fn end_session(
&self,
id: &str,
status: SessionStatus,
ended_at: DateTime<Utc>,
) -> Result<(), StorageError> {
self.memory.end_session(id, status, ended_at)?;
self.queue_session_snapshot(id)?;
Ok(())
}
fn list_sessions(&self, agent_filter: Option<&str>) -> Result<Vec<Session>, StorageError> {
self.memory.list_sessions(agent_filter)
}
fn get_session(&self, id: &str) -> Result<Option<Session>, StorageError> {
self.memory.get_session(id)
}
fn set_commit_session(
&self,
commit_id: &ObjectId,
session_id: &str,
) -> Result<(), StorageError> {
self.memory.set_commit_session(commit_id, session_id)?;
let hex = format!("{}", commit_id);
self.pending_commit_sessions
.write()
.unwrap()
.push((hex, session_id.to_string()));
self.queue_session_snapshot(session_id)?;
Ok(())
}
}
impl TaintStore for IndexedDbStorage {
fn create_taint(&self, taint: &agentstategraph_taint::Taint) -> Result<(), StorageError> {
self.memory.create_taint(taint)
}
fn resolve_taint(
&self,
id: &str,
resolved_by: &str,
reason: &str,
proof: Option<&str>,
resolved_at: DateTime<Utc>,
) -> Result<(), StorageError> {
self.memory
.resolve_taint(id, resolved_by, reason, proof, resolved_at)
}
fn list_taints(
&self,
path_prefix: Option<&str>,
kind: Option<agentstategraph_taint::TaintKind>,
include_resolved: bool,
) -> Result<Vec<agentstategraph_taint::Taint>, StorageError> {
self.memory.list_taints(path_prefix, kind, include_resolved)
}
fn check_taint(
&self,
request_path: &str,
) -> Result<Vec<agentstategraph_taint::Taint>, StorageError> {
self.memory.check_taint(request_path)
}
fn get_taint(&self, id: &str) -> Result<Option<agentstategraph_taint::Taint>, StorageError> {
self.memory.get_taint(id)
}
fn set_taint_commit_id(&self, id: &str, commit_id: &str) -> Result<(), StorageError> {
self.memory.set_taint_commit_id(id, commit_id)
}
}
impl ReminderStore for IndexedDbStorage {
fn save(
&self,
reminder: &agentstategraph_reminders::Reminder,
) -> Result<(), agentstategraph_reminders::ReminderError> {
self.memory.reminders.save(reminder)
}
fn get(
&self,
id: &str,
) -> Result<Option<agentstategraph_reminders::Reminder>, agentstategraph_reminders::ReminderError>
{
self.memory.reminders.get(id)
}
fn update(
&self,
reminder: &agentstategraph_reminders::Reminder,
) -> Result<(), agentstategraph_reminders::ReminderError> {
self.memory.reminders.update(reminder)
}
fn delete(&self, id: &str) -> Result<bool, agentstategraph_reminders::ReminderError> {
self.memory.reminders.delete(id)
}
fn list(
&self,
filter: &agentstategraph_reminders::ReminderFilter,
) -> Result<Vec<agentstategraph_reminders::Reminder>, agentstategraph_reminders::ReminderError>
{
self.memory.reminders.list(filter)
}
}
#[cfg(test)]
mod tests {
use super::*;
use agentstategraph_core::*;
#[test]
fn refs_in_two_namespaces_reload_into_their_own() {
let store = IndexedDbStorage::new("test-db");
let team = Namespace::new("team").unwrap();
store.create_namespace(&team).unwrap();
let (default_head, team_head) = (ObjectId::hash(b"default"), ObjectId::hash(b"team"));
store
.set_ref(&Namespace::default_ns(), "main", default_head)
.unwrap();
store.set_ref(&team, "main", team_head).unwrap();
let reloaded = IndexedDbStorage::new("test-db");
reloaded.load_refs(&store.drain_pending_refs()).unwrap();
assert_eq!(
reloaded.get_ref(&Namespace::default_ns(), "main").unwrap(),
Some(default_head)
);
assert_eq!(reloaded.get_ref(&team, "main").unwrap(), Some(team_head));
}
#[test]
fn a_loaded_ref_supersedes_one_queued_before_the_load() {
let store = IndexedDbStorage::new("test-db");
let ns = Namespace::default_ns();
store
.set_ref(&ns, "main", ObjectId::hash(b"fresh"))
.unwrap();
store
.set_ref(&ns, "other", ObjectId::hash(b"other"))
.unwrap();
let persisted = ObjectId::hash(b"persisted");
store
.load_refs(&[("main".to_string(), format!("{persisted}"))])
.unwrap();
let queued = store.drain_pending_refs();
assert_eq!(
queued,
vec![("other".to_string(), format!("{}", ObjectId::hash(b"other")))]
);
assert_eq!(store.get_ref(&ns, "main").unwrap(), Some(persisted));
}
#[test]
fn test_basic_operations() {
let store = IndexedDbStorage::new("test-db");
let obj = Object::string("hello indexeddb");
let id = store.put_object(&obj).unwrap();
let retrieved = store.get_object(&id).unwrap();
assert_eq!(retrieved, Some(obj));
}
#[test]
fn test_pending_writes_queued() {
let store = IndexedDbStorage::new("test-db");
store.put_object(&Object::string("a")).unwrap();
store.put_object(&Object::string("b")).unwrap();
let pending = store.drain_pending_objects();
assert_eq!(pending.len(), 2);
let pending2 = store.drain_pending_objects();
assert_eq!(pending2.len(), 0);
}
#[test]
fn test_refs_pending() {
let store = IndexedDbStorage::new("test-db");
let target = ObjectId::hash(b"commit");
let ns = Namespace::default_ns();
store.set_ref(&ns, "main", target).unwrap();
let pending = store.drain_pending_refs();
assert_eq!(pending.len(), 1);
assert_eq!(pending[0].0, "main");
}
#[test]
fn test_load_and_read() {
let store = IndexedDbStorage::new("test-db");
let obj = Object::string("persisted");
let json = serde_json::to_string(&obj).unwrap();
let id = obj.id();
let hex = format!("{}", id);
store.load_objects(&[(hex, json)]).unwrap();
let retrieved = store.get_object(&id).unwrap();
assert_eq!(retrieved, Some(obj));
}
#[test]
fn test_commit_pending() {
let store = IndexedDbStorage::new("test-db");
let commit = CommitBuilder::new(
ObjectId::hash(b"state"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, "test"),
)
.build();
store.put_commit(&commit).unwrap();
let pending = store.drain_pending_commits();
assert_eq!(pending.len(), 1);
let retrieved = store.get_commit(&commit.id).unwrap();
assert!(retrieved.is_some());
}
#[test]
fn test_delete_ref_pending() {
let store = IndexedDbStorage::new("test-db");
let target = ObjectId::hash(b"commit");
let ns = Namespace::default_ns();
store.set_ref(&ns, "temp", target).unwrap();
store.drain_pending_refs();
store.delete_ref(&ns, "temp").unwrap();
let deleted = store.drain_deleted_refs();
assert_eq!(deleted, vec!["temp"]);
}
#[test]
fn test_epoch_create_and_queue() {
let store = IndexedDbStorage::new("test-db");
let epoch = Epoch::new("e1", "first", vec![]);
store.create_epoch(&epoch).unwrap();
let pending = store.drain_pending_epochs();
assert_eq!(pending.len(), 1);
assert_eq!(pending[0].0, "e1");
let parsed: Epoch = serde_json::from_str(&pending[0].1).unwrap();
assert_eq!(parsed.id, "e1");
assert!(store.get_epoch("e1").unwrap().is_some());
assert_eq!(store.list_epochs().unwrap().len(), 1);
}
#[test]
fn test_epoch_seal_re_snapshots() {
let store = IndexedDbStorage::new("test-db");
store.create_epoch(&Epoch::new("e1", "x", vec![])).unwrap();
store.drain_pending_epochs();
store
.seal_epoch(
"e1",
"done",
Utc::now(),
&[],
&ObjectId::from_bytes([0u8; 32]),
)
.unwrap();
let pending = store.drain_pending_epochs();
assert_eq!(pending.len(), 1, "seal must re-snapshot");
let sealed: Epoch = serde_json::from_str(&pending[0].1).unwrap();
assert_eq!(sealed.status, EpochStatus::Sealed);
assert!(sealed.sealed_at.is_some());
}
#[test]
fn test_set_commit_epoch_queues_association() {
let store = IndexedDbStorage::new("test-db");
store.create_epoch(&Epoch::new("e1", "x", vec![])).unwrap();
store.drain_pending_epochs();
let cid = ObjectId::hash(b"c1");
store.set_commit_epoch(&cid, "e1").unwrap();
let assocs = store.drain_pending_commit_epochs();
assert_eq!(assocs.len(), 1);
assert_eq!(assocs[0].1, "e1");
let epoch_pending = store.drain_pending_epochs();
assert_eq!(epoch_pending.len(), 1);
}
#[test]
fn test_session_create_end_and_queue() {
let store = IndexedDbStorage::new("test-db");
let session = Session {
id: "s1".to_string(),
agent_id: "agent/x".to_string(),
working_branch: "main".to_string(),
head: ObjectId::hash(b"head"),
parent_session: None,
delegated_intent: None,
report_to: None,
path_scope: None,
scope_tenant: None,
scope_namespace: None,
status: SessionStatus::Active,
created_at: Utc::now(),
ended_at: None,
};
store.create_session(&session).unwrap();
assert_eq!(store.drain_pending_sessions().len(), 1);
store
.end_session("s1", SessionStatus::Completed, Utc::now())
.unwrap();
let after_end = store.drain_pending_sessions();
assert_eq!(after_end.len(), 1);
let snap: Session = serde_json::from_str(&after_end[0].1).unwrap();
assert_eq!(snap.status, SessionStatus::Completed);
}
#[test]
fn test_set_commit_session_queues_association() {
let store = IndexedDbStorage::new("test-db");
let session = Session {
id: "s1".to_string(),
agent_id: "agent/x".to_string(),
working_branch: "main".to_string(),
head: ObjectId::hash(b"head"),
parent_session: None,
delegated_intent: None,
report_to: None,
path_scope: None,
scope_tenant: None,
scope_namespace: None,
status: SessionStatus::Active,
created_at: Utc::now(),
ended_at: None,
};
store.create_session(&session).unwrap();
store.drain_pending_sessions();
let cid = ObjectId::hash(b"c1");
store.set_commit_session(&cid, "s1").unwrap();
let assocs = store.drain_pending_commit_sessions();
assert_eq!(assocs.len(), 1);
assert_eq!(assocs[0].1, "s1");
}
#[test]
fn test_load_epoch_round_trip() {
let store = IndexedDbStorage::new("test-db");
let epoch = Epoch::new("e1", "loaded", vec![]);
let json = serde_json::to_string(&epoch).unwrap();
store.load_epochs(&[("e1".to_string(), json)]).unwrap();
let got = store.get_epoch("e1").unwrap().unwrap();
assert_eq!(got.id, "e1");
assert_eq!(got.description, "loaded");
}
#[test]
fn test_load_commit_epoch_association() {
let store = IndexedDbStorage::new("test-db");
store.create_epoch(&Epoch::new("e1", "x", vec![])).unwrap();
let cid = ObjectId::hash(b"c-load");
let hex = format!("{}", cid);
store
.load_commit_epochs(&[(hex, "e1".to_string())])
.unwrap();
let assocs = store.drain_pending_commit_epochs();
assert!(assocs.is_empty());
}
}