prototype actor_store

src/actor_store/actor_store.rs

···
 use cidv10::Cid;
 use diesel::*;
 use futures::stream::{self, StreamExt};
-use rsky_common;
 use rsky_pds::actor_store::repo::types::SyncEvtData;
 use rsky_repo::repo::Repo;
 use rsky_repo::storage::readable_blockstore::ReadableBlockstore;
···
 use rsky_syntax::aturi::AtUri;
 use secp256k1::{Keypair, Secp256k1, SecretKey};
 use std::env;
-use std::fmt;
 use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
···
     pub async fn destroy(&mut self) -> Result<()> {
         let did: String = self.did.clone();
         let storage_guard = self.storage.read().await;
-        let db: Arc<ActorDb> = storage_guard.db.clone();
+        let db: ActorDb = storage_guard.db.clone();
         use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
         let blob_rows: Vec<String> = db
···
         }
         let did: String = self.did.clone();
         let storage_guard = self.storage.read().await;
-        let db: Arc<ActorDb> = storage_guard.db.clone();
+        let db: ActorDb = storage_guard.db.clone();
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
         let cid_strs: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();

src/actor_store/blob.rs

···
 use rsky_pds::models::models;
 use rsky_repo::error::BlobError;
 use rsky_repo::types::{PreparedBlobRef, PreparedWrite};
-use sha2::{Digest, Sha256};
+use sha2::Digest;
 
 use super::ActorDb;
 use super::sql_blob::BlobStoreSql;
