prototype actor_store

src/actor_store/mod.rs

···
 use std::sync::Arc;
 
 use anyhow::{Context as _, Result};
-use atrium_crypto::keypair::{Export as _, Secp256k1Keypair};
+use atrium_crypto::keypair::Export as _;
 use sqlx::SqlitePool;
 
+use crate::SigningKey;
 use crate::config::RepoConfig;
 
 /// Resources required by the actor store.
 pub(crate) struct ActorStoreResources {
     /// Configuration for the repo.
     pub(crate) config: RepoConfig,
+    /// Configuration for the blob store.
+    pub(crate) blob_config: crate::config::BlobConfig,
     /// Background task queue (we'll need to implement this later).
     pub(crate) background_queue: Arc<()>, // TODO: Placeholder until we implement a proper queue
 }
···
 /// Reader for actor data.
 pub(crate) struct ActorStoreReader {
     /// The DID of the actor.
-    did: String,
+    pub(crate) did: String,
     /// The database connection.
-    db: SqlitePool,
+    pub(crate) db: SqlitePool,
     /// The actor's keypair.
-    keypair: Arc<Secp256k1Keypair>,
+    keypair: Arc<SigningKey>,
     /// Resources for the actor store.
-    resources: Arc<ActorStoreResources>,
+    pub(crate) resources: Arc<ActorStoreResources>,
+    /// Repository reader
+    pub(crate) repo: repo::RepoReader,
+    /// Record reader
+    pub(crate) record: record::RecordReader,
+    /// Preference reader
+    pub(crate) pref: preference::PreferenceReader,
 }
 
 /// Writer for actor data with transaction support.
 pub(crate) struct ActorStoreWriter {
     /// The DID of the actor.
-    did: String,
+    pub(crate) did: String,
     /// The database connection.
-    db: SqlitePool,
+    pub(crate) db: SqlitePool,
     /// The actor's keypair.
-    keypair: Arc<Secp256k1Keypair>,
+    keypair: Arc<SigningKey>,
     /// Resources for the actor store.
-    resources: Arc<ActorStoreResources>,
+    pub(crate) resources: Arc<ActorStoreResources>,
+    /// Repository access
+    pub(crate) repo: repo::RepoTransactor,
+    /// Record access
+    pub(crate) record: record::RecordTransactor,
+    /// Preference access
+    pub(crate) pref: preference::PreferenceTransactor,
 }
 
 /// Transactor for actor data.
 pub(crate) struct ActorStoreTransactor {
     /// The DID of the actor.
-    did: String,
+    pub(crate) did: String,
     /// The database connection.
-    db: SqlitePool,
+    pub(crate) db: SqlitePool,
     /// The actor's keypair.
-    keypair: Arc<Secp256k1Keypair>,
+    keypair: Arc<SigningKey>,
     /// Resources for the actor store.
-    resources: Arc<ActorStoreResources>,
+    pub(crate) resources: Arc<ActorStoreResources>,
+    /// Repository access
+    pub(crate) repo: repo::RepoTransactor,
+    /// Record access
+    pub(crate) record: record::RecordTransactor,
+    /// Preference access
+    pub(crate) pref: preference::PreferenceTransactor,
 }
 
 impl ActorStore {
···
         }
     }
 
+    /// Load an actor store based on a given DID.
+    pub(crate) async fn load(did: &str, resources: ActorStoreResources) -> Result<Self> {
+        let did_hash = sha256_hex(did).await?;
+        let directory = resources.config.path.join(&did_hash[0..2]).join(did);
+        let reserved_key_dir = directory.join("reserved_keys");
+
+        Ok(Self {
+            directory,
+            reserved_key_dir,
+            resources,
+        })
+    }
+
     /// Get the location of a DID's data.
     pub(crate) async fn get_location(&self, did: &str) -> Result<ActorLocation> {
         let did_hash = sha256_hex(did).await?;
···
     }
 
     /// Get the keypair for an actor.
