prototype actor_store

src/actor_store/actor_store_reader.rs

···
 
 use super::{
     ActorStoreTransactor, actor_store_resources::ActorStoreResources, db::ActorDb,
-    preference::PreferenceReader, record::RecordReader,
+    preference::PreferenceReader, record::RecordReader, repo::RepoReader,
 };
 use crate::SigningKey;
 
···
     pub(crate) record: RecordReader,
     /// Preference reader.
     pub(crate) pref: PreferenceReader,
-    /// RepoReader placeholder - will be implemented later.
-    pub(crate) repo: (), // Placeholder for RepoReader
+    /// RepoReader
+    pub(crate) repo: RepoReader,
     /// Function to get keypair.
     keypair_fn: Box<dyn Fn() -> Result<Arc<SigningKey>> + Send + Sync>,
     /// Database connection.
···
         // Initial keypair call as in TypeScript implementation
         let _ = keypair_fn();
 
-        // For now, we use a placeholder for RepoReader
-        // Real implementation will need to be added later
-        let repo = ();
+        // Create repo reader
+        let repo = RepoReader::new(db.clone(), resources.blobstore(did.clone()));
 
         Self {
             did,

src/actor_store/actor_store_transactor.rs

···
 
         let record = RecordTransactor::new(db.clone(), blobstore.clone());
         let pref = PreferenceTransactor::new(db.clone());
-        let repo = RepoTransactor::new(db, blobstore, did, keypair, resources.background_queue);
+        let repo = RepoTransactor::new(
+            db,
+            blobstore,
+            did,
+            keypair,
+            resources.background_queue,
+            None,
+        );
 
         Self { record, repo, pref }
     }

src/actor_store/actor_store_writer.rs

···
 use std::sync::Arc;
 
-use super::resources::ActorStoreResources;
+use super::{ActorDb, ActorStoreResources};
 use crate::SigningKey;
 
 pub(crate) struct ActorStoreWriter {

src/actor_store/blob/mod.rs

···
 
 mod background;
 mod reader;
+mod store;
 mod transactor;
 
 pub(crate) use background::BackgroundQueue;
 pub(crate) use reader::BlobReader;
+pub(crate) use store::BlobStore;
+pub(crate) use store::BlobStorePlaceholder;
+pub(crate) use store::BlobStream;
 pub(crate) use transactor::BlobTransactor;

src/actor_store/blob/reader.rs

···
 use atrium_repo::Cid;
 use sqlx::Row;
 
-use crate::{
-    actor_store::ActorDb,
-    repo::types::{BlobStore, BlobStoreTrait, BlobStream},
-};
+use crate::actor_store::ActorDb;
+
+use super::{BlobStore, BlobStorePlaceholder, BlobStream};
 
 /// Reader for blob data in the actor store.
 pub(crate) struct BlobReader {
     /// Database connection.
     pub db: ActorDb,
     /// BlobStore.
-    pub blobstore: BlobStore,
+    pub blobstore: BlobStorePlaceholder,
 }
 
 impl BlobReader {
     /// Create a new blob reader.
-    pub(crate) fn new(db: ActorDb, blobstore: BlobStore) -> Self {
+    pub(crate) fn new(db: ActorDb, blobstore: BlobStorePlaceholder) -> Self {
         Self { db, blobstore }
     }
 
···
         &self,
         cid: &Cid,
     ) -> Result<Option<StatusAttrData>> {
-        // const res = await this.db.db
-        //   .selectFrom('blob')
-        //   .select('takedownRef')
-        //   .where('cid', '=', cid.toString())
-        //   .executeTakeFirst()
-        // if (!res) return null
-        // return res.takedownRef
-        //   ? { applied: true, ref: res.takedownRef }
-        //   : { applied: false }
         let cid_str = cid.to_string();
         let result = sqlx::query!(r#"SELECT takedownRef FROM blob WHERE cid = ?"#, cid_str)
             .fetch_optional(&self.db.pool)
···
 
     /// Get blobs referenced by a record.
     pub(crate) async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
-        // const res = await this.db.db
-        //   .selectFrom('blob')
-        //   .innerJoin('record_blob', 'record_blob.blobCid', 'blob.cid')
-        //   .where('recordUri', '=', recordUri)
-        //   .select('blob.cid')
-        //   .execute()
-        // return res.map((row) => row.cid)
         let blobs = sqlx::query!(
             r#"SELECT blob.cid FROM blob INNER JOIN record_blob ON record_blob.blobCid = blob.cid WHERE recordUri = ?"#,
             record_uri

src/actor_store/blob/transactor.rs

···
 use atrium_repo::Cid;
 use futures::FutureExt;
 use futures::future::BoxFuture;
+use rsky_repo::types::{PreparedBlobRef, WriteOpAction};
 use uuid::Uuid;
 
-use super::{BackgroundQueue, BlobReader};
-use crate::{
-    actor_store::ActorDb,
-    repo::{
-        block_map::sha256_raw_to_cid,
-        types::{BlobStore, BlobStoreTrait as _, PreparedBlobRef, PreparedWrite, WriteOpAction},
-    },
-};
+use super::{BackgroundQueue, BlobReader, BlobStore};
+use crate::actor_store::{ActorDb, PreparedWrite, blob::BlobStore as _};
 
 /// Blob metadata for a newly uploaded blob.
 #[derive(Debug, Clone)]

src/actor_store/mod.rs

···
 mod blob;
 mod db;
 mod preference;
+mod prepared_write;
 mod record;
 mod repo;
 
···
 pub(crate) use actor_store_transactor::ActorStoreTransactor;
 pub(crate) use actor_store_writer::ActorStoreWriter;
 pub(crate) use db::ActorDb;
+pub(crate) use prepared_write::PreparedWrite;

src/actor_store/repo/reader.rs

···
 
 use anyhow::Result;
 use atrium_repo::Cid;
+use rsky_repo::storage::readable_blockstore::ReadableBlockstore as _;
 
 use super::sql_repo_reader::SqlRepoReader;
 use crate::{

src/main.rs

···
 mod mmap;
 mod oauth;
 mod plc;
-mod repo;
 mod storage;
 #[cfg(test)]
 mod tests;