prototype actor_store sql_repo

Cargo.lock

···
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.0",
+ "windows-core",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
 dependencies = [
- "windows-core 0.58.0",
+ "windows-core",
  "windows-targets 0.52.6",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
 dependencies = [
- "windows-implement 0.58.0",
- "windows-interface 0.58.0",
+ "windows-implement",
+ "windows-interface",
  "windows-result 0.2.0",
  "windows-strings 0.1.0",
  "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "windows-core"
-version = "0.61.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
-dependencies = [
- "windows-implement 0.60.0",
- "windows-interface 0.59.1",
- "windows-link",
- "windows-result 0.3.2",
- "windows-strings 0.4.0",
-]
-
-[[package]]
 name = "windows-implement"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "windows-implement"
-version = "0.60.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.101",
-]
-
-[[package]]
 name = "windows-interface"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.101",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
 dependencies = [
  "proc-macro2",
  "quote",
···
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
 dependencies = [
  "windows-link",
 ]

src/actor_store/repo/sql_repo_reader.rs

···
     Cid,
     blockstore::{AsyncBlockStoreRead, Error as BlockstoreError},
 };
-use rsky_repo::{block_map::BlockMap, cid_set::CidSet};
-use sha2::Digest;
 use sqlx::{Row, SqlitePool};
 use std::str::FromStr;
 use std::sync::Arc;
···
     }
 
     // async getRoot(): Promise<CID> {
-    // async getBytes(cid: CID): Promise<Uint8Array | null> {
     // async has(cid: CID): Promise<boolean> {
     // async getCarStream(since?: string) {
     // async *iterateCarBlocks(since?: string): AsyncIterable<CarBlock> {
     // async getBlockRange(since?: string, cursor?: RevCursor) {
     // async countBlocks(): Promise<number> {
     // async destroy(): Promise<void> {
+
+    pub(crate) async fn get_bytes(&self, cid: &Cid) -> Result<Option<Vec<u8>>> {
+        // First check the cache
+        {
+            let cache_guard = self.cache.read().await;
+            if let Some(cached) = cache_guard.get(*cid) {
+                return Ok(Some(cached.clone()));
+            }
+        }
+
+        // Not in cache, query from database
+        let cid_str = cid.to_string();
+        let did = self.did.clone();
+
+        let content = sqlx::query!(r#"SELECT content FROM repo_block WHERE cid = ?"#, cid_str,)
+            .fetch_optional(&self.db)
+            .await
+            .context("failed to fetch block content")?
+            .map(|row| row.content);
+
+        // If found, update the cache
+        if let Some(bytes) = &content {
+            let mut cache_guard = self.cache.write().await;
+            cache_guard.set(*cid, bytes.clone());
+        }
+
+        Ok(content)
+    }
 
     /// Get the detailed root information.
     pub(crate) async fn get_root_detailed(&self) -> Result<RootInfo> {

src/actor_store/repo/sql_repo_transactor.rs

···
     Cid,
     blockstore::{AsyncBlockStoreWrite, Error as BlockstoreError},
 };
-use rsky_repo::{block_map::BlockMap, types::CommitData};
 use sha2::Digest;
 use sqlx::SqlitePool;
 
···
     /// Apply a commit to the repository.
     pub(crate) async fn apply_commit(&self, commit: CommitData, is_create: bool) -> Result<()> {
         let is_create = is_create || false;
+        let removed_cids_list = commit.removed_cids.to_list();
 
         // Run these operations in parallel for better performance
         tokio::try_join!(
             self.update_root(commit.cid, &commit.rev, is_create),
             self.put_many(&commit.new_blocks, &commit.rev),
-            self.delete_many(&commit.removed_cids.to_list())
+            self.delete_many(&removed_cids_list)
         )?;
 
         Ok(())
···
     /// Put a block into the repository.
     pub(crate) async fn put_block(&self, cid: Cid, block: &[u8], rev: &str) -> Result<()> {
         let cid_str = cid.to_string();
-        let did = self.reader.did.clone();
 
+        let block_len = block.len() as i64;
         sqlx::query!(
             r#"
                 INSERT INTO repo_block (cid, repoRev, size, content)
···
                 "#,
             cid_str,
             rev,
-            block.len() as i64,
+            block_len,
             block
         )
         .execute(&self.reader.db)
···
 
     /// Put many blocks into the repository.
     pub(crate) async fn put_many(&self, blocks: &BlockMap, rev: &str) -> Result<()> {
-        if blocks.is_empty() {
+        if blocks.size() == 0 {
             return Ok(());
         }
 
···
         let mut batch = Vec::new();
 
         blocks.for_each(|cid, bytes| {
+            let cid_string = format!("{:?}", cid);
             batch.push((
-                cid.to_string(),
+                cid_string,
                 did.clone(),
                 rev.to_string(),
-                bytes.len() as i64,
+                bytes.encoded_len() as i64,
                 bytes.clone(),
             ));
         });
···
         contents: &[u8],
     ) -> impl Future<Output = Result<Cid, BlockstoreError>> + Send {
         let contents = contents.to_vec();
-        let did = self.reader.did.clone();
         let rev = self.now.clone();
 
         async move {
···
 
             let cid = Cid::new_v1(codec, multihash);
             let cid_str = cid.to_string();
+            let contents_len = contents.len() as i64;
 
             sqlx::query!(
                 r#"
···
                     "#,
                 cid_str,
                 rev,
-                contents.len() as i64,
+                contents_len,
                 contents
             )
             .execute(&self.reader.db)
             .await
             .map_err(|e| BlockstoreError::Other(Box::new(e)))?;
 
-            self.cache.set(cid, contents);
+            self.cache.set(&cid, contents);
             Ok(cid)
         }
     }