···
 // Basically handles getting blob records from db
 impl BlobReader {
     pub fn new(blobstore: BlobStoreSql, db: ActorDb) -> Self {
-        BlobReader {
-            did: blobstore.bucket.clone(),
-            blobstore,
-            db,
-        }
+        // BlobReader {
+        //     did: blobstore.bucket.clone(),
+        //     blobstore,
+        //     db,
+        // }
+        todo!();
     }
 
     pub async fn get_blob_metadata(&self, cid: Cid) -> Result<GetBlobMetadataOutput> {
···
 
     pub async fn get_blob(&self, cid: Cid) -> Result<GetBlobOutput> {
         let metadata = self.get_blob_metadata(cid).await?;
-        let blob_stream = match self.blobstore.get_stream(cid).await {
-            Ok(res) => res,
-            Err(e) => {
-                return match e.downcast_ref() {
-                    Some(GetObjectError::NoSuchKey(key)) => {
-                        Err(anyhow::Error::new(GetObjectError::NoSuchKey(key.clone())))
-                    }
-                    _ => bail!(e.to_string()),
-                };
-            }
-        };
-        Ok(GetBlobOutput {
-            size: metadata.size,
-            mime_type: metadata.mime_type,
-            stream: blob_stream,
-        })
+        // let blob_stream = match self.blobstore.get_stream(cid).await {
+        //     Ok(res) => res,
+        //     Err(e) => {
+        //         return match e.downcast_ref() {
+        //             Some(GetObjectError::NoSuchKey(key)) => {
+        //                 Err(anyhow::Error::new(GetObjectError::NoSuchKey(key.clone())))
+        //             }
+        //             _ => bail!(e.to_string()),
+        //         };
+        //     }
+        // };
+        // Ok(GetBlobOutput {
+        //     size: metadata.size,
+        //     mime_type: metadata.mime_type,
+        //     stream: blob_stream,
+        // })
+        todo!();
     }
 
     pub async fn get_records_for_blob(&self, cid: Cid) -> Result<Vec<String>> {
···
     pub async fn upload_blob_and_get_metadata(
         &self,
         user_suggested_mime: String,
-        blob: Data<'_>,
+        blob: Data<'_>, // Type representing the body data of a request.
     ) -> Result<BlobMetadata> {
+        todo!();
         let blob_stream = blob.open(100.mebibytes());
         let bytes = blob_stream.into_bytes().await?;
         let size = bytes.n.written;

src/actor_store/mod.rs

···
 mod sql_blob;
 mod sql_repo;
 
-pub(crate) use actor_store::ActorStore;
 pub(crate) use db::ActorDb;
-pub(crate) use sql_blob::BlobStoreSql;

src/actor_store/preference.rs

···
 use rsky_pds::actor_store::preference::util::pref_in_scope;
 use rsky_pds::auth_verifier::AuthScope;
 use rsky_pds::db::DbConn;
-use rsky_pds::models;
 use rsky_pds::models::AccountPref;
 use std::sync::Arc;
 
···
                         use rsky_pds::schema::pds::account_pref::dsl as AccountPrefSchema;
                         let all_prefs = AccountPrefSchema::account_pref
                             .filter(AccountPrefSchema::did.eq(&did))
-                            .select(models::AccountPref::as_select())
+                            .select(AccountPref::as_select())
                             .load(conn)?;
                         let put_prefs = values
                             .into_iter()

src/actor_store/record.rs

···
 use futures::stream::{self, StreamExt};
 use rsky_lexicon::com::atproto::admin::StatusAttr;
 use rsky_pds::actor_store::record::{GetRecord, RecordsForCollection, get_backlinks};
-use rsky_pds::models::{Backlink, Record};
+use rsky_pds::models::{Backlink, Record, RepoBlock};
 use rsky_repo::types::{RepoRecord, WriteOpAction};
 use rsky_repo::util::cbor_to_lex_record;
 use rsky_syntax::aturi::AtUri;
···
         let mut builder = RecordSchema::record
             .inner_join(RepoBlockSchema::repo_block.on(RepoBlockSchema::cid.eq(RecordSchema::cid)))
             .limit(limit)
-            .select((
-                rsky_pds::models::Record::as_select(),
-                rsky_pds::models::RepoBlock::as_select(),
-            ))
+            .select((Record::as_select(), RepoBlock::as_select()))
             .filter(RecordSchema::did.eq(self.did.clone()))
             .filter(RecordSchema::collection.eq(collection))
             .into_boxed();
···
                 builder = builder.filter(RecordSchema::rkey.lt(rkey_end));
             }
         }
-        let res: Vec<(rsky_pds::models::Record, rsky_pds::models::RepoBlock)> =
-            self.db.run(move |conn| builder.load(conn)).await?;
+        let res: Vec<(Record, RepoBlock)> = self.db.run(move |conn| builder.load(conn)).await?;
         res.into_iter()
             .map(|row| {
                 Ok(RecordsForCollection {
···
         };
         let mut builder = RecordSchema::record
             .inner_join(RepoBlockSchema::repo_block.on(RepoBlockSchema::cid.eq(RecordSchema::cid)))
-            .select((
-                rsky_pds::models::Record::as_select(),
-                rsky_pds::models::RepoBlock::as_select(),
-            ))
+            .select((Record::as_select(), RepoBlock::as_select()))
             .filter(RecordSchema::uri.eq(uri.to_string()))
             .into_boxed();
         if !include_soft_deleted {
···
         if let Some(cid) = cid {
             builder = builder.filter(RecordSchema::cid.eq(cid));
         }
-        let record: Option<(rsky_pds::models::Record, rsky_pds::models::RepoBlock)> = self
+        let record: Option<(Record, RepoBlock)> = self
             .db
             .run(move |conn| builder.first(conn).optional())
             .await?;
···
         let record_backlinks = get_backlinks(uri, record)?;
         let conflicts: Vec<Vec<Record>> = stream::iter(record_backlinks)
             .then(|backlink| async move {
-                Ok::<Vec<Record>, anyhow::Error>(
+                Ok::<Vec<Record>, Error>(
                     self.get_record_backlinks(
                         uri.get_collection(),
                         backlink.path,

src/actor_store/sql_blob.rs

···
     path: PathBuf,
 }
 
+/// Configuration for the blob store
+/// TODO: Implement this placeholder
+pub(crate) struct BlobConfig {
+    pub(crate) path: PathBuf,
+}
+
+/// ByteStream
+/// TODO: Implement this placeholder
+pub(crate) struct ByteStream {
+    pub(crate) bytes: Vec<u8>,
+}
+impl ByteStream {
+    pub async fn collect(self) -> Result<Vec<u8>> {
+        Ok(self.bytes)
+    }
+}
+
 impl BlobStoreSql {
-    pub fn new(did: String, cfg: &SdkConfig) -> Self {
+    pub fn new(did: String, cfg: &BlobConfig) -> Self {
         // let client = aws_sdk_s3::Client::new(cfg);
         // BlobStorePlaceholder {
         //     client,
···
         todo!();
     }
 
-    pub fn creator(cfg: &SdkConfig) -> Box<dyn Fn(String) -> BlobStoreSql + '_> {
+    pub fn creator(cfg: &BlobConfig) -> Box<dyn Fn(String) -> BlobStoreSql + '_> {
         Box::new(move |did: String| BlobStoreSql::new(did, cfg))
     }
 
···
 
     pub async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>> {
         let res = self.get_object(cid).await?;
-        let bytes = res.collect().await.map(|data| data.into_bytes())?;
-        Ok(bytes.to_vec())
+        // let bytes = res.collect().await.map(|data| data.into_bytes())?;
+        // Ok(bytes.to_vec())
+        todo!();
     }
 
     pub async fn get_stream(&self, cid: Cid) -> Result<ByteStream> {
···
         todo!();
     }
 }
+
+struct MoveObject {
+    from: String,
+    to: String,
+}