-    pub(crate) async fn keypair(&self, did: &str) -> Result<Arc<Secp256k1Keypair>> {
+    pub(crate) async fn keypair(&self, did: &str) -> Result<Arc<SigningKey>> {
         let location = self.get_location(did).await?;
         let priv_key = tokio::fs::read(&location.key_location).await?;
-        let keypair = Secp256k1Keypair::import(&priv_key)?;
+        let keypair = SigningKey::import(&priv_key)?;
         Ok(Arc::new(keypair))
     }
 
···
         let db = self.open_db(did).await?;
         let keypair = self.keypair(did).await?;
         let resources = Arc::new(self.resources.clone());
+        let did_str = did.to_string();
 
         let reader = ActorStoreReader {
-            did: did.to_string(),
+            did: did_str.clone(),
+            repo: repo::RepoReader::new(
+                db.clone(),
+                did_str.clone(),
+                self.resources.blob_config.clone(),
+            ),
+            record: record::RecordReader::new(db.clone(), did_str.clone()),
+            pref: preference::PreferenceReader::new(db.clone(), did_str),
             db,
             keypair,
             resources,
···
     where
         F: FnOnce(ActorStoreTransactor) -> Result<T>,
     {
-        let db = self.open_db(did).await?;
         let keypair = self.keypair(did).await?;
+        let db = self.open_db(did).await?;
         let resources = Arc::new(self.resources.clone());
+        let did_str = did.to_string();
 
         let transactor = ActorStoreTransactor {
-            did: did.to_string(),
+            did: did_str.clone(),
+            repo: repo::RepoTransactor::new(
+                db.clone(),
+                did_str.clone(),
+                (*keypair).clone(),
+                self.resources.blob_config.clone(),
+            ),
+            record: record::RecordTransactor::new(
+                db.clone(),
+                db.clone(), // Using db as placeholder for blobstore
+                did_str.clone(),
+            ),
+            pref: preference::PreferenceTransactor::new(db.clone(), did_str),
             db,
             keypair,
             resources,
···
         let db = self.open_db(did).await?;
         let keypair = self.keypair(did).await?;
         let resources = Arc::new(self.resources.clone());
+        let did_str = did.to_string();
 
         let writer = ActorStoreWriter {
-            did: did.to_string(),
+            did: did_str.clone(),
+            repo: repo::RepoTransactor::new(
+                db.clone(),
+                did_str.clone(),
+                (*keypair).clone(),
+                self.resources.blob_config.clone(),
+            ),
+            record: record::RecordTransactor::new(
+                db.clone(),
+                db.clone(), // Using db as placeholder for blobstore
+                did_str.clone(),
+            ),
+            pref: preference::PreferenceTransactor::new(db.clone(), did_str),
             db,
             keypair,
             resources,
···
     }
 
     /// Create a new actor repository.
-    pub(crate) async fn create(&self, did: &str, keypair: Secp256k1Keypair) -> Result<()> {
+    pub(crate) async fn create(&self, did: &str, keypair: SigningKey) -> Result<()> {
         let location = self.get_location(did).await?;
 
         // Create directory if it doesn't exist
···
         Ok(())
     }
 
-    // TODO: To be implemented: destroy, reserve_keypair, etc.
+    /// Destroy an actor's repository and associated data.
+    pub(crate) async fn destroy(&self, did: &str) -> Result<()> {
+        // TODO: Implement repository destruction
+        // - Delete all blobs for the repository
+        // - Remove the repository directory
+        todo!("Implement repository destruction")
+    }
+
+    /// Reserve a keypair for a DID.
+    pub(crate) async fn reserve_keypair(&self, did: Option<&str>) -> Result<String> {
+        // TODO: Implement keypair reservation
+        // - Generate a keypair if one doesn't exist
+        // - Store the keypair in the reserved_key_dir
+        // - Return the DID of the keypair
+        todo!("Implement keypair reservation")
+    }
+
+    /// Get a reserved keypair.
+    pub(crate) async fn get_reserved_keypair(
+        &self,
+        signing_key_or_did: &str,
+    ) -> Result<Option<()>> {
+        // TODO: Implement getting a reserved keypair
+        // - Load the keypair from the reserved_key_dir
+        todo!("Implement getting a reserved keypair")
+    }
+
+    /// Clear a reserved keypair.
+    pub(crate) async fn clear_reserved_keypair(
+        &self,
+        key_did: &str,
+        did: Option<&str>,
+    ) -> Result<()> {
+        // TODO: Implement clearing a reserved keypair
+        // - Remove the keypair file from the reserved_key_dir
+        todo!("Implement clearing a reserved keypair")
+    }
+
+    /// Store a PLC operation.
+    pub(crate) async fn store_plc_op(&self, did: &str, op: &[u8]) -> Result<()> {
+        // TODO: Implement storing a PLC operation
+        // - Store the operation in the actor's directory
+        todo!("Implement storing a PLC operation")
+    }
+
+    /// Get a stored PLC operation.
+    pub(crate) async fn get_plc_op(&self, did: &str) -> Result<Vec<u8>> {
+        // TODO: Implement getting a PLC operation
+        // - Retrieve the operation from the actor's directory
+        todo!("Implement getting a PLC operation")
+    }
+
+    /// Clear a stored PLC operation.
+    pub(crate) async fn clear_plc_op(&self, did: &str) -> Result<()> {
+        // TODO: Implement clearing a PLC operation
+        // - Remove the operation file from the actor's directory
+        todo!("Implement clearing a PLC operation")
+    }
 }
 
-// Helper function for SHA-256 hashing
-async fn sha256_hex(input: &str) -> Result<String> {
-    use sha2::{Digest, Sha256};
-    let mut hasher = Sha256::new();
-    hasher.update(input.as_bytes());
-    let result = hasher.finalize();
-    Ok(hex::encode(result))
+impl ActorStoreWriter {
+    /// Transact with the writer.
+    pub(crate) async fn transact<T, F>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(ActorStoreTransactor) -> Result<T>,
+    {
+        todo!("Implement transact method for ActorStoreWriter")
+    }
 }
 
 impl Clone for ActorStoreResources {
     fn clone(&self) -> Self {
         Self {
             config: self.config.clone(),
+            blob_config: self.blob_config.clone(),
             background_queue: self.background_queue.clone(),
         }
     }
 }
+
+// Helper function for SHA-256 hashing
+async fn sha256_hex(input: &str) -> Result<String> {
+    use sha2::{Digest, Sha256};
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    let result = hasher.finalize();
+    Ok(hex::encode(result))
+}

src/actor_store/preference/mod.rs

···
 
 mod reader;
 mod transactor;
+
+pub(crate) use reader::PreferenceReader;
+pub(crate) use transactor::PreferenceTransactor;

src/actor_store/preference/transactor.rs

···
 use super::reader::{AccountPreference, PreferenceReader, pref_in_scope, pref_match_namespace};
 
 /// Transactor for preference operations.
-pub(super) struct PreferenceTransactor {
+pub(crate) struct PreferenceTransactor {
     /// Preference reader.
     pub reader: PreferenceReader,
 }
 
 impl PreferenceTransactor {
     /// Create a new preference transactor.
-    pub(super) fn new(db: SqlitePool, did: String) -> Self {
+    pub(crate) fn new(db: SqlitePool, did: String) -> Self {
         Self {
             reader: PreferenceReader::new(db, did),
         }
     }
 
     /// Put preferences for a namespace.
-    pub(super) async fn put_preferences(
+    pub(crate) async fn put_preferences(
         &self,
         values: Vec<AccountPreference>,
         namespace: &str,

src/actor_store/record/mod.rs

···
 
 mod reader;
 mod transactor;
+
+pub(crate) use reader::RecordReader;
+pub(crate) use transactor::RecordTransactor;

src/actor_store/repo/mod.rs

···
 mod sql_repo_reader;
 mod sql_repo_transactor;
 mod transactor;
+
+pub(crate) use reader::RepoReader;
+pub(crate) use sql_repo_reader::SqlRepoReader;
+pub(crate) use sql_repo_transactor::SqlRepoTransactor;
+pub(crate) use transactor::RepoTransactor;

src/config.rs

···
 pub(crate) struct RepoConfig {
     /// The path to the repository storage.
     pub path: PathBuf,
-    /// Use SQLite for repository storage instead of CAR files.
-    #[serde(default)]
-    pub use_sqlite: bool,
 }
 
 #[derive(Deserialize, Debug, Clone)]

src/main.rs

···
     }
 }
 
+impl SigningKey {
+    /// Import from a private key.
+    pub fn import(key: &[u8]) -> Result<Self> {
+        let key = Secp256k1Keypair::import(key).context("failed to import signing key")?;
+        Ok(Self(Arc::new(key)))
+    }
+}
+
 impl std::ops::Deref for RotationKey {
     type Target = Secp256k1Keypair;