actor_store prototyping

Cargo.lock

···
 checksum = "9425c3bf7089c983facbae04de54513cce73b41c7f9ff8c845b54e7bc64ebbfb"
 
 [[package]]
+name = "bitcoin-io"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+
+[[package]]
 name = "bitcoin_hashes"
 version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1930a4dabfebb8d7d9992db18ebe3ae2876f0a305fab206fd168df931ede293b"
 dependencies = [
  "bitcoin-internals",
- "hex-conservative",
+ "hex-conservative 0.1.2",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative 0.2.1",
 ]
 
 [[package]]
···
  "reqwest 0.12.15",
  "reqwest-middleware",
  "rsky-common",
+ "rsky-lexicon",
  "rsky-pds",
  "rsky-repo",
  "rsky-syntax",
+ "secp256k1 0.31.0",
  "serde",
  "serde_bytes",
  "serde_ipld_dagcbor",
···
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "212ab92002354b4819390025006c897e8140934349e8635c9b077f47b4dcbd20"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd"
+dependencies = [
+ "arrayvec",
+]
 
 [[package]]
 name = "hickory-proto"
···
  "rand_core 0.6.4",
  "regex",
  "rsky-identity",
- "secp256k1",
+ "secp256k1 0.28.2",
  "serde",
  "serde_ipld_dagcbor",
  "serde_json",
···
  "anyhow",
  "multibase",
  "p256 0.13.2",
- "secp256k1",
+ "secp256k1 0.28.2",
  "unsigned-varint 0.8.0",
 ]
 
···
  "libipld",
  "miette",
  "parking_lot",
- "secp256k1",
+ "secp256k1 0.28.2",
  "serde",
  "serde_bytes",
  "serde_cbor",
···
  "rsky-lexicon",
  "rsky-repo",
  "rsky-syntax",
- "secp256k1",
+ "secp256k1 0.28.2",
  "serde",
  "serde_bytes",
  "serde_cbor",
···
  "rsky-crypto",
  "rsky-lexicon",
  "rsky-syntax",
- "secp256k1",
+ "secp256k1 0.28.2",
  "serde",
  "serde_bytes",
  "serde_cbor",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24b59d129cdadea20aea4fb2352fa053712e5d713eee47d700cd4b2bc002f10"
 dependencies = [
- "bitcoin_hashes",
+ "bitcoin_hashes 0.13.0",
  "rand 0.8.5",
- "secp256k1-sys",
+ "secp256k1-sys 0.9.2",
  "serde",
 ]
 
 [[package]]
+name = "secp256k1"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a3dff2d01c9aa65c3186a45ff846bfea52cbe6de3b6320ed2a358d90dad0d76"
+dependencies = [
+ "bitcoin_hashes 0.14.0",
+ "rand 0.9.1",
+ "secp256k1-sys 0.11.0",
+]
+
+[[package]]
 name = "secp256k1-sys"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5d1746aae42c19d583c3c1a8c646bfad910498e2051c551a7f2e3c0c9fbb7eb"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcb913707158fadaf0d8702c2db0e857de66eb003ccfdda5924b5f5ac98efb38"
 dependencies = [
  "cc",
 ]

Cargo.toml

···
 rsky-repo = { git = "https://github.com/blacksky-algorithms/rsky.git" }
 rsky-pds = { git = "https://github.com/blacksky-algorithms/rsky.git" }
 rsky-common = { git = "https://github.com/blacksky-algorithms/rsky.git" }
+rsky-lexicon = { git = "https://github.com/blacksky-algorithms/rsky.git" }
 
 # async in streams
 # async-stream = "0.3"
···
 urlencoding = "2.1.3"
 async-trait = "0.1.88"
 lazy_static = "1.5.0"
+secp256k1 = "0.31.0"

src/actor_store/actor_store.rs

···
-use std::path::PathBuf;
+//! Based on https://github.com/blacksky-algorithms/rsky/blob/main/rsky-pds/src/actor_store/mod.rs
+//! Which is based on https://github.com/bluesky-social/atproto/blob/main/packages/repo/src/repo.ts
+//! and also adds components from https://github.com/bluesky-social/atproto/blob/main/packages/pds/src/actor-store/repo/transactor.ts
+//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
+//!
+//! Modified for SQLite backend
+
+use anyhow::Result;
+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_repo::storage::types::RepoStorage;
+use rsky_repo::types::{
+    CommitAction, CommitData, CommitDataWithOps, CommitOp, PreparedCreateOrUpdate, PreparedWrite,
+    RecordCreateOrUpdateOp, RecordWriteEnum, RecordWriteOp, WriteOpAction, write_to_op,
+};
+use rsky_repo::util::format_data_key;
+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;
 
-use anyhow::{Context as _, Result, anyhow, bail};
-use atrium_crypto::keypair::{Did as _, Export as _, Secp256k1Keypair};
-use atrium_repo::Cid;
-use diesel::prelude::*;
-use sha2::Digest as _;
-use tokio::fs;
+use super::ActorDb;
+use super::blob::BlobReader;
+use super::preference::PreferenceReader;
+use super::record::RecordReader;
+use super::sql_blob::BlobStoreSql;
+use super::sql_repo::SqlRepoReader;
 
-use super::PreparedWrite;
-use super::actor_store_handler::ActorStoreHandler;
-use super::actor_store_resources::ActorStoreResources;
-use super::blob::{BlobStore as _, BlobStorePlaceholder};
-use super::db::{ActorDb, get_db};
-use crate::SigningKey;
-
-/// Central manager for actor stores
-pub(crate) struct ActorStore {
-    /// Base directory for actor data
-    pub directory: PathBuf,
-    /// Resources shared between actor stores
-    pub resources: ActorStoreResources,
+#[derive(Debug)]
+enum FormatCommitError {
+    BadRecordSwap(String),
+    RecordSwapMismatch(String),
+    BadCommitSwap(String),
+    MissingRepoRoot(String),
 }
 
-struct ActorLocation {
-    /// Actor's directory path
-    directory: PathBuf,
-    /// Database path
-    db_location: PathBuf,
-    /// Key path
-    key_location: PathBuf,
+pub struct ActorStore {
+    pub did: String,
+    pub storage: Arc<RwLock<SqlRepoReader>>, // get ipld blocks from db
+    pub record: RecordReader,                // get lexicon records from db
+    pub blob: BlobReader,                    // get blobs
+    pub pref: PreferenceReader,              // get preferences
 }
 
+// Combination of RepoReader/Transactor, BlobReader/Transactor, SqlRepoReader/Transactor
 impl ActorStore {
-    /// Create a new actor store manager
-    pub(crate) fn new(directory: impl Into<PathBuf>, resources: ActorStoreResources) -> Self {
-        Self {
-            directory: directory.into(),
-            resources,
+    /// Concrete reader of an individual repo (hence BlobStoreSql which takes `did` param)
+    pub fn new(did: String, blobstore: BlobStoreSql, db: ActorDb) -> Self {
+        let db = Arc::new(db);
+        ActorStore {
+            storage: Arc::new(RwLock::new(SqlRepoReader::new(
+                did.clone(),
+                None,
+                db.clone(),
+            ))),
+            record: RecordReader::new(did.clone(), db.clone()),
+            pref: PreferenceReader::new(did.clone(), db.clone()),
+            did,
+            blob: BlobReader::new(blobstore, db.clone()), // Unlike TS impl, just use blob reader vs generator
         }
     }
 
-    /// Get the location information for an actor
-    pub(crate) async fn get_location(&self, did: &str) -> Result<ActorLocation> {
-        // Hash the DID for directory organization
-        let did_hash = sha2::Sha256::digest(did.as_bytes());
-        let hash_prefix = format!("{:02x}", did_hash[0]);
-
-        // Create paths
-        let directory = self.directory.join(hash_prefix).join(did);
-        let db_location = directory.join("store.sqlite");
-        let key_location = directory.join("key");
-
-        Ok(ActorLocation {
-            directory,
-            db_location,
-            key_location,
-        })
+    pub async fn get_repo_root(&self) -> Option<Cid> {
+        let storage_guard = self.storage.read().await;
+        storage_guard.get_root().await
     }
 
-    /// Check if an actor store exists
-    pub(crate) async fn exists(&self, did: &str) -> Result<bool> {
-        let location = self.get_location(did).await?;
-        Ok(location.db_location.exists())
-    }
-
-    /// Get the signing keypair for an actor
-    pub(crate) async fn keypair(&self, did: &str) -> Result<Arc<SigningKey>> {
-        let location = self.get_location(did).await?;
-        let priv_key = fs::read(&location.key_location)
-            .await
-            .context("Failed to read key file")?;
-
-        let keypair = SigningKey::import(&priv_key).context("Failed to import signing key")?;
-
-        Ok(Arc::new(keypair))
-    }
-
-    /// Open the database for an actor
-    pub(crate) async fn open_db(&self, did: &str) -> Result<ActorDb> {
-        let location = self.get_location(did).await?;
-
-        if !location.db_location.exists() {
-            bail!("Repo not found");
-        }
-
-        // Convert path to string for SQLite connection
-        let db_path = location
-            .db_location
-            .to_str()
-            .ok_or_else(|| anyhow!("Invalid path encoding"))?;
-
-        // Open database with WAL mode enabled
-        let db = get_db(db_path, false)
-            .await
-            .context("Failed to open actor database")?;
-
-        // Run a simple query to ensure the database is ready
-        db.run(|conn| diesel::sql_query("SELECT 1 FROM repo_root LIMIT 1").execute(conn))
-            .await
-            .context("Database not ready")?;
-
-        Ok(db)
-    }
-
-    /// Execute read operations on an actor store
-    pub(crate) async fn read<T, F>(&self, did: &str, f: F) -> Result<T>
-    where
-        F: FnOnce(ActorStoreHandler) -> Result<T>,
-    {
-        let db = self.open_db(did).await?;
-        let blobstore = self.resources.blobstore(did.to_string());
-
-        // Create a read-only handler
-        let handler = ActorStoreHandler::new_reader(db.clone(), did.to_string(), blobstore);
-
-        // Execute the function
-        f(handler)
-    }
+    // Transactors
+    // -------------------
 
-    /// Execute read-write operations with a transaction
-    pub(crate) async fn transact<T, F>(&self, did: &str, f: F) -> Result<T>
-    where
-        F: FnOnce(ActorStoreHandler) -> Result<T>,
-    {
-        let db = self.open_db(did).await?;
-        let keypair = self.keypair(did).await?;
-        let blobstore = self.resources.blobstore(did.to_string());
-        let background_queue = self.resources.background_queue();
-
-        // Create a read-write handler with transaction support
-        let handler = ActorStoreHandler::new_writer(
-            db,
-            did.to_string(),
-            blobstore,
+    #[deprecated]
+    pub async fn create_repo_legacy(
+        &self,
+        keypair: Keypair,
+        writes: Vec<PreparedCreateOrUpdate>,
+    ) -> Result<CommitData> {
+        let write_ops = writes
+            .clone()
+            .into_iter()
+            .map(|prepare| {
+                let at_uri: AtUri = prepare.uri.try_into()?;
+                Ok(RecordCreateOrUpdateOp {
+                    action: WriteOpAction::Create,
+                    collection: at_uri.get_collection(),
+                    rkey: at_uri.get_rkey(),
+                    record: prepare.record,
+                })
+            })
+            .collect::<Result<Vec<RecordCreateOrUpdateOp>>>()?;
+        let commit = Repo::format_init_commit(
+            self.storage.clone(),
+            self.did.clone(),
             keypair,
-            background_queue.as_ref().clone(),
-        );
-
-        // Execute the function (will handle transactions internally)
-        f(handler)
+            Some(write_ops),
+        )
+        .await?;
+        let storage_guard = self.storage.read().await;
+        storage_guard.apply_commit(commit.clone(), None).await?;
+        let writes = writes
+            .into_iter()
+            .map(PreparedWrite::Create)
+            .collect::<Vec<PreparedWrite>>();
+        self.blob.process_write_blobs(writes).await?;
+        Ok(commit)
     }
 
-    /// Execute read-write operations without a transaction
-    pub(crate) async fn write_no_transaction<T, F>(&self, did: &str, f: F) -> Result<T>
-    where
-        F: FnOnce(ActorStoreHandler) -> Result<T>,
-    {
-        let db = self.open_db(did).await?;
-        let keypair = self.keypair(did).await?;
-        let blobstore = self.resources.blobstore(did.to_string());
-        let background_queue = self.resources.background_queue();
-
-        // Create a read-write handler without automatic transaction
-        let handler = ActorStoreHandler::new_writer(
-            db,
-            did.to_string(),
-            blobstore,
+    pub async fn create_repo(
+        &self,
+        keypair: Keypair,
+        writes: Vec<PreparedCreateOrUpdate>,
+    ) -> Result<CommitDataWithOps> {
+        let write_ops = writes
+            .clone()
+            .into_iter()
+            .map(|prepare| {
+                let at_uri: AtUri = prepare.uri.try_into()?;
+                Ok(RecordCreateOrUpdateOp {
+                    action: WriteOpAction::Create,
+                    collection: at_uri.get_collection(),
+                    rkey: at_uri.get_rkey(),
+                    record: prepare.record,
+                })
+            })
+            .collect::<Result<Vec<RecordCreateOrUpdateOp>>>()?;
+        let commit = Repo::format_init_commit(
+            self.storage.clone(),
+            self.did.clone(),
             keypair,
-            background_queue.as_ref().clone(),
-        );
-
-        // Execute the function
-        f(handler)
+            Some(write_ops),
+        )
+        .await?;
+        let storage_guard = self.storage.read().await;
+        storage_guard.apply_commit(commit.clone(), None).await?;
+        let write_commit_ops = writes.iter().try_fold(
+            Vec::with_capacity(writes.len()),
+            |mut acc, w| -> Result<Vec<CommitOp>> {
+                let aturi: AtUri = w.uri.clone().try_into()?;
+                acc.push(CommitOp {
+                    action: CommitAction::Create,
+                    path: format_data_key(aturi.get_collection(), aturi.get_rkey()),
+                    cid: Some(w.cid.clone()),
+                    prev: None,
+                });
+                Ok(acc)
+            },
+        )?;
+        let writes = writes
+            .into_iter()
+            .map(PreparedWrite::Create)
+            .collect::<Vec<PreparedWrite>>();
+        self.blob.process_write_blobs(writes).await?;
+        Ok(CommitDataWithOps {
+            commit_data: commit,
+            ops: write_commit_ops,
+            prev_data: None,
+        })
     }
 
-    /// Create a new actor store
-    pub(crate) async fn create(&self, did: &str, keypair: SigningKey) -> Result<()> {
-        let location = self.get_location(did).await?;
-
-        // Ensure directory exists
-        fs::create_dir_all(&location.directory)
-            .await
-            .context("Failed to create directory")?;
-
-        // Check if repo already exists
-        if location.db_location.exists() {
-            bail!("Repo already exists");
+    pub async fn process_import_repo(
+        &mut self,
+        commit: CommitData,
+        writes: Vec<PreparedWrite>,
+    ) -> Result<()> {
+        {
+            let immutable_borrow = &self;
+            // & send to indexing
+            immutable_borrow
+                .index_writes(writes.clone(), &commit.rev)
+                .await?;
         }
-
-        // Export and save private key
-        let priv_key = keypair.export();
-        fs::write(&location.key_location, priv_key)
-            .await
-            .context("Failed to write key file")?;
-
-        // Initialize the database
-        let db_path = location
-            .db_location
-            .to_str()
-            .ok_or_else(|| anyhow!("Invalid path encoding"))?;
-
-        let db = get_db(db_path, false)
-            .await
-            .context("Failed to create actor database")?;
-
-        // Ensure WAL mode and run migrations
-        db.ensure_wal().await?;
-        db.run_migrations()?;
-
+        // persist the commit to repo storage
+        let storage_guard = self.storage.read().await;
+        storage_guard.apply_commit(commit.clone(), None).await?;
+        // process blobs
+        self.blob.process_write_blobs(writes).await?;
         Ok(())
     }
 
-    /// Destroy an actor store
-    pub(crate) async fn destroy(&self, did: &str) -> Result<()> {
-        // Get all blob CIDs first
-        let cids = self
-            .read(did, |handler| async move {
-                handler.repo.blob.get_blob_cids().await
-            })
-            .await?;
-
-        // Delete all blobs
-        let blobstore = self.resources.blobstore(did.to_string());
-        if !cids.is_empty() {
-            // Process in chunks of 500
-            for chunk in cids.chunks(500) {
-                let _ = blobstore.delete_many(chunk.to_vec()).await;
-            }
-        }
-
-        // Remove directory and all files
-        let location = self.get_location(did).await?;
-        if location.directory.exists() {
-            fs::remove_dir_all(&location.directory)
-                .await
-                .context("Failed to remove actor directory")?;
+    pub async fn process_writes(
+        &mut self,
+        writes: Vec<PreparedWrite>,
+        swap_commit_cid: Option<Cid>,
+    ) -> Result<CommitDataWithOps> {
+        // NOTE: In the typescript PR on sync v1.1
+        // there are some safeguards added for adding
+        // very large commits and very many commits
+        // for which I'm sure we could safeguard on
+        // but may not be necessary.
+        // https://github.com/bluesky-social/atproto/pull/3585/files#diff-7627844a4a6b50190014e947d1331a96df3c64d4c5273fa0ce544f85c3c1265f
+        let commit = self.format_commit(writes.clone(), swap_commit_cid).await?;
+        {
+            let immutable_borrow = &self;
+            // & send to indexing
+            immutable_borrow
+                .index_writes(writes.clone(), &commit.commit_data.rev)
+                .await?;
         }
+        // persist the commit to repo storage
+        let storage_guard = self.storage.read().await;
+        storage_guard
+            .apply_commit(commit.commit_data.clone(), None)
+            .await?;
+        // process blobs
+        self.blob.process_write_blobs(writes).await?;
+        Ok(commit)
+    }
 
-        Ok(())
+    pub async fn get_sync_event_data(&mut self) -> Result<SyncEvtData> {
+        let storage_guard = self.storage.read().await;
+        let current_root = storage_guard.get_root_detailed().await?;
+        let blocks_and_missing = storage_guard.get_blocks(vec![current_root.cid]).await?;
+        Ok(SyncEvtData {
+            cid: current_root.cid,
+            rev: current_root.rev,
+            blocks: blocks_and_missing.blocks,
+        })
     }
 
-    /// Reserve a keypair for future use
-    pub(crate) async fn reserve_keypair(&self, did: Option<&str>) -> Result<String> {
-        let reserved_dir = self
-            .resources
-            .reserved_key_dir()
-            .ok_or_else(|| anyhow!("No reserved key directory configured"))?;
-
-        // If DID is provided, check if key already exists
-        let mut key_path = None;
-        if let Some(did_str) = did {
-            assert_safe_path_part(did_str)?;
-            key_path = Some(reserved_dir.join(did_str));
-
-            if key_path.as_ref().unwrap().exists() {
-                let key_data = fs::read(key_path.as_ref().unwrap()).await?;
-                let keypair = Secp256k1Keypair::import(&key_data)
-                    .context("Failed to import existing reserved key")?;
-                return Ok(keypair.did());
+    pub async fn format_commit(
+        &mut self,
+        writes: Vec<PreparedWrite>,
+        swap_commit: Option<Cid>,
+    ) -> Result<CommitDataWithOps> {
+        let current_root = {
+            let storage_guard = self.storage.read().await;
+            storage_guard.get_root_detailed().await
+        };
+        if let Ok(current_root) = current_root {
+            if let Some(swap_commit) = swap_commit {
+                if !current_root.cid.eq(&swap_commit) {
+                    return Err(
+                        FormatCommitError::BadCommitSwap(current_root.cid.to_string()).into(),
+                    );
+                }
+            }
+            {
+                let mut storage_guard = self.storage.write().await;
+                storage_guard.cache_rev(current_root.rev).await?;
+            }
+            let mut new_record_cids: Vec<Cid> = vec![];
+            let mut delete_and_update_uris = vec![];
+            let mut commit_ops = vec![];
+            for write in &writes {
+                let commit_action: CommitAction = write.action().into();
+                match write.clone() {
+                    PreparedWrite::Create(c) => new_record_cids.push(c.cid),
+                    PreparedWrite::Update(u) => {
+                        new_record_cids.push(u.cid);
+                        let u_at_uri: AtUri = u.uri.try_into()?;
+                        delete_and_update_uris.push(u_at_uri);
+                    }
+                    PreparedWrite::Delete(d) => {
+                        let d_at_uri: AtUri = d.uri.try_into()?;
+                        delete_and_update_uris.push(d_at_uri)
+                    }
+                }
+                if write.swap_cid().is_none() {
+                    continue;
+                }
+                let write_at_uri: &AtUri = &write.uri().try_into()?;
+                let record = self
+                    .record
+                    .get_record(write_at_uri, None, Some(true))
+                    .await?;
+                let current_record = match record {
+                    Some(record) => Some(Cid::from_str(&record.cid)?),
+                    None => None,
+                };
+                let cid = match &write {
+                    &PreparedWrite::Delete(_) => None,
+                    &PreparedWrite::Create(w) | &PreparedWrite::Update(w) => Some(w.cid),
+                };
+                let mut op = CommitOp {
+                    action: commit_action,
+                    path: format_data_key(write_at_uri.get_collection(), write_at_uri.get_rkey()),
+                    cid,
+                    prev: None,
+                };
+                if let Some(_) = current_record {
+                    op.prev = current_record;
+                };
+                commit_ops.push(op);
+                match write {
+                    // There should be no current record for a create
+                    PreparedWrite::Create(_) if write.swap_cid().is_some() => {
+                        Err::<(), anyhow::Error>(
+                            FormatCommitError::BadRecordSwap(format!("{:?}", current_record))
+                                .into(),
+                        )
+                    }
+                    // There should be a current record for an update
+                    PreparedWrite::Update(_) if write.swap_cid().is_none() => {
+                        Err::<(), anyhow::Error>(
+                            FormatCommitError::BadRecordSwap(format!("{:?}", current_record))
+                                .into(),
+                        )
+                    }
+                    // There should be a current record for a delete
+                    PreparedWrite::Delete(_) if write.swap_cid().is_none() => {
+                        Err::<(), anyhow::Error>(
+                            FormatCommitError::BadRecordSwap(format!("{:?}", current_record))
+                                .into(),
+                        )
+                    }
+                    _ => Ok::<(), anyhow::Error>(()),
+                }?;
+                match (current_record, write.swap_cid()) {
+                    (Some(current_record), Some(swap_cid)) if current_record.eq(swap_cid) => {
+                        Ok::<(), anyhow::Error>(())
+                    }
+                    _ => Err::<(), anyhow::Error>(
+                        FormatCommitError::RecordSwapMismatch(format!("{:?}", current_record))
+                            .into(),
+                    ),
+                }?;
             }
-        }
-
-        // Create a new keypair
-        let keypair = Secp256k1Keypair::create(&mut rand::thread_rng());
-        let key_did = keypair.did();
-
-        // Set path if not already set
-        let final_path = key_path.unwrap_or_else(|| reserved_dir.join(&key_did));
-
-        // Ensure directory exists
-        fs::create_dir_all(reserved_dir).await?;
-
-        // Save key
-        fs::write(&final_path, keypair.export()).await?;
-
-        Ok(key_did)
-    }
-
-    /// Get a reserved keypair
-    pub(crate) async fn get_reserved_keypair(
-        &self,
-        key_did: &str,
-    ) -> Result<Option<Arc<SigningKey>>> {
-        let reserved_dir = self
-            .resources
-            .reserved_key_dir()
-            .ok_or_else(|| anyhow!("No reserved key directory configured"))?;
-
-        let key_path = reserved_dir.join(key_did);
-        if !key_path.exists() {
-            return Ok(None);
-        }
-
-        let key_data = fs::read(key_path).await?;
-        let keypair = SigningKey::import(&key_data).context("Failed to import reserved key")?;
-
-        Ok(Some(Arc::new(keypair)))
-    }
+            let mut repo = Repo::load(self.storage.clone(), Some(current_root.cid)).await?;
+            let previous_data = repo.commit.data;
+            let write_ops: Vec<RecordWriteOp> = writes
+                .into_iter()
+                .map(write_to_op)
+                .collect::<Result<Vec<RecordWriteOp>>>()?;
+            // @TODO: Use repo signing key global config
+            let secp = Secp256k1::new();
+            let repo_private_key = env::var("PDS_REPO_SIGNING_KEY_K256_PRIVATE_KEY_HEX").unwrap();
+            let repo_secret_key =
+                SecretKey::from_slice(&hex::decode(repo_private_key.as_bytes()).unwrap()).unwrap();
+            let repo_signing_key = Keypair::from_secret_key(&secp, &repo_secret_key);
 
-    /// Clear a reserved keypair
-    pub(crate) async fn clear_reserved_keypair(
-        &self,
-        key_did: &str,
-        did: Option<&str>,
-    ) -> Result<()> {
-        let reserved_dir = self
-            .resources
-            .reserved_key_dir()
-            .ok_or_else(|| anyhow!("No reserved key directory configured"))?;
+            let mut commit = repo
+                .format_commit(RecordWriteEnum::List(write_ops), repo_signing_key)
+                .await?;
 
-        // Remove key by DID
-        let key_path = reserved_dir.join(key_did);
-        if key_path.exists() {
-            fs::remove_file(key_path).await?;
-        }
+            // find blocks that would be deleted but are referenced by another record
+            let duplicate_record_cids = self
+                .get_duplicate_record_cids(commit.removed_cids.to_list(), delete_and_update_uris)
+                .await?;
+            for cid in duplicate_record_cids {
+                commit.removed_cids.delete(cid)
+            }
 
-        // If DID mapping provided, remove that too
-        if let Some(did_str) = did {
-            let did_path = reserved_dir.join(did_str);
-            if did_path.exists() {
-                fs::remove_file(did_path).await?;
+            // find blocks that are relevant to ops but not included in diff
+            // (for instance a record that was moved but cid stayed the same)
+            let new_record_blocks = commit.relevant_blocks.get_many(new_record_cids)?;
+            if !new_record_blocks.missing.is_empty() {
+                let missing_blocks = {
+                    let storage_guard = self.storage.read().await;
+                    storage_guard.get_blocks(new_record_blocks.missing).await?
+                };
+                commit.relevant_blocks.add_map(missing_blocks.blocks)?;
             }
+            let commit_with_data_ops = CommitDataWithOps {
+                ops: commit_ops,
+                commit_data: commit,
+                prev_data: Some(previous_data),
+            };
+            Ok(commit_with_data_ops)
+        } else {
+            Err(FormatCommitError::MissingRepoRoot(self.did.clone()).into())
         }
-
-        Ok(())
     }
 
-    /// Store a PLC operation
-    pub(crate) async fn store_plc_op(&self, did: &str, op: &[u8]) -> Result<()> {
-        let location = self.get_location(did).await?;
-        let op_path = location.directory.join("did-op");
+    pub async fn index_writes(&self, writes: Vec<PreparedWrite>, rev: &str) -> Result<()> {
+        let now: &str = &rsky_common::now();
 
-        fs::write(op_path, op).await?;
+        let _ = stream::iter(writes)
+            .then(|write| async move {
+                Ok::<(), anyhow::Error>(match write {
+                    PreparedWrite::Create(write) => {
+                        let write_at_uri: AtUri = write.uri.try_into()?;
+                        self.record
+                            .index_record(
+                                write_at_uri.clone(),
+                                write.cid,
+                                Some(write.record),
+                                Some(write.action),
+                                rev.to_owned(),
+                                Some(now.to_string()),
+                            )
+                            .await?
+                    }
+                    PreparedWrite::Update(write) => {
+                        let write_at_uri: AtUri = write.uri.try_into()?;
+                        self.record
+                            .index_record(
+                                write_at_uri.clone(),
+                                write.cid,
+                                Some(write.record),
+                                Some(write.action),
+                                rev.to_owned(),
+                                Some(now.to_string()),
+                            )
+                            .await?
+                    }
+                    PreparedWrite::Delete(write) => {
+                        let write_at_uri: AtUri = write.uri.try_into()?;
+                        self.record.delete_record(&write_at_uri).await?
+                    }
+                })
+            })
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
         Ok(())
     }
 
-    /// Get a stored PLC operation
-    pub(crate) async fn get_plc_op(&self, did: &str) -> Result<Vec<u8>> {
-        let location = self.get_location(did).await?;
-        let op_path = location.directory.join("did-op");
-
-        let data = fs::read(op_path).await?;
-        Ok(data)
-    }
-
-    /// Clear a stored PLC operation
-    pub(crate) async fn clear_plc_op(&self, did: &str) -> Result<()> {
-        let location = self.get_location(did).await?;
-        let op_path = location.directory.join("did-op");
+    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();
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
-        if op_path.exists() {
-            fs::remove_file(op_path).await?;
-        }
-
+        let blob_rows: Vec<String> = db
+            .run(move |conn| {
+                BlobSchema::blob
+                    .filter(BlobSchema::did.eq(did))
+                    .select(BlobSchema::cid)
+                    .get_results(conn)
+            })
+            .await?;
+        let cids = blob_rows
+            .into_iter()
+            .map(|row| Ok(Cid::from_str(&row)?))
+            .collect::<Result<Vec<Cid>>>()?;
+        let _ = stream::iter(cids.chunks(500))
+            .then(|chunk| async { self.blob.blobstore.delete_many(chunk.to_vec()).await })
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
         Ok(())
     }
-}
 
-/// Ensure a path part is safe to use in a filename
-fn assert_safe_path_part(part: &str) -> Result<()> {
-    let normalized = std::path::Path::new(part)
-        .file_name()
-        .and_then(|s| s.to_str())
-        .ok_or_else(|| anyhow!("Invalid path"))?;
+    pub async fn get_duplicate_record_cids(
+        &self,
+        cids: Vec<Cid>,
+        touched_uris: Vec<AtUri>,
+    ) -> Result<Vec<Cid>> {
+        if touched_uris.is_empty() || cids.is_empty() {
+            return Ok(vec![]);
+        }
+        let did: String = self.did.clone();
+        let storage_guard = self.storage.read().await;
+        let db: Arc<ActorDb> = storage_guard.db.clone();
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-    if part != normalized || part.starts_with('.') || part.contains('/') || part.contains('\\') {
-        bail!("Unsafe path part: {}", part);
+        let cid_strs: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();
+        let touched_uri_strs: Vec<String> = touched_uris.iter().map(|t| t.to_string()).collect();
+        let res: Vec<String> = db
+            .run(move |conn| {
+                RecordSchema::record
+                    .filter(RecordSchema::did.eq(did))
+                    .filter(RecordSchema::cid.eq_any(cid_strs))
+                    .filter(RecordSchema::uri.ne_all(touched_uri_strs))
+                    .select(RecordSchema::cid)
+                    .get_results(conn)
+            })
+            .await?;
+        res.into_iter()
+            .map(|row| Cid::from_str(&row).map_err(|error| anyhow::Error::new(error)))
+            .collect::<Result<Vec<Cid>>>()
     }
-
-    Ok(())
 }

src/actor_store/actor_store_handler.rs

···
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use anyhow::{Context as _, Result, anyhow};
-use futures::TryStreamExt;
-use rsky_repo::repo::Repo;
-use rsky_repo::types::{CommitData, CommitDataWithOps, PreparedWrite as RskyPreparedWrite};
-
-use super::PreparedWrite;
-use super::blob::{BackgroundQueue, BlobStorePlaceholder};
-use super::db::ActorDb;
-use super::preference::PreferenceHandler;
-use super::record::RecordHandler;
-use super::repo::RepoHandler;
-use crate::SigningKey;
-
-/// Unified handler for actor store operations.
-pub(crate) struct ActorStoreHandler {
-    /// Actor DID
-    pub did: String,
-    /// Database connection
-    pub db: ActorDb,
-    /// Repository handler
-    pub repo: RepoHandler,
-    /// Record handler
-    pub record: RecordHandler,
-    /// Preference handler
-    pub pref: PreferenceHandler,
-    /// Background queue for async operations
-    pub background_queue: Option<BackgroundQueue>,
-    /// Signing keypair (required for write operations)
-    pub signing_key: Option<Arc<SigningKey>>,
-}
-
-impl ActorStoreHandler {
-    /// Create a new actor store handler with read-only capabilities
-    pub(crate) fn new_reader(db: ActorDb, did: String, blobstore: BlobStorePlaceholder) -> Self {
-        let record = RecordHandler::new(db.clone(), did.clone());
-        let pref = PreferenceHandler::new(db.clone(), did.clone());
-        let repo = RepoHandler::new_reader(db.clone(), blobstore, did.clone());
-
-        Self {
-            did,
-            db,
-            repo,
-            record,
-            pref,
-            background_queue: None,
-            signing_key: None,
-        }
-    }
-
-    /// Create a new actor store handler with read/write capabilities
-    pub(crate) fn new_writer(
-        db: ActorDb,
-        did: String,
-        blobstore: BlobStorePlaceholder,
-        signing_key: Arc<SigningKey>,
-        background_queue: BackgroundQueue,
-    ) -> Self {
-        let record = RecordHandler::new_with_blobstore(db.clone(), blobstore.clone(), did.clone());
-        let pref = PreferenceHandler::new(db.clone(), did.clone());
-        let repo = RepoHandler::new_writer(
-            db.clone(),
-            blobstore,
-            did.clone(),
-            signing_key.clone(),
-            background_queue.clone(),
-        );
-
-        Self {
-            did,
-            db,
-            repo,
-            record,
-            pref,
-            background_queue: Some(background_queue),
-            signing_key: Some(signing_key),
-        }
-    }
-
-    /// Set signing key (needed for write operations)
-    pub(crate) fn with_signing_key(mut self, signing_key: Arc<SigningKey>) -> Self {
-        self.signing_key = Some(signing_key);
-        self
-    }
-
-    /// Set background queue (needed for async operations)
-    pub(crate) fn with_background_queue(mut self, queue: BackgroundQueue) -> Self {
-        self.background_queue = Some(queue);
-        self
-    }
-
-    // Repository Operations
-    // --------------------
-
-    /// Try to load repository
-    pub(crate) async fn maybe_load_repo(&self) -> Result<Option<Repo>> {
-        self.repo.maybe_load_repo().await
-    }
-
-    /// Get repository root CID
-    pub(crate) async fn get_repo_root(&self) -> Result<Option<atrium_repo::Cid>> {
-        self.repo.get_repo_root().await
-    }
-
-    /// Create a new repository with prepared writes
-    pub(crate) async fn create_repo(
-        &self,
-        writes: Vec<PreparedWrite>,
-    ) -> Result<CommitDataWithOps> {
-        if self.signing_key.is_none() {
-            return Err(anyhow!(
-                "No signing key available for create_repo operation"
-            ));
-        }
-
-        let rsky_writes = writes
-            .into_iter()
-            .map(|w| RskyPreparedWrite::from(w))
-            .collect::<Vec<_>>();
-
-        self.repo.create_repo(rsky_writes).await
-    }
-
-    /// Process writes to the repository
-    pub(crate) async fn process_writes(
-        &self,
-        writes: Vec<PreparedWrite>,
-        swap_commit_cid: Option<atrium_repo::Cid>,
-    ) -> Result<CommitDataWithOps> {
-        if self.signing_key.is_none() {
-            return Err(anyhow!(
-                "No signing key available for process_writes operation"
-            ));
-        }
-
-        let rsky_writes = writes
-            .into_iter()
-            .map(|w| RskyPreparedWrite::from(w))
-            .collect::<Vec<_>>();
-
-        self.repo.process_writes(rsky_writes, swap_commit_cid).await
-    }
-
-    /// Import a repository from external data
-    pub(crate) async fn process_import_repo(
-        &self,
-        commit: CommitData,
-        writes: Vec<PreparedWrite>,
-    ) -> Result<()> {
-        let rsky_writes = writes
-            .into_iter()
-            .map(|w| RskyPreparedWrite::from(w))
-            .collect::<Vec<_>>();
-
-        // First index the records
-        self.repo.index_writes(&rsky_writes, &commit.rev).await?;
-
-        // Then process the commit
-        self.repo.storage.apply_commit(commit.clone(), None).await?;
-
-        // Finally process any blobs
-        if let Some(bg_queue) = &self.background_queue {
-            self.repo
-                .blob_transactor
-                .process_write_blobs(&commit.rev, rsky_writes)
-                .await?;
-        } else {
-            return Err(anyhow!(
-                "Background queue required for process_import_repo operation"
-            ));
-        }
-
-        Ok(())
-    }
-
-    /// Get sync event data for replication
-    pub(crate) async fn get_sync_event_data(&self) -> Result<super::repo::SyncEventData> {
-        self.repo.get_sync_event_data().await
-    }
-
-    /// Destroy the repository and all associated data
-    pub(crate) async fn destroy(&self) -> Result<()> {
-        // Get all blob CIDs
-        let blob_cids = self.repo.blob.get_blob_cids().await?;
-
-        // Delete all blobs
-        if !blob_cids.is_empty() {
-            self.repo
-                .blob_transactor
-                .blobstore
-                .delete_many(blob_cids.clone())
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    // Record Operations
-    // ----------------
-
-    /// Get a specific record
-    pub(crate) async fn get_record(
-        &self,
-        uri: &rsky_syntax::aturi::AtUri,
-        cid: Option<&str>,
-        include_soft_deleted: bool,
-    ) -> Result<Option<super::record::RecordData>> {
-        self.record.get_record(uri, cid, include_soft_deleted).await
-    }
-
-    /// List collections in the repository
-    pub(crate) async fn list_collections(&self) -> Result<Vec<String>> {
-        self.record.list_collections().await
-    }
-
-    /// List records in a collection
-    pub(crate) async fn list_records_for_collection(
-        &self,
-        opts: super::record::ListRecordsOptions,
-    ) -> Result<Vec<super::record::RecordData>> {
-        self.record.list_records_for_collection(opts).await
-    }
-
-    /// Get record count
-    pub(crate) async fn record_count(&self) -> Result<i64> {
-        self.record.record_count().await
-    }
-
-    /// Update record takedown status
-    pub(crate) async fn update_record_takedown_status(
-        &self,
-        uri: &rsky_syntax::aturi::AtUri,
-        takedown: atrium_api::com::atproto::admin::defs::StatusAttr,
-    ) -> Result<()> {
-        self.record
-            .update_record_takedown_status(uri, takedown)
-            .await
-    }
-
-    // Preference Operations
-    // -------------------
-
-    /// Get preferences for a namespace
-    pub(crate) async fn get_preferences(
-        &self,
-        namespace: Option<&str>,
-        scope: &str,
-    ) -> Result<Vec<super::preference::AccountPreference>> {
-        self.pref.get_preferences(namespace, scope).await
-    }
-
-    /// Put preferences for a namespace
-    pub(crate) async fn put_preferences(
-        &self,
-        values: Vec<super::preference::AccountPreference>,
-        namespace: &str,
-        scope: &str,
-    ) -> Result<()> {
-        self.pref.put_preferences(values, namespace, scope).await
-    }
-
-    // Blob Operations
-    // --------------
-
-    /// Get blob metadata
-    pub(crate) async fn get_blob_metadata(
-        &self,
-        cid: &atrium_repo::Cid,
-    ) -> Result<super::blob::BlobMetadata> {
-        self.repo.blob.get_blob_metadata(cid).await
-    }
-
-    /// Get blob data
-    pub(crate) async fn get_blob(&self, cid: &atrium_repo::Cid) -> Result<super::blob::BlobData> {
-        self.repo.blob.get_blob(cid).await
-    }
-
-    /// Update blob takedown status
-    pub(crate) async fn update_blob_takedown_status(
-        &self,
-        cid: atrium_repo::Cid,
-        takedown: atrium_api::com::atproto::admin::defs::StatusAttr,
-    ) -> Result<()> {
-        self.repo
-            .blob
-            .update_blob_takedown_status(cid, takedown)
-            .await
-    }
-
-    /// Upload blob and get metadata
-    pub(crate) async fn upload_blob_and_get_metadata(
-        &self,
-        user_suggested_mime: &str,
-        blob_bytes: &[u8],
-    ) -> Result<super::blob::BlobMetadata> {
-        self.repo
-            .blob
-            .upload_blob_and_get_metadata(user_suggested_mime, blob_bytes)
-            .await
-    }
-
-    /// Count blobs
-    pub(crate) async fn blob_count(&self) -> Result<i64> {
-        self.repo.blob.blob_count().await
-    }
-
-    // Transaction Support
-    // -----------------
-
-    /// Execute a transaction
-    pub(crate) async fn transaction<T, F>(&self, f: F) -> Result<T>
-    where
-        F: FnOnce(&mut diesel::SqliteConnection) -> Result<T> + Send,
-        T: Send + 'static,
-    {
-        self.db.transaction(f).await
-    }
-
-    /// Execute a database operation with retries
-    pub(crate) async fn run<F, T>(&self, operation: F) -> Result<T>
-    where
-        F: FnOnce(&mut diesel::SqliteConnection) -> diesel::QueryResult<T> + Send,
-        T: Send + 'static,
-    {
-        self.db.run(operation).await
-    }
-}

src/actor_store/actor_store_resources.rs

···
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use super::blob::{BackgroundQueue, BlobStorePlaceholder};
-
-pub(crate) struct ActorStoreResources {
-    // Factory function to create blobstore instances
-    blobstore_factory: Arc<dyn Fn(String) -> BlobStorePlaceholder + Send + Sync>,
-    // Shared background queue
-    background_queue: Arc<BackgroundQueue>,
-    // Optional directory for reserved keys
-    reserved_key_dir: Option<PathBuf>,
-}
-
-impl ActorStoreResources {
-    // Simple constructor with minimal parameters
-    pub(crate) fn new(
-        blobstore_factory: impl Fn(String) -> BlobStorePlaceholder + Send + Sync + 'static,
-        concurrency: usize,
-    ) -> Self {
-        Self {
-            blobstore_factory: Arc::new(blobstore_factory),
-            background_queue: Arc::new(BackgroundQueue::new(concurrency)),
-            reserved_key_dir: None,
-        }
-    }
-
-    // Set reserved key directory
-    pub(crate) fn with_reserved_key_dir(mut self, dir: impl Into<PathBuf>) -> Self {
-        self.reserved_key_dir = Some(dir.into());
-        self
-    }
-
-    // Get a blobstore for a DID
-    pub(crate) fn blobstore(&self, did: String) -> BlobStorePlaceholder {
-        (self.blobstore_factory)(did)
-    }
-
-    // Get the background queue
-    pub(crate) fn background_queue(&self) -> Arc<BackgroundQueue> {
-        self.background_queue.clone()
-    }
-
-    // Get the reserved key directory
-    pub(crate) fn reserved_key_dir(&self) -> Option<&PathBuf> {
-        self.reserved_key_dir.as_ref()
-    }
-}

src/actor_store/blob.rs

···
+//! Blob storage and retrieval for the actor store.
+//! Based on https://github.com/blacksky-algorithms/rsky/blob/main/rsky-pds/src/actor_store/blob/mod.rs
+//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
+//!
+//! Modified for SQLite backend
+
+use anyhow::{Result, bail};
+use cidv10::Cid;
+use diesel::dsl::{count_distinct, exists, not};
+use diesel::result::Error;
+use diesel::sql_types::{Integer, Nullable, Text};
+use diesel::*;
+use futures::stream::{self, StreamExt};
+use futures::try_join;
+use rsky_pds::actor_store::blob::sha256_stream;
+// use rocket::data::{Data, ToByteUnit};
+// use rocket::form::validate::Contains;
+use rsky_common::ipld::sha256_raw_to_cid;
+use rsky_common::now;
+use rsky_lexicon::blob_refs::BlobRef;
+use rsky_lexicon::com::atproto::admin::StatusAttr;
+use rsky_lexicon::com::atproto::repo::ListMissingBlobsRefRecordBlob;
+use rsky_pds::actor_store::blob::{
+    BlobMetadata, GetBlobMetadataOutput, GetBlobOutput, ListBlobsOpts, ListMissingBlobsOpts,
+    verify_blob,
+};
+use rsky_pds::image;
+use rsky_pds::models::models;
+use rsky_repo::error::BlobError;
+use rsky_repo::types::{PreparedBlobRef, PreparedWrite};
+use sha2::{Digest, Sha256};
+
+use super::ActorDb;
+use super::sql_blob::BlobStoreSql;
+
+pub struct BlobReader {
+    pub blobstore: BlobStoreSql,
+    pub did: String,
+    pub db: ActorDb,
+}
+
+// Basically handles getting blob records from db
+impl BlobReader {
+    pub fn new(blobstore: BlobStoreSql, db: ActorDb) -> Self {
+        BlobReader {
+            did: blobstore.bucket.clone(),
+            blobstore,
+            db,
+        }
+    }
+
+    pub async fn get_blob_metadata(&self, cid: Cid) -> Result<GetBlobMetadataOutput> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        let did = self.did.clone();
+        let found = self
+            .db
+            .run(move |conn| {
+                BlobSchema::blob
+                    .filter(BlobSchema::did.eq(did))
+                    .filter(BlobSchema::cid.eq(cid.to_string()))
+                    .filter(BlobSchema::takedownRef.is_null())
+                    .select(models::Blob::as_select())
+                    .first(conn)
+                    .optional()
+            })
+            .await?;
+
+        match found {
+            None => bail!("Blob not found"),
+            Some(found) => Ok(GetBlobMetadataOutput {
+                size: found.size,
+                mime_type: Some(found.mime_type),
+            }),
+        }
+    }
+
+    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,
+        })
+    }
+
+    pub async fn get_records_for_blob(&self, cid: Cid) -> Result<Vec<String>> {
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+
+        let did = self.did.clone();
+        let res = self
+            .db
+            .run(move |conn| {
+                let results = RecordBlobSchema::record_blob
+                    .filter(RecordBlobSchema::blobCid.eq(cid.to_string()))
+                    .filter(RecordBlobSchema::did.eq(did))
+                    .select(models::RecordBlob::as_select())
+                    .get_results(conn)?;
+                Ok::<_, Error>(results.into_iter().map(|row| row.record_uri))
+            })
+            .await?
+            .collect::<Vec<String>>();
+
+        Ok(res)
+    }
+
+    pub async fn upload_blob_and_get_metadata(
+        &self,
+        user_suggested_mime: String,
+        blob: Data<'_>,
+    ) -> Result<BlobMetadata> {
+        let blob_stream = blob.open(100.mebibytes());
+        let bytes = blob_stream.into_bytes().await?;
+        let size = bytes.n.written;
+        let bytes = bytes.into_inner();
+        let (temp_key, sha256, img_info, sniffed_mime) = try_join!(
+            self.blobstore.put_temp(bytes.clone()),
+            sha256_stream(bytes.clone()),
+            image::maybe_get_info(bytes.clone()),
+            image::mime_type_from_bytes(bytes.clone())
+        )?;
+
+        let cid = sha256_raw_to_cid(sha256);
+        let mime_type = sniffed_mime.unwrap_or(user_suggested_mime);
+
+        Ok(BlobMetadata {
+            temp_key,
+            size: size as i64,
+            cid,
+            mime_type,
+            width: if let Some(ref info) = img_info {
+                Some(info.width as i32)
+            } else {
+                None
+            },
+            height: if let Some(info) = img_info {
+                Some(info.height as i32)
+            } else {
+                None
+            },
+        })
+    }
+
+    pub async fn track_untethered_blob(&self, metadata: BlobMetadata) -> Result<BlobRef> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        let did = self.did.clone();
+        self.db.run(move |conn| {
+            let BlobMetadata {
+                temp_key,
+                size,
+                cid,
+                mime_type,
+                width,
+                height,
+            } = metadata;
+            let created_at = now();
+
+            let found = BlobSchema::blob
+                .filter(BlobSchema::did.eq(&did))
+                .filter(BlobSchema::cid.eq(&cid.to_string()))
+                .select(models::Blob::as_select())
+                .first(conn)
+                .optional()?;
+
+            if let Some(found) = found {
+                if found.takedown_ref.is_some() {
+                    bail!("Blob has been takendown, cannot re-upload")
+                }
+            }
+
+            let upsert = sql_query("INSERT INTO pds.blob (cid, did, \"mimeType\", size, \"tempKey\", width, height, \"createdAt\", \"takedownRef\") \
+        VALUES \
+            ($1, $2, $3, $4, $5, $6, $7, $8, $9) \
+        ON CONFLICT (cid, did) DO UPDATE \
+        SET \"tempKey\" = EXCLUDED.\"tempKey\" \
+            WHERE pds.blob.\"tempKey\" is not null;");
+            upsert
+                .bind::<Text, _>(&cid.to_string())
+                .bind::<Text, _>(&did)
+                .bind::<Text, _>(&mime_type)
+                .bind::<Integer, _>(size as i32)
+                .bind::<Nullable<Text>, _>(Some(temp_key.clone()))
+                .bind::<Nullable<Integer>, _>(width)
+                .bind::<Nullable<Integer>, _>(height)
+                .bind::<Text, _>(created_at)
+                .bind::<Nullable<Text>, _>(None as Option<String>)
+                .execute(conn)?;
+
+            Ok(BlobRef::new(cid, mime_type, size, None))
+        }).await
+    }
+
+    pub async fn process_write_blobs(&self, writes: Vec<PreparedWrite>) -> Result<()> {
+        self.delete_dereferenced_blobs(writes.clone()).await?;
+        let _ = stream::iter(writes)
+            .then(|write| async move {
+                Ok::<(), anyhow::Error>(match write {
+                    PreparedWrite::Create(w) => {
+                        for blob in w.blobs {
+                            self.verify_blob_and_make_permanent(blob.clone()).await?;
+                            self.associate_blob(blob, w.uri.clone()).await?;
+                        }
+                    }
+                    PreparedWrite::Update(w) => {
+                        for blob in w.blobs {
+                            self.verify_blob_and_make_permanent(blob.clone()).await?;
+                            self.associate_blob(blob, w.uri.clone()).await?;
+                        }
+                    }
+                    _ => (),
+                })
+            })
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(())
+    }
+
+    pub async fn delete_dereferenced_blobs(&self, writes: Vec<PreparedWrite>) -> Result<()> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+
+        let uris: Vec<String> = writes
+            .clone()
+            .into_iter()
+            .filter_map(|w| match w {
+                PreparedWrite::Delete(w) => Some(w.uri),
+                PreparedWrite::Update(w) => Some(w.uri),
+                _ => None,
+            })
+            .collect();
+        if uris.is_empty() {
+            return Ok(());
+        }
+
+        let deleted_repo_blobs: Vec<models::RecordBlob> = self
+            .db
+            .run(move |conn| {
+                delete(RecordBlobSchema::record_blob)
+                    .filter(RecordBlobSchema::recordUri.eq_any(uris))
+                    .get_results(conn)
+            })
+            .await?
+            .into_iter()
+            .collect::<Vec<models::RecordBlob>>();
+        if deleted_repo_blobs.is_empty() {
+            return Ok(());
+        }
+
+        let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs
+            .into_iter()
+            .map(|row| row.blob_cid)
+            .collect::<Vec<String>>();
+
+        let x = deleted_repo_blob_cids.clone();
+        let mut duplicated_cids: Vec<String> = self
+            .db
+            .run(move |conn| {
+                RecordBlobSchema::record_blob
+                    .select(RecordBlobSchema::blobCid)
+                    .filter(RecordBlobSchema::blobCid.eq_any(&x))
+                    .load(conn)
+            })
+            .await?
+            .into_iter()
+            .collect::<Vec<String>>();
+
+        let mut new_blob_cids: Vec<String> = writes
+            .into_iter()
+            .map(|w| match w {
+                PreparedWrite::Create(w) => w.blobs,
+                PreparedWrite::Update(w) => w.blobs,
+                PreparedWrite::Delete(_) => Vec::new(),
+            })
+            .collect::<Vec<Vec<PreparedBlobRef>>>()
+            .into_iter()
+            .flat_map(|v: Vec<PreparedBlobRef>| v.into_iter().map(|b| b.cid.to_string()))
+            .collect();
+        let mut cids_to_keep = Vec::new();
+        cids_to_keep.append(&mut new_blob_cids);
+        cids_to_keep.append(&mut duplicated_cids);
+
+        let cids_to_delete = deleted_repo_blob_cids
+            .into_iter()
+            .filter_map(|cid: String| match cids_to_keep.contains(&cid) {
+                true => Some(cid),
+                false => None,
+            })
+            .collect::<Vec<String>>();
+        if cids_to_delete.is_empty() {
+            return Ok(());
+        }
+
+        let y = cids_to_delete.clone();
+        self.db
+            .run(move |conn| {
+                delete(BlobSchema::blob)
+                    .filter(BlobSchema::cid.eq_any(&y))
+                    .execute(conn)
+            })
+            .await?;
+
+        // Original code queues a background job to delete by CID from S3 compatible blobstore
+        let _ = stream::iter(cids_to_delete)
+            .then(|cid| async { self.blobstore.delete(cid).await })
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(())
+    }
+
+    pub async fn verify_blob_and_make_permanent(&self, blob: PreparedBlobRef) -> Result<()> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        let found = self
+            .db
+            .run(move |conn| {
+                BlobSchema::blob
+                    .filter(
+                        BlobSchema::cid
+                            .eq(blob.cid.to_string())
+                            .and(BlobSchema::takedownRef.is_null()),
+                    )
+                    .select(models::Blob::as_select())
+                    .first(conn)
+                    .optional()
+            })
+            .await?;
+        if let Some(found) = found {
+            verify_blob(&blob, &found).await?;
+            if let Some(ref temp_key) = found.temp_key {
+                self.blobstore
+                    .make_permanent(temp_key.clone(), blob.cid)
+                    .await?;
+            }
+            self.db
+                .run(move |conn| {
+                    update(BlobSchema::blob)
+                        .filter(BlobSchema::tempKey.eq(found.temp_key))
+                        .set(BlobSchema::tempKey.eq::<Option<String>>(None))
+                        .execute(conn)
+                })
+                .await?;
+            Ok(())
+        } else {
+            bail!("Cound not find blob: {:?}", blob.cid.to_string())
+        }
+    }
+
+    pub async fn associate_blob(&self, blob: PreparedBlobRef, _record_uri: String) -> Result<()> {
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+
+        let cid = blob.cid.to_string();
+        let record_uri = _record_uri;
+        let did = self.did.clone();
+        self.db
+            .run(move |conn| {
+                insert_into(RecordBlobSchema::record_blob)
+                    .values((
+                        RecordBlobSchema::blobCid.eq(cid),
+                        RecordBlobSchema::recordUri.eq(record_uri),
+                        RecordBlobSchema::did.eq(&did),
+                    ))
+                    .on_conflict_do_nothing()
+                    .execute(conn)
+            })
+            .await?;
+        Ok(())
+    }
+
+    pub async fn blob_count(&self) -> Result<i64> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        let did = self.did.clone();
+        self.db
+            .run(move |conn| {
+                let res = BlobSchema::blob
+                    .filter(BlobSchema::did.eq(&did))
+                    .count()
+                    .get_result(conn)?;
+                Ok(res)
+            })
+            .await
+    }
+
+    pub async fn record_blob_count(&self) -> Result<i64> {
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+
+        let did = self.did.clone();
+        self.db
+            .run(move |conn| {
+                let res: i64 = RecordBlobSchema::record_blob
+                    .filter(RecordBlobSchema::did.eq(&did))
+                    .select(count_distinct(RecordBlobSchema::blobCid))
+                    .get_result(conn)?;
+                Ok(res)
+            })
+            .await
+    }
+
+    pub async fn list_missing_blobs(
+        &self,
+        opts: ListMissingBlobsOpts,
+    ) -> Result<Vec<ListMissingBlobsRefRecordBlob>> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+
+        let did = self.did.clone();
+        self.db
+            .run(move |conn| {
+                let ListMissingBlobsOpts { cursor, limit } = opts;
+
+                if limit > 1000 {
+                    bail!("Limit too high. Max: 1000.");
+                }
+
+                let res: Vec<models::RecordBlob> = if let Some(cursor) = cursor {
+                    RecordBlobSchema::record_blob
+                        .limit(limit as i64)
+                        .filter(not(exists(
+                            BlobSchema::blob
+                                .filter(BlobSchema::cid.eq(RecordBlobSchema::blobCid))
+                                .filter(BlobSchema::did.eq(&did))
+                                .select(models::Blob::as_select()),
+                        )))
+                        .filter(RecordBlobSchema::blobCid.gt(cursor))
+                        .filter(RecordBlobSchema::did.eq(&did))
+                        .select(models::RecordBlob::as_select())
+                        .order(RecordBlobSchema::blobCid.asc())
+                        .distinct_on(RecordBlobSchema::blobCid)
+                        .get_results(conn)?
+                } else {
+                    RecordBlobSchema::record_blob
+                        .limit(limit as i64)
+                        .filter(not(exists(
+                            BlobSchema::blob
+                                .filter(BlobSchema::cid.eq(RecordBlobSchema::blobCid))
+                                .filter(BlobSchema::did.eq(&did))
+                                .select(models::Blob::as_select()),
+                        )))
+                        .filter(RecordBlobSchema::did.eq(&did))
+                        .select(models::RecordBlob::as_select())
+                        .order(RecordBlobSchema::blobCid.asc())
+                        .distinct_on(RecordBlobSchema::blobCid)
+                        .get_results(conn)?
+                };
+
+                Ok(res
+                    .into_iter()
+                    .map(|row| ListMissingBlobsRefRecordBlob {
+                        cid: row.blob_cid,
+                        record_uri: row.record_uri,
+                    })
+                    .collect())
+            })
+            .await
+    }
+
+    pub async fn list_blobs(&self, opts: ListBlobsOpts) -> Result<Vec<String>> {
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
+        use rsky_pds::schema::pds::record_blob::dsl as RecordBlobSchema;
+        let ListBlobsOpts {
+            since,
+            cursor,
+            limit,
+        } = opts;
+
+        let res: Vec<String> = if let Some(since) = since {
+            let mut builder = RecordBlobSchema::record_blob
+                .inner_join(
+                    RecordSchema::record.on(RecordSchema::uri.eq(RecordBlobSchema::recordUri)),
+                )
+                .filter(RecordSchema::repoRev.gt(since))
+                .select(RecordBlobSchema::blobCid)
+                .distinct()
+                .order(RecordBlobSchema::blobCid.asc())
+                .limit(limit as i64)
+                .into_boxed();
+
+            if let Some(cursor) = cursor {
+                builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor));
+            }
+            self.db.run(move |conn| builder.load(conn)).await?
+        } else {
+            let mut builder = RecordBlobSchema::record_blob
+                .select(RecordBlobSchema::blobCid)
+                .distinct()
+                .order(RecordBlobSchema::blobCid.asc())
+                .limit(limit as i64)
+                .into_boxed();
+
+            if let Some(cursor) = cursor {
+                builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor));
+            }
+            self.db.run(move |conn| builder.load(conn)).await?
+        };
+        Ok(res)
+    }
+
+    pub async fn get_blob_takedown_status(&self, cid: Cid) -> Result<Option<StatusAttr>> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        self.db
+            .run(move |conn| {
+                let res = BlobSchema::blob
+                    .filter(BlobSchema::cid.eq(cid.to_string()))
+                    .select(models::Blob::as_select())
+                    .first(conn)
+                    .optional()?;
+                match res {
+                    None => Ok(None),
+                    Some(res) => match res.takedown_ref {
+                        None => Ok(Some(StatusAttr {
+                            applied: false,
+                            r#ref: None,
+                        })),
+                        Some(takedown_ref) => Ok(Some(StatusAttr {
+                            applied: true,
+                            r#ref: Some(takedown_ref),
+                        })),
+                    },
+                }
+            })
+            .await
+    }
+
+    // Transactors
+    // -------------------
+
+    pub async fn update_blob_takedown_status(&self, blob: Cid, takedown: StatusAttr) -> Result<()> {
+        use rsky_pds::schema::pds::blob::dsl as BlobSchema;
+
+        let takedown_ref: Option<String> = match takedown.applied {
+            true => match takedown.r#ref {
+                Some(takedown_ref) => Some(takedown_ref),
+                None => Some(now()),
+            },
+            false => None,
+        };
+
+        let blob = self
+            .db
+            .run(move |conn| {
+                update(BlobSchema::blob)
+                    .filter(BlobSchema::cid.eq(blob.to_string()))
+                    .set(BlobSchema::takedownRef.eq(takedown_ref))
+                    .execute(conn)?;
+                Ok::<_, Error>(blob)
+            })
+            .await?;
+
+        let res = match takedown.applied {
+            true => self.blobstore.quarantine(blob).await,
+            false => self.blobstore.unquarantine(blob).await,
+        };
+        match res {
+            Ok(_) => Ok(()),
+            Err(e) => match e.downcast_ref() {
+                Some(BlobError::BlobNotFoundError) => Ok(()),
+                None => Err(e),
+            },
+        }
+    }
+}

src/actor_store/blob/background.rs

···
-use std::future::Future;
-use std::sync::Arc;
-use tokio::sync::{Mutex, Semaphore};
-use tokio::task::{self, JoinHandle};
-use tracing::error;
-
-/// Background Queue for asynchronous processing tasks
-///
-/// A simple queue for in-process, out-of-band/backgrounded work
-#[derive(Clone)]
-pub struct BackgroundQueue {
-    semaphore: Arc<Semaphore>,
-    tasks: Arc<Mutex<Vec<JoinHandle<()>>>>,
-    destroyed: Arc<Mutex<bool>>,
-}
-
-impl BackgroundQueue {
-    /// Create a new BackgroundQueue with the specified concurrency limit
-    pub fn new(concurrency: usize) -> Self {
-        Self {
-            semaphore: Arc::new(Semaphore::new(concurrency)),
-            tasks: Arc::new(Mutex::new(Vec::new())),
-            destroyed: Arc::new(Mutex::new(false)),
-        }
-    }
-
-    /// Add a task to the queue
-    pub async fn add<F>(&self, future: F)
-    where
-        F: Future<Output = ()> + Send + 'static,
-    {
-        let destroyed = *self.destroyed.lock().await;
-        if destroyed {
-            return;
-        }
-
-        let permit = match self.semaphore.clone().acquire_owned().await {
-            Ok(p) => p,
-            Err(_) => {
-                error!("Failed to acquire semaphore permit for background task");
-                return;
-            }
-        };
-
-        let tasks = self.tasks.clone();
-
-        let handle = task::spawn(async move {
-            future.await;
-
-            // Catch any panics to prevent task failures from propagating
-            if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {})) {
-                error!("Background queue task panicked: {:?}", e);
-            }
-
-            // Release the semaphore permit
-            drop(permit);
-        });
-
-        // Store the handle for later cleanup
-        tasks.lock().await.push(handle);
-    }
-
-    /// Wait for all tasks to finish
-    pub async fn process_all(&self) {
-        let mut handles = self.tasks.lock().await;
-        while let Some(handle) = handles.pop() {
-            let _ = handle.await;
-        }
-    }
-
-    /// Stop accepting new tasks, wait for all to finish
-    pub async fn destroy(&self) {
-        *self.destroyed.lock().await = true;
-        self.process_all().await;
-    }
-}

src/actor_store/blob/mod.rs

···
-// bluepds/src/actor_store/blob/mod.rs
-
-//! Blob storage and retrieval for the actor store.
-
-use std::str::FromStr;
-
-use anyhow::{Context as _, Result, bail};
-use atrium_api::com::atproto::admin::defs::StatusAttr;
-use atrium_repo::Cid;
-use diesel::associations::HasTable as _;
-use diesel::prelude::*;
-use futures::{StreamExt, future::try_join_all};
-use rsky_common::ipld::sha256_raw_to_cid;
-use rsky_pds::actor_store::blob::sha256_stream;
-use rsky_pds::image::{maybe_get_info, mime_type_from_bytes};
-use rsky_pds::schema::pds::*;
-use rsky_repo::types::{PreparedBlobRef, PreparedWrite, WriteOpAction};
-use sha2::Digest;
-use uuid::Uuid;
-
-use crate::actor_store::PreparedWrite as BluePreparedWrite;
-use crate::actor_store::db::ActorDb;
-
-/// Background task queue for blob operations
-pub mod background;
-// Re-export BackgroundQueue
-pub use background::BackgroundQueue;
-
-pub mod placeholder;
-pub(crate) use placeholder::BlobStorePlaceholder;
-
-/// Type for stream of blob data
-pub type BlobStream = Box<dyn std::io::Read + Send>;
-
-/// Blob store interface
-pub trait BlobStore: Send + Sync {
-    async fn put_temp(&self, bytes: &[u8]) -> Result<String>;
-    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()>;
-    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()>;
-    async fn quarantine(&self, cid: Cid) -> Result<()>;
-    async fn unquarantine(&self, cid: Cid) -> Result<()>;
-    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>>;
-    async fn get_stream(&self, cid: Cid) -> Result<BlobStream>;
-    async fn has_temp(&self, key: &str) -> Result<bool>;
-    async fn has_stored(&self, cid: Cid) -> Result<bool>;
-    async fn delete(&self, cid: Cid) -> Result<()>;
-    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()>;
-}
-
-/// Blob metadata for upload
-pub struct BlobMetadata {
-    pub temp_key: String,
-    pub size: i64,
-    pub cid: Cid,
-    pub mime_type: String,
-    pub width: Option<i32>,
-    pub height: Option<i32>,
-}
-
-/// Blob data with content stream
-pub struct BlobData {
-    pub size: u64,
-    pub mime_type: Option<String>,
-    pub stream: BlobStream,
-}
-
-/// Options for listing blobs
-pub struct ListBlobsOptions {
-    pub since: Option<String>,
-    pub cursor: Option<String>,
-    pub limit: i64,
-}
-
-/// Options for listing missing blobs
-pub struct ListMissingBlobsOptions {
-    pub cursor: Option<String>,
-    pub limit: i64,
-}
-
-/// Information about a missing blob
-pub struct MissingBlob {
-    pub cid: String,
-    pub record_uri: String,
-}
-
-/// Unified handler for blob operations
-pub struct BlobHandler {
-    /// Database connection
-    pub db: ActorDb,
-    /// DID of the actor
-    pub did: String,
-    /// Blob store implementation
-    pub blobstore: Box<dyn BlobStore>,
-    /// Background queue for async operations
-    pub background_queue: Option<background::BackgroundQueue>,
-}
-
-impl BlobHandler {
-    /// Create a new blob handler with background queue for write operations
-    pub fn new(
-        db: ActorDb,
-        blobstore: impl BlobStore + 'static,
-        background_queue: background::BackgroundQueue,
-        did: String,
-    ) -> Self {
-        Self {
-            db,
-            did,
-            blobstore: Box::new(blobstore),
-            background_queue: Some(background_queue),
-        }
-    }
-
-    /// Get metadata for a blob
-    pub async fn get_blob_metadata(&self, cid: &Cid) -> Result<BlobMetadata> {
-        let cid_str = cid.to_string();
-        let did = self.did.clone();
-
-        let found = self
-            .db
-            .run(move |conn| {
-                blob::table
-                    .filter(blob::cid.eq(&cid_str))
-                    .filter(blob::did.eq(&did))
-                    .filter(blob::takedownRef.is_null())
-                    .first::<BlobModel>(conn)
-                    .optional()
-            })
-            .await?;
-
-        match found {
-            Some(found) => Ok(BlobMetadata {
-                temp_key: found.temp_key.unwrap_or_default(),
-                size: found.size as i64,
-                cid: Cid::from_str(&found.cid)?,
-                mime_type: found.mime_type,
-                width: found.width,
-                height: found.height,
-            }),
-            None => bail!("Blob not found"),
-        }
-    }
-
-    /// Get a blob's complete data
-    pub async fn get_blob(&self, cid: &Cid) -> Result<BlobData> {
-        let metadata = self.get_blob_metadata(cid).await?;
-        let blob_stream = self.blobstore.get_stream(*cid).await?;
-
-        Ok(BlobData {
-            size: metadata.size as u64,
-            mime_type: Some(metadata.mime_type),
-            stream: blob_stream,
-        })
-    }
-
-    /// List blobs for a repository
-    pub async fn list_blobs(&self, opts: ListBlobsOptions) -> Result<Vec<String>> {
-        let did = self.did.clone();
-        let since = opts.since;
-        let cursor = opts.cursor;
-        let limit = opts.limit;
-
-        self.db
-            .run(move |conn| {
-                let mut query = record_blob::table
-                    .inner_join(
-                        crate::schema::record::table
-                            .on(crate::schema::record::uri.eq(record_blob::record_uri)),
-                    )
-                    .filter(record_blob::did.eq(&did))
-                    .select(record_blob::blob_cid)
-                    .distinct()
-                    .order(record_blob::blob_cid.asc())
-                    .limit(limit)
-                    .into_boxed();
-
-                if let Some(since_val) = since {
-                    query = query.filter(crate::schema::record::repo_rev.gt(since_val));
-                }
-
-                if let Some(cursor_val) = cursor {
-                    query = query.filter(record_blob::blob_cid.gt(cursor_val));
-                }
-
-                query.load::<String>(conn)
-            })
-            .await
-    }
-
-    /// Get records that reference a blob
-    pub async fn get_records_for_blob(&self, cid: &Cid) -> Result<Vec<String>> {
-        let cid_str = cid.to_string();
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                record_blob::table
-                    .filter(record_blob::blob_cid.eq(&cid_str))
-                    .filter(record_blob::did.eq(&did))
-                    .select(record_blob::record_uri)
-                    .load::<String>(conn)
-            })
-            .await
-    }
-
-    /// Get blobs referenced by a record
-    pub async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
-        let record_uri_str = record_uri.to_string();
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                blob::table
-                    .inner_join(record_blob::table.on(record_blob::blob_cid.eq(blob::cid)))
-                    .filter(record_blob::record_uri.eq(&record_uri_str))
-                    .filter(blob::did.eq(&did))
-                    .select(blob::cid)
-                    .load::<String>(conn)
-            })
-            .await
-    }
-
-    /// Upload a blob and get its metadata
-    pub async fn upload_blob_and_get_metadata(
-        &self,
-        user_suggested_mime: &str,
-        blob_bytes: &[u8],
-    ) -> Result<BlobMetadata> {
-        let temp_key = self.blobstore.put_temp(blob_bytes).await?;
-        let size = blob_bytes.len() as i64;
-        let sha256 = sha256_stream(blob_bytes).await?;
-        let img_info = maybe_get_info(blob_bytes).await?;
-        let sniffed_mime = mime_type_from_bytes(blob_bytes).await?;
-        let cid = sha256_raw_to_cid(sha256);
-        let mime_type = sniffed_mime.unwrap_or_else(|| user_suggested_mime.to_string());
-
-        Ok(BlobMetadata {
-            temp_key,
-            size,
-            cid,
-            mime_type,
-            width: img_info.as_ref().map(|info| info.width as i32),
-            height: img_info.as_ref().map(|info| info.height as i32),
-        })
-    }
-
-    /// Count total blobs
-    pub async fn blob_count(&self) -> Result<i64> {
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                blob::table
-                    .filter(blob::did.eq(&did))
-                    .count()
-                    .get_result(conn)
-            })
-            .await
-    }
-
-    /// Count distinct blobs referenced by records
-    pub async fn record_blob_count(&self) -> Result<i64> {
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                record_blob::table
-                    .filter(record_blob::did.eq(&did))
-                    .select(diesel::dsl::count_distinct(record_blob::blob_cid))
-                    .first::<i64>(conn)
-            })
-            .await
-    }
-
-    /// List blobs that are referenced but missing from storage
-    pub async fn list_missing_blobs(
-        &self,
-        opts: ListMissingBlobsOptions,
-    ) -> Result<Vec<MissingBlob>> {
-        let did = self.did.clone();
-        let limit = opts.limit;
-        let cursor = opts.cursor;
-
-        self.db
-            .run(move |conn| {
-                let mut query = record_blob::table
-                    .left_join(
-                        blob::table.on(blob::cid.eq(record_blob::blob_cid).and(blob::did.eq(&did))),
-                    )
-                    .filter(record_blob::did.eq(&did))
-                    .filter(blob::cid.is_null())
-                    .select((record_blob::blob_cid, record_blob::record_uri))
-                    .order(record_blob::blob_cid.asc())
-                    .limit(limit)
-                    .into_boxed();
-
-                if let Some(cursor_val) = cursor {
-                    query = query.filter(record_blob::blob_cid.gt(cursor_val));
-                }
-
-                let results = query.load::<(String, String)>(conn)?;
-
-                Ok(results
-                    .into_iter()
-                    .map(|(cid, record_uri)| MissingBlob { cid, record_uri })
-                    .collect())
-            })
-            .await
-    }
-
-    /// Get takedown status for a blob
-    pub async fn get_blob_takedown_status(&self, cid: &Cid) -> Result<Option<StatusAttr>> {
-        let cid_str = cid.to_string();
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                let result = blob::table
-                    .filter(blob::cid.eq(&cid_str))
-                    .filter(blob::did.eq(&did))
-                    .select(blob::takedownRef)
-                    .first::<Option<String>>(conn)
-                    .optional()?;
-
-                match result {
-                    Some(takedown) => match takedown {
-                        Some(takedownRef) => Ok(Some(StatusAttr {
-                            applied: true,
-                            r#ref: Some(takedownRef),
-                        })),
-                        None => Ok(Some(StatusAttr {
-                            applied: false,
-                            r#ref: None,
-                        })),
-                    },
-                    None => Ok(None),
-                }
-            })
-            .await
-    }
-
-    /// Get all blob CIDs in the repository
-    pub async fn get_blob_cids(&self) -> Result<Vec<Cid>> {
-        let did = self.did.clone();
-
-        let rows = self
-            .db
-            .run(move |conn| {
-                blob::table
-                    .filter(blob::did.eq(&did))
-                    .select(blob::cid)
-                    .load::<String>(conn)
-            })
-            .await?;
-
-        rows.into_iter()
-            .map(|cid_str| Cid::from_str(&cid_str).context("Invalid CID format"))
-            .collect()
-    }
-
-    /// Track a blob that's not yet associated with a record
-    pub async fn track_untethered_blob(&self, metadata: &BlobMetadata) -> Result<()> {
-        let cid_str = metadata.cid.to_string();
-        let did = self.did.clone();
-
-        // Check if blob exists and is taken down
-        let existing = self
-            .db
-            .run({
-                let cid_str_clone = cid_str.clone();
-                let did_clone = did.clone();
-
-                move |conn| {
-                    blob::table
-                        .filter(blob::did.eq(&did_clone))
-                        .filter(blob::cid.eq(&cid_str_clone))
-                        .select(blob::takedownRef)
-                        .first::<Option<String>>(conn)
-                        .optional()
-                }
-            })
-            .await?;
-
-        if let Some(row) = existing {
-            if row.is_some() {
-                return Err(anyhow::anyhow!(
-                    "Blob has been taken down, cannot re-upload"
-                ));
-            }
-        }
-
-        let size = metadata.size as i32;
-        let now = chrono::Utc::now().to_rfc3339();
-        let mime_type = metadata.mime_type.clone();
-        let temp_key = metadata.temp_key.clone();
-        let width = metadata.width;
-        let height = metadata.height;
-
-        self.db.run(move |conn| {
-            diesel::insert_into(blob::table)
-                .values((
-                    blob::cid.eq(&cid_str),
-                    blob::did.eq(&did),
-                    blob::mime_type.eq(&mime_type),
-                    blob::size.eq(size),
-                    blob::temp_key.eq(&temp_key),
-                    blob::width.eq(width),
-                    blob::height.eq(height),
-                    blob::created_at.eq(&now),
-                ))
-                .on_conflict((blob::cid, blob::did))
-                .do_update()
-                .set(
-                    blob::temp_key.eq(
-                        diesel::dsl::sql::<diesel::sql_types::Text>(
-                            "CASE WHEN blob.temp_key IS NULL THEN excluded.temp_key ELSE blob.temp_key END"
-                        )
-                    )
-                )
-                .execute(conn)
-                .context("Failed to track untethered blob")
-        }).await?;
-
-        Ok(())
-    }
-
-    /// Process blobs for repository writes
-    pub async fn process_write_blobs(&self, rev: &str, writes: Vec<PreparedWrite>) -> Result<()> {
-        self.delete_dereferenced_blobs(writes.clone()).await?;
-
-        let futures = writes.iter().filter_map(|write| match write {
-            PreparedWrite::Create(w) | PreparedWrite::Update(w) => {
-                let blobs = &w.blobs;
-                let uri = w.uri.clone();
-                let handler = self;
-
-                Some(async move {
-                    for blob in blobs {
-                        handler.verify_blob_and_make_permanent(blob).await?;
-                        handler.associate_blob(blob, &uri).await?;
-                    }
-                    Ok(())
-                })
-            }
-            _ => None,
-        });
-
-        try_join_all(futures).await?;
-
-        Ok(())
-    }
-
-    /// Delete blobs that are no longer referenced
-    pub async fn delete_dereferenced_blobs(&self, writes: Vec<PreparedWrite>) -> Result<()> {
-        let uris: Vec<String> = writes
-            .iter()
-            .filter_map(|w| match w {
-                PreparedWrite::Delete(w) => Some(w.uri.clone()),
-                PreparedWrite::Update(w) => Some(w.uri.clone()),
-                _ => None,
-            })
-            .collect();
-
-        if uris.is_empty() {
-            return Ok(());
-        }
-
-        let did = self.did.clone();
-
-        // Delete record-blob associations
-        let deleted_repo_blobs = self
-            .db
-            .run({
-                let uris_clone = uris.clone();
-                let did_clone = did.clone();
-
-                move |conn| {
-                    let query = diesel::delete(record_blob::table)
-                        .filter(record_blob::did.eq(&did_clone))
-                        .filter(record_blob::record_uri.eq_any(&uris_clone))
-                        .returning(RecordBlob::as_returning());
-
-                    query.load(conn)
-                }
-            })
-            .await?;
-
-        if deleted_repo_blobs.is_empty() {
-            return Ok(());
-        }
-
-        // Collect deleted blob CIDs
-        let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs
-            .iter()
-            .map(|rb| rb.blob_cid.clone())
-            .collect();
-
-        // Find duplicates in record_blob table
-        let duplicate_cids = self
-            .db
-            .run({
-                let blob_cids = deleted_repo_blob_cids.clone();
-                let did_clone = did.clone();
-
-                move |conn| {
-                    record_blob::table
-                        .filter(record_blob::did.eq(&did_clone))
-                        .filter(record_blob::blob_cid.eq_any(&blob_cids))
-                        .select(record_blob::blob_cid)
-                        .load::<String>(conn)
-                }
-            })
-            .await?;
-
-        // Get new blob CIDs from writes
-        let new_blob_cids: Vec<String> = writes
-            .iter()
-            .filter_map(|w| match w {
-                PreparedWrite::Create(w) | PreparedWrite::Update(w) => Some(
-                    w.blobs
-                        .iter()
-                        .map(|b| b.cid.to_string())
-                        .collect::<Vec<String>>(),
-                ),
-                _ => None,
-            })
-            .flatten()
-            .collect();
-
-        // Determine which CIDs to keep and which to delete
-        let cids_to_keep: std::collections::HashSet<String> = new_blob_cids
-            .into_iter()
-            .chain(duplicate_cids.into_iter())
-            .collect();
-
-        let cids_to_delete: Vec<String> = deleted_repo_blob_cids
-            .into_iter()
-            .filter(|cid| !cids_to_keep.contains(cid))
-            .collect();
-
-        if cids_to_delete.is_empty() {
-            return Ok(());
-        }
-
-        // Delete blobs from the database
-        self.db
-            .run({
-                let cids = cids_to_delete.clone();
-                let did_clone = did.clone();
-
-                move |conn| {
-                    diesel::delete(blob::table)
-                        .filter(blob::did.eq(&did_clone))
-                        .filter(blob::cid.eq_any(&cids))
-                        .execute(conn)
-                }
-            })
-            .await?;
-
-        // Delete blobs from storage
-        let cids_to_delete_objects: Vec<Cid> = cids_to_delete
-            .iter()
-            .filter_map(|cid_str| Cid::from_str(cid_str).ok())
-            .collect();
-
-        // Use background queue if available
-        if let Some(queue) = &self.background_queue {
-            let blobstore = self.blobstore.clone();
-            queue
-                .add(async move {
-                    let _ = blobstore.delete_many(cids_to_delete_objects).await;
-                })
-                .await;
-        } else {
-            // Otherwise delete directly
-            if !cids_to_delete_objects.is_empty() {
-                self.blobstore.delete_many(cids_to_delete_objects).await?;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Verify blob integrity and move from temporary to permanent storage
-    pub async fn verify_blob_and_make_permanent(&self, blob: &PreparedBlobRef) -> Result<()> {
-        let cid_str = blob.cid.to_string();
-        let did = self.did.clone();
-
-        let found = self
-            .db
-            .run(move |conn| {
-                blob::table
-                    .filter(blob::did.eq(&did))
-                    .filter(blob::cid.eq(&cid_str))
-                    .filter(blob::takedownRef.is_null())
-                    .first::<BlobModel>(conn)
-                    .optional()
-            })
-            .await?;
-
-        let found = match found {
-            Some(b) => b,
-            None => bail!("Blob not found: {}", cid_str),
-        };
-
-        // Verify blob constraints
-        if let Some(max_size) = blob.constraints.max_size {
-            if found.size as usize > max_size {
-                bail!(
-                    "BlobTooLarge: This file is too large. It is {} but the maximum size is {}",
-                    found.size,
-                    max_size
-                );
-            }
-        }
-
-        if blob.mime_type != found.mime_type {
-            bail!(
-                "InvalidMimeType: Referenced MIME type does not match stored blob. Expected: {}, Got: {}",
-                found.mime_type,
-                blob.mime_type
-            );
-        }
-
-        if let Some(ref accept) = blob.constraints.accept {
-            if !accepted_mime(&blob.mime_type, accept).await {
-                bail!(
-                    "Wrong type of file. It is {} but it must match {:?}.",
-                    blob.mime_type,
-                    accept
-                );
-            }
-        }
-
-        // Move blob from temporary to permanent storage if needed
-        if let Some(temp_key) = found.temp_key {
-            self.blobstore.make_permanent(&temp_key, blob.cid).await?;
-
-            // Update database to clear temp key
-            let cid_str = blob.cid.to_string();
-            let did = self.did.clone();
-
-            self.db
-                .run(move |conn| {
-                    diesel::update(blob::table)
-                        .filter(blob::did.eq(&did))
-                        .filter(blob::cid.eq(&cid_str))
-                        .set(blob::temp_key.eq::<Option<String>>(None))
-                        .execute(conn)
-                })
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    /// Associate a blob with a record
-    pub async fn associate_blob(&self, blob: &PreparedBlobRef, record_uri: &str) -> Result<()> {
-        let cid_str = blob.cid.to_string();
-        let record_uri = record_uri.to_string();
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                diesel::insert_into(record_blob::table)
-                    .values((
-                        record_blob::blob_cid.eq(&cid_str),
-                        record_blob::record_uri.eq(&record_uri),
-                        record_blob::did.eq(&did),
-                    ))
-                    .on_conflict_do_nothing()
-                    .execute(conn)
-            })
-            .await?;
-
-        Ok(())
-    }
-
-    /// Update takedown status for a blob
-    pub async fn update_blob_takedown_status(&self, blob: Cid, takedown: StatusAttr) -> Result<()> {
-        let cid_str = blob.to_string();
-        let did = self.did.clone();
-
-        let takedownRef: Option<String> = if takedown.applied {
-            Some(takedown.r#ref.unwrap_or_else(|| Uuid::new_v4().to_string()))
-        } else {
-            None
-        };
-
-        // Update database
-        self.db
-            .run(move |conn| {
-                diesel::update(blob::table)
-                    .filter(blob::did.eq(&did))
-                    .filter(blob::cid.eq(&cid_str))
-                    .set(blob::takedownRef.eq(takedownRef))
-                    .execute(conn)
-            })
-            .await?;
-
-        // Update blob storage
-        if takedown.applied {
-            self.blobstore.quarantine(blob).await?;
-        } else {
-            self.blobstore.unquarantine(blob).await?;
-        }
-
-        Ok(())
-    }
-}
-
-/// Verify MIME type against accepted formats
-async fn accepted_mime(mime: &str, accepted: &[String]) -> bool {
-    // Accept any type
-    if accepted.contains(&"*/*".to_string()) {
-        return true;
-    }
-
-    // Check for glob patterns (e.g., "image/*")
-    for glob in accepted {
-        if glob.ends_with("/*") {
-            let prefix = glob.split('/').next().unwrap();
-            if mime.starts_with(&format!("{}/", prefix)) {
-                return true;
-            }
-        }
-    }
-
-    // Check for exact match
-    accepted.contains(&mime.to_string())
-}

src/actor_store/blob/placeholder.rs

···
-use anyhow::Result;
-use atrium_repo::Cid;
-
-use super::{BlobStore, BlobStream};
-
-/// Placeholder implementation for blob store
-#[derive(Clone)]
-pub struct BlobStorePlaceholder;
-
-impl BlobStore for BlobStorePlaceholder {
-    async fn put_temp(&self, _bytes: &[u8]) -> Result<String> {
-        todo!("BlobStorePlaceholder::put_temp not implemented");
-    }
-
-    async fn make_permanent(&self, _key: &str, _cid: Cid) -> Result<()> {
-        todo!("BlobStorePlaceholder::make_permanent not implemented");
-    }
-
-    async fn put_permanent(&self, _cid: Cid, _bytes: &[u8]) -> Result<()> {
-        todo!("BlobStorePlaceholder::put_permanent not implemented");
-    }
-
-    async fn quarantine(&self, _cid: Cid) -> Result<()> {
-        todo!("BlobStorePlaceholder::quarantine not implemented");
-    }
-
-    async fn unquarantine(&self, _cid: Cid) -> Result<()> {
-        todo!("BlobStorePlaceholder::unquarantine not implemented");
-    }
-
-    async fn get_bytes(&self, _cid: Cid) -> Result<Vec<u8>> {
-        todo!("BlobStorePlaceholder::get_bytes not implemented");
-    }
-
-    async fn get_stream(&self, _cid: Cid) -> Result<BlobStream> {
-        todo!("BlobStorePlaceholder::get_stream not implemented");
-    }
-
-    async fn has_temp(&self, _key: &str) -> Result<bool> {
-        todo!("BlobStorePlaceholder::has_temp not implemented");
-    }
-
-    async fn has_stored(&self, _cid: Cid) -> Result<bool> {
-        todo!("BlobStorePlaceholder::has_stored not implemented");
-    }
-
-    async fn delete(&self, _cid: Cid) -> Result<()> {
-        todo!("BlobStorePlaceholder::delete not implemented");
-    }
-
-    async fn delete_many(&self, _cids: Vec<Cid>) -> Result<()> {
-        todo!("BlobStorePlaceholder::delete_many not implemented");
-    }
-}

src/actor_store/db.rs

···
 
 use crate::db::DatabaseConnection;
 use anyhow::{Context as _, Result};
-use diesel::prelude::*;
 
 /// Type alias for the actor database.
 pub(crate) type ActorDb = DatabaseConnection;

src/actor_store/mod.rs

···
 //! Actor store implementation for ATProto PDS.
 
 mod actor_store;
-mod actor_store_handler;
-mod actor_store_resources;
 mod blob;
 mod db;
 mod preference;
-mod prepared_write;
 mod record;
-mod repo;
+mod sql_blob;
 mod sql_repo;
 
 pub(crate) use actor_store::ActorStore;
-pub(crate) use actor_store_handler::ActorStoreHandler;
-pub(crate) use actor_store_resources::ActorStoreResources;
 pub(crate) use db::ActorDb;
-pub(crate) use prepared_write::PreparedWrite;
+pub(crate) use sql_blob::BlobStoreSql;

src/actor_store/preference.rs

···
 //! Preference handling for actor store.
+//! Based on https://github.com/blacksky-algorithms/rsky/blob/main/rsky-pds/src/actor_store/preference/mod.rs
+//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
+//!
+//! Modified for SQLite backend
 
 use anyhow::{Result, bail};
 use diesel::*;
 use rsky_lexicon::app::bsky::actor::RefPreferences;
-use rsky_pds::{
-    actor_store::preference::{pref_match_namespace, util::pref_in_scope},
-    auth_verifier::AuthScope,
-    models::AccountPref,
-};
-
-use crate::actor_store::db::ActorDb;
+use rsky_pds::actor_store::preference::pref_match_namespace;
+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;
 
-/// Handler for preference operations with both read and write capabilities.
-pub(crate) struct PreferenceHandler {
-    /// Database connection.
-    pub db: ActorDb,
-    /// DID of the actor.
+pub struct PreferenceReader {
     pub did: String,
+    pub db: Arc<DbConn>,
 }
 
-impl PreferenceHandler {
-    /// Create a new preference handler.
-    pub(crate) fn new(did: String, db: ActorDb) -> Self {
-        Self { db, did }
+impl PreferenceReader {
+    pub fn new(did: String, db: Arc<DbConn>) -> Self {
+        PreferenceReader { did, db }
     }
 
-    /// Get preferences for a namespace.
     pub async fn get_preferences(
         &self,
         namespace: Option<String>,
···
             .await
     }
 
-    /// Put preferences for a namespace.
     #[tracing::instrument(skip_all)]
     pub async fn put_preferences(
         &self,
···
                         use rsky_pds::schema::pds::account_pref::dsl as AccountPrefSchema;
                         let all_prefs = AccountPrefSchema::account_pref
                             .filter(AccountPrefSchema::did.eq(&did))
-                            .select(AccountPref::as_select())
+                            .select(models::AccountPref::as_select())
                             .load(conn)?;
                         let put_prefs = values
                             .into_iter()

src/actor_store/prepared_write.rs

···
-use std::str::FromStr;
-
-use cidv10::Cid as CidV10;
-use rsky_repo::types::{
-    CommitAction, PreparedBlobRef, PreparedCreateOrUpdate, PreparedDelete, WriteOpAction,
-};
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum PreparedWrite {
-    Create(PreparedCreateOrUpdate),
-    Update(PreparedCreateOrUpdate),
-    Delete(PreparedDelete),
-}
-
-impl PreparedWrite {
-    pub fn uri(&self) -> &String {
-        match self {
-            PreparedWrite::Create(w) => &w.uri,
-            PreparedWrite::Update(w) => &w.uri,
-            PreparedWrite::Delete(w) => &w.uri,
-        }
-    }
-
-    pub fn cid(&self) -> Option<CidV10> {
-        match self {
-            PreparedWrite::Create(w) => Some(CidV10::from_str(w.cid.to_string().as_str()).unwrap()),
-            PreparedWrite::Update(w) => Some(CidV10::from_str(w.cid.to_string().as_str()).unwrap()),
-            PreparedWrite::Delete(_) => None,
-        }
-    }
-
-    pub fn swap_cid(&self) -> Option<CidV10> {
-        match self {
-            PreparedWrite::Create(w) => w
-                .swap_cid
-                .as_ref()
-                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
-            PreparedWrite::Update(w) => w
-                .swap_cid
-                .as_ref()
-                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
-            PreparedWrite::Delete(w) => w
-                .swap_cid
-                .as_ref()
-                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
-        }
-    }
-
-    pub fn action(&self) -> &WriteOpAction {
-        match self {
-            PreparedWrite::Create(w) => &w.action,
-            PreparedWrite::Update(w) => &w.action,
-            PreparedWrite::Delete(w) => &w.action,
-        }
-    }
-
-    /// TEQ: Add blobs() impl
-    pub fn blobs(&self) -> Option<&Vec<PreparedBlobRef>> {
-        match self {
-            PreparedWrite::Create(w) => Some(&w.blobs),
-            PreparedWrite::Update(w) => Some(&w.blobs),
-            PreparedWrite::Delete(_) => None,
-        }
-    }
-}
-
-impl From<&PreparedWrite> for CommitAction {
-    fn from(value: &PreparedWrite) -> Self {
-        match value {
-            &PreparedWrite::Create(_) => CommitAction::Create,
-            &PreparedWrite::Update(_) => CommitAction::Update,
-            &PreparedWrite::Delete(_) => CommitAction::Delete,
-        }
-    }
-}

src/actor_store/record.rs

···
 //! Record storage and retrieval for the actor store.
+//! Based on https://github.com/blacksky-algorithms/rsky/blob/main/rsky-pds/src/actor_store/record/mod.rs
+//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
+//!
+//! Modified for SQLite backend
 
-use anyhow::{Context as _, Result, bail};
-use atrium_api::com::atproto::admin::defs::StatusAttr;
-use atrium_repo::Cid;
-use diesel::associations::HasTable;
-use diesel::prelude::*;
+use anyhow::{Error, Result, bail};
+use cidv10::Cid;
+use diesel::*;
+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::schema::pds::repo_block::dsl::repo_block;
-use rsky_pds::schema::pds::{backlink, record};
-use rsky_repo::types::WriteOpAction;
+use rsky_repo::types::{RepoRecord, WriteOpAction};
+use rsky_repo::util::cbor_to_lex_record;
 use rsky_syntax::aturi::AtUri;
+use std::env;
 use std::str::FromStr;
 
-use crate::actor_store::blob::BlobStorePlaceholder;
 use crate::actor_store::db::ActorDb;
 
 /// Combined handler for record operations with both read and write capabilities.
-pub(crate) struct RecordHandler {
+pub(crate) struct RecordReader {
     /// Database connection.
     pub db: ActorDb,
     /// DID of the actor.
     pub did: String,
-    /// Blob store for handling blobs.
-    pub blobstore: Option<BlobStorePlaceholder>,
 }
 
-/// Record descriptor containing URI, path, and CID.
-pub(crate) struct RecordDescript {
-    /// Record URI.
-    pub uri: String,
-    /// Record path.
-    pub path: String,
-    /// Record CID.
-    pub cid: Cid,
-}
-
-/// Record data with values.
-#[derive(Debug, Clone)]
-pub(crate) struct RecordData {
-    /// Record URI.
-    pub uri: String,
-    /// Record CID.
-    pub cid: String,
-    /// Record value as JSON.
-    pub value: serde_json::Value,
-    /// When the record was indexed.
-    pub indexedAt: String,
-    /// Reference for takedown, if any.
-    pub takedownRef: Option<String>,
-}
-
-/// Options for listing records in a collection.
-#[derive(Debug, Clone)]
-pub(crate) struct ListRecordsOptions {
-    /// Collection to list records from.
-    pub collection: String,
-    /// Maximum number of records to return.
-    pub limit: i64,
-    /// Whether to reverse the sort order.
-    pub reverse: bool,
-    /// Cursor for pagination.
-    pub cursor: Option<String>,
-    /// Start key (deprecated).
-    pub rkey_start: Option<String>,
-    /// End key (deprecated).
-    pub rkey_end: Option<String>,
-    /// Whether to include soft-deleted records.
-    pub include_soft_deleted: bool,
-}
-
-impl RecordHandler {
+impl RecordReader {
     /// Create a new record handler.
-    pub(crate) fn new(db: ActorDb, did: String) -> Self {
-        Self {
-            db,
-            did,
-            blobstore: None,
-        }
-    }
-
-    /// Create a new record handler with blobstore support.
-    pub(crate) fn new_with_blobstore(
-        db: ActorDb,
-        blobstore: BlobStorePlaceholder,
-        did: String,
-    ) -> Self {
-        Self {
-            db,
-            did,
-            blobstore: Some(blobstore),
-        }
+    pub(crate) fn new(did: String, db: ActorDb) -> Self {
+        Self { did, db }
     }
 
     /// Count the total number of records.
-    pub(crate) async fn record_count(&self) -> Result<i64> {
-        let did = self.did.clone();
+    pub(crate) async fn record_count(&mut self) -> Result<i64> {
+        use rsky_pds::schema::pds::record::dsl::*;
 
+        let other_did = self.did.clone();
         self.db
             .run(move |conn| {
-                use rsky_pds::schema::pds::record::dsl::*;
-
-                record.filter(did.eq(&did)).count().get_result(conn)
+                let res: i64 = record.filter(did.eq(&other_did)).count().get_result(conn)?;
+                Ok(res)
             })
             .await
     }
 
-    /// List all records.
-    pub(crate) async fn list_all(&self) -> Result<Vec<RecordDescript>> {
-        let did = self.did.clone();
-        let mut records = Vec::new();
-        let mut current_cursor = Some("".to_string());
-
-        while let Some(cursor) = current_cursor.take() {
-            let cursor_clone = cursor.clone();
-            let did_clone = did.clone();
-
-            let rows = self
-                .db
-                .run(move |conn| {
-                    use rsky_pds::schema::pds::record::dsl::*;
-
-                    record
-                        .filter(did.eq(&did_clone))
-                        .filter(uri.gt(&cursor_clone))
-                        .order(uri.asc())
-                        .limit(1000)
-                        .select((uri, cid))
-                        .load::<(String, String)>(conn)
-                })
-                .await?;
-
-            for (uri_str, cid_str) in &rows {
-                let uri = uri_str.clone();
-                let parts: Vec<&str> = uri.rsplitn(2, '/').collect();
-                let path = if parts.len() == 2 {
-                    format!("{}/{}", parts[1], parts[0])
-                } else {
-                    uri.clone()
-                };
-
-                match Cid::from_str(&cid_str) {
-                    Ok(cid) => records.push(RecordDescript { uri, path, cid }),
-                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
-                }
-            }
-
-            if let Some(last) = rows.last() {
-                current_cursor = Some(last.0.clone());
-            } else {
-                break;
-            }
-        }
-
-        Ok(records)
-    }
-
     /// List all collections in the repository.
     pub(crate) async fn list_collections(&self) -> Result<Vec<String>> {
-        let did = self.did.clone();
+        use rsky_pds::schema::pds::record::dsl::*;
 
+        let other_did = self.did.clone();
         self.db
             .run(move |conn| {
-                use rsky_pds::schema::pds::record::dsl::*;
-
-                record
-                    .filter(did.eq(&did))
+                let collections = record
+                    .filter(did.eq(&other_did))
+                    .select(collection)
                     .group_by(collection)
-                    .select(collection)
-                    .load::<String>(conn)
+                    .load::<String>(conn)?
+                    .into_iter()
+                    .collect::<Vec<String>>();
+                Ok(collections)
             })
             .await
     }
 
     /// List records for a specific collection.
     pub(crate) async fn list_records_for_collection(
-        &self,
-        opts: ListRecordsOptions,
-    ) -> Result<Vec<RecordData>> {
-        let did = self.did.clone();
+        &mut self,
+        collection: String,
+        limit: i64,
+        reverse: bool,
+        cursor: Option<String>,
+        rkey_start: Option<String>,
+        rkey_end: Option<String>,
+        include_soft_deleted: Option<bool>,
+    ) -> Result<Vec<RecordsForCollection>> {
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        self.db
-            .run(move |conn| {
-                // Start building the query
-                let mut query = record::table
-                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
-                    .filter(record::did.eq(&did))
-                    .filter(record::collection.eq(&opts.collection))
-                    .into_boxed();
-
-                // Handle soft-deleted records
-                if !opts.include_soft_deleted {
-                    query = query.filter(record::takedownRef.is_null());
-                }
-
-                // Handle cursor-based pagination first
-                if let Some(cursor) = &opts.cursor {
-                    if opts.reverse {
-                        query = query.filter(record::rkey.gt(cursor));
-                    } else {
-                        query = query.filter(record::rkey.lt(cursor));
-                    }
-                } else {
-                    // Fall back to deprecated rkey-based pagination
-                    if let Some(start) = &opts.rkey_start {
-                        query = query.filter(record::rkey.gt(start));
-                    }
-                    if let Some(end) = &opts.rkey_end {
-                        query = query.filter(record::rkey.lt(end));
-                    }
-                }
-
-                // Add order and limit
-                if opts.reverse {
-                    query = query.order(record::rkey.asc());
-                } else {
-                    query = query.order(record::rkey.desc());
-                }
-
-                query = query.limit(opts.limit);
-
-                // Execute the query
-                let results = query
-                    .select((
-                        record::uri,
-                        record::cid,
-                        record::indexedAt,
-                        record::takedownRef,
-                        repo_block::content,
-                    ))
-                    .load::<(String, String, String, Option<String>, Vec<u8>)>(conn)?;
-
-                // Convert results to RecordData
-                let records = results
-                    .into_iter()
-                    .map(|(uri, cid, indexedAt, takedownRef, content)| {
-                        let value = serde_json::from_slice(&content)
-                            .with_context(|| format!("Failed to decode record {}", cid))?;
-
-                        Ok(RecordData {
-                            uri,
-                            cid,
-                            value,
-                            indexedAt,
-                            takedownRef,
-                        })
-                    })
-                    .collect::<Result<Vec<_>>>()?;
+        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
+            include_soft_deleted
+        } else {
+            false
+        };
+        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(),
+            ))
+            .filter(RecordSchema::did.eq(self.did.clone()))
+            .filter(RecordSchema::collection.eq(collection))
+            .into_boxed();
+        if !include_soft_deleted {
+            builder = builder.filter(RecordSchema::takedownRef.is_null());
+        }
+        if reverse {
+            builder = builder.order(RecordSchema::rkey.asc());
+        } else {
+            builder = builder.order(RecordSchema::rkey.desc());
+        }
 
-                Ok(records)
+        if let Some(cursor) = cursor {
+            if reverse {
+                builder = builder.filter(RecordSchema::rkey.gt(cursor));
+            } else {
+                builder = builder.filter(RecordSchema::rkey.lt(cursor));
+            }
+        } else {
+            if let Some(rkey_start) = rkey_start {
+                builder = builder.filter(RecordSchema::rkey.gt(rkey_start));
+            }
+            if let Some(rkey_end) = rkey_end {
+                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?;
+        res.into_iter()
+            .map(|row| {
+                Ok(RecordsForCollection {
+                    uri: row.0.uri,
+                    cid: row.0.cid,
+                    value: cbor_to_lex_record(row.1.content)?,
+                })
             })
-            .await
+            .collect::<Result<Vec<RecordsForCollection>>>()
     }
 
     /// Get a specific record by URI.
     pub(crate) async fn get_record(
-        &self,
+        &mut self,
         uri: &AtUri,
-        cid: Option<&str>,
-        include_soft_deleted: bool,
-    ) -> Result<Option<RecordData>> {
-        let did = self.did.clone();
-        let uri_str = uri.to_string();
-        let cid_opt = cid.map(|c| c.to_string());
-
-        self.db
-            .run(move |conn| {
-                let mut query = record::table
-                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
-                    .filter(record::did.eq(&did))
-                    .filter(record::uri.eq(&uri_str))
-                    .into_boxed();
-
-                if !include_soft_deleted {
-                    query = query.filter(record::takedownRef.is_null());
-                }
-
-                if let Some(cid_val) = cid_opt {
-                    query = query.filter(record::cid.eq(cid_val));
-                }
+        cid: Option<String>,
+        include_soft_deleted: Option<bool>,
+    ) -> Result<Option<GetRecord>> {
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-                let result = query
-                    .select((
-                        record::uri,
-                        record::cid,
-                        record::indexedAt,
-                        record::takedownRef,
-                        repo_block::content,
-                    ))
-                    .first::<(String, String, String, Option<String>, Vec<u8>)>(conn)
-                    .optional()?;
-
-                if let Some((uri, cid, indexedAt, takedownRef, content)) = result {
-                    let value = serde_json::from_slice(&content)
-                        .with_context(|| format!("Failed to decode record {}", cid))?;
-
-                    Ok(Some(RecordData {
-                        uri,
-                        cid,
-                        value,
-                        indexedAt,
-                        takedownRef,
-                    }))
-                } else {
-                    Ok(None)
-                }
-            })
-            .await
+        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
+            include_soft_deleted
+        } else {
+            false
+        };
+        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(),
+            ))
+            .filter(RecordSchema::uri.eq(uri.to_string()))
+            .into_boxed();
+        if !include_soft_deleted {
+            builder = builder.filter(RecordSchema::takedownRef.is_null());
+        }
+        if let Some(cid) = cid {
+            builder = builder.filter(RecordSchema::cid.eq(cid));
+        }
+        let record: Option<(rsky_pds::models::Record, rsky_pds::models::RepoBlock)> = self
+            .db
+            .run(move |conn| builder.first(conn).optional())
+            .await?;
+        if let Some(record) = record {
+            Ok(Some(GetRecord {
+                uri: record.0.uri,
+                cid: record.0.cid,
+                value: cbor_to_lex_record(record.1.content)?,
+                indexed_at: record.0.indexed_at,
+                takedown_ref: record.0.takedown_ref,
+            }))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Check if a record exists.
     pub(crate) async fn has_record(
-        &self,
-        uri: &str,
-        cid: Option<&str>,
-        include_soft_deleted: bool,
+        &mut self,
+        uri: String,
+        cid: Option<String>,
+        include_soft_deleted: Option<bool>,
     ) -> Result<bool> {
-        let did = self.did.clone();
-        let uri_str = uri.to_string();
-        let cid_opt = cid.map(|c| c.to_string());
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        self.db
-            .run(move |conn| {
-                let mut query = record::table
-                    .filter(record::did.eq(&did))
-                    .filter(record::uri.eq(&uri_str))
-                    .into_boxed();
-
-                if !include_soft_deleted {
-                    query = query.filter(record::takedownRef.is_null());
-                }
-
-                if let Some(cid_val) = cid_opt {
-                    query = query.filter(record::cid.eq(cid_val));
-                }
-
-                let exists = query
-                    .select(record::uri)
-                    .first::<String>(conn)
-                    .optional()?
-                    .is_some();
-
-                Ok(exists)
-            })
-            .await
+        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
+            include_soft_deleted
+        } else {
+            false
+        };
+        let mut builder = RecordSchema::record
+            .select(RecordSchema::uri)
+            .filter(RecordSchema::uri.eq(uri))
+            .into_boxed();
+        if !include_soft_deleted {
+            builder = builder.filter(RecordSchema::takedownRef.is_null());
+        }
+        if let Some(cid) = cid {
+            builder = builder.filter(RecordSchema::cid.eq(cid));
+        }
+        let record_uri = self
+            .db
+            .run(move |conn| builder.first::<String>(conn).optional())
+            .await?;
+        Ok(!!record_uri.is_some())
     }
 
     /// Get the takedown status of a record.
-    pub(crate) async fn get_record_takedown_status(&self, uri: &str) -> Result<Option<StatusAttr>> {
-        let did = self.did.clone();
-        let uri_str = uri.to_string();
+    pub(crate) async fn get_record_takedown_status(
+        &self,
+        uri: String,
+    ) -> Result<Option<StatusAttr>> {
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        self.db
+        let res = self
+            .db
             .run(move |conn| {
-                let result = record::table
-                    .filter(record::did.eq(&did))
-                    .filter(record::uri.eq(&uri_str))
-                    .select(record::takedownRef)
+                RecordSchema::record
+                    .select(RecordSchema::takedownRef)
+                    .filter(RecordSchema::uri.eq(uri))
                     .first::<Option<String>>(conn)
-                    .optional()?;
-
-                match result {
-                    Some(takedown) => match takedown {
-                        Some(takedownRef) => Ok(Some(StatusAttr {
-                            applied: true,
-                            r#ref: Some(takedownRef),
-                        })),
-                        None => Ok(Some(StatusAttr {
-                            applied: false,
-                            r#ref: None,
-                        })),
-                    },
-                    None => Ok(None),
-                }
+                    .optional()
             })
-            .await
+            .await?;
+        if let Some(res) = res {
+            if let Some(takedown_ref) = res {
+                Ok(Some(StatusAttr {
+                    applied: true,
+                    r#ref: Some(takedown_ref),
+                }))
+            } else {
+                Ok(Some(StatusAttr {
+                    applied: false,
+                    r#ref: None,
+                }))
+            }
+        } else {
+            Ok(None)
+        }
     }
 
     /// Get the current CID for a record URI.
-    pub(crate) async fn get_current_record_cid(&self, uri: &str) -> Result<Option<Cid>> {
-        let did = self.did.clone();
-        let uri_str = uri.to_string();
+    pub(crate) async fn get_current_record_cid(&self, uri: String) -> Result<Option<Cid>> {
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        self.db
+        let res = self
+            .db
             .run(move |conn| {
-                let result = record::table
-                    .filter(record::did.eq(&did))
-                    .filter(record::uri.eq(&uri_str))
-                    .select(record::cid)
+                RecordSchema::record
+                    .select(RecordSchema::cid)
+                    .filter(RecordSchema::uri.eq(uri))
                     .first::<String>(conn)
-                    .optional()?;
-
-                match result {
-                    Some(cid_str) => {
-                        let cid = Cid::from_str(&cid_str)?;
-                        Ok(Some(cid))
-                    }
-                    None => Ok(None),
-                }
+                    .optional()
             })
-            .await
+            .await?;
+        if let Some(res) = res {
+            Ok(Some(Cid::from_str(&res)?))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Get backlinks for a record.
     pub(crate) async fn get_record_backlinks(
         &self,
-        collection: &str,
-        path: &str,
-        linkTo: &str,
+        collection: String,
+        path: String,
+        link_to: String,
     ) -> Result<Vec<Record>> {
-        let did = self.did.clone();
-        let collection_str = collection.to_string();
-        let path_str = path.to_string();
-        let linkTo_str = linkTo.to_string();
+        use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        self.db
+        let res = self
+            .db
             .run(move |conn| {
-                backlink::table
-                    .inner_join(record::table.on(backlink::uri.eq(record::uri)))
-                    .filter(backlink::path.eq(&path_str))
-                    .filter(backlink::linkTo.eq(&linkTo_str))
-                    .filter(record::collection.eq(&collection_str))
-                    .filter(record::did.eq(&did))
+                RecordSchema::record
+                    .inner_join(
+                        BacklinkSchema::backlink.on(BacklinkSchema::uri.eq(RecordSchema::uri)),
+                    )
                     .select(Record::as_select())
+                    .filter(BacklinkSchema::path.eq(path))
+                    .filter(BacklinkSchema::linkTo.eq(link_to))
+                    .filter(RecordSchema::collection.eq(collection))
                     .load::<Record>(conn)
             })
-            .await
+            .await?;
+        Ok(res)
     }
 
     /// Get backlink conflicts for a record.
     pub(crate) async fn get_backlink_conflicts(
         &self,
         uri: &AtUri,
-        record: &serde_json::Value,
-    ) -> Result<Vec<String>> {
-        let backlinks = get_backlinks(uri, record)?;
-        if backlinks.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let did = self.did.clone();
-        let uri_collection = uri.get_collection().to_string();
-        let mut conflicts = Vec::new();
-
-        for backlink in backlinks {
-            let path_str = backlink.path.clone();
-            let linkTo_str = backlink.linkTo.clone();
-
-            let results = self
-                .db
-                .run(move |conn| {
-                    backlink::table
-                        .inner_join(record::table.on(backlink::uri.eq(record::uri)))
-                        .filter(backlink::path.eq(&path_str))
-                        .filter(backlink::linkTo.eq(&linkTo_str))
-                        .filter(record::collection.eq(&uri_collection))
-                        .filter(record::did.eq(&did))
-                        .select(record::uri)
-                        .load::<String>(conn)
-                })
-                .await?;
-
-            conflicts.extend(results);
-        }
-
-        Ok(conflicts)
-    }
-
-    /// List existing blocks in the repository.
-    pub(crate) async fn list_existing_blocks(&self) -> Result<Vec<Cid>> {
-        let did = self.did.clone();
-        let mut blocks = Vec::new();
-        let mut current_cursor = Some("".to_string());
-
-        while let Some(cursor) = current_cursor.take() {
-            let cursor_clone = cursor.clone();
-            let did_clone = did.clone();
-
-            let rows = self
-                .db
-                .run(move |conn| {
-                    use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                    repo_block
-                        .filter(did.eq(&did_clone))
-                        .filter(cid.gt(&cursor_clone))
-                        .order(cid.asc())
-                        .limit(1000)
-                        .select(cid)
-                        .load::<String>(conn)
-                })
-                .await?;
-
-            for cid_str in &rows {
-                match Cid::from_str(cid_str) {
-                    Ok(cid) => blocks.push(cid),
-                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
-                }
-            }
-
-            if let Some(last) = rows.last() {
-                current_cursor = Some(last.clone());
-            } else {
-                break;
-            }
-        }
-
-        Ok(blocks)
-    }
-
-    /// Get the profile record for this repository
-    pub(crate) async fn get_profile_record(&self) -> Result<Option<serde_json::Value>> {
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                let result = record::table
-                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
-                    .filter(record::did.eq(&did))
-                    .filter(record::collection.eq("app.bsky.actor.profile"))
-                    .filter(record::rkey.eq("self"))
-                    .select(repo_block::content)
-                    .first::<Vec<u8>>(conn)
-                    .optional()?;
-
-                if let Some(content) = result {
-                    let value = serde_json::from_slice(&content)
-                        .context("Failed to decode profile record")?;
-                    Ok(Some(value))
-                } else {
-                    Ok(None)
-                }
+        record: &RepoRecord,
+    ) -> Result<Vec<AtUri>> {
+        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>(
+                    self.get_record_backlinks(
+                        uri.get_collection(),
+                        backlink.path,
+                        backlink.link_to,
+                    )
+                    .await?,
+                )
             })
+            .collect::<Vec<_>>()
             .await
-    }
-
-    /// Get records created or updated since a specific revision
-    pub(crate) async fn get_records_since_rev(&self, rev: &str) -> Result<Vec<RecordData>> {
-        let did = self.did.clone();
-        let rev_str = rev.to_string();
-
-        // First check if the revision exists
-        let exists = self
-            .db
-            .run({
-                let did_clone = did.clone();
-                let rev_clone = rev_str.clone();
-
-                move |conn| {
-                    record::table
-                        .filter(record::did.eq(&did_clone))
-                        .filter(record::repoRev.le(&rev_clone))
-                        .count()
-                        .get_result::<i64>(conn)
-                        .map(|count| count > 0)
-                }
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(conflicts
+            .into_iter()
+            .flatten()
+            .filter_map(|record| {
+                AtUri::make(
+                    env::var("BLUEPDS_HOST_NAME").unwrap_or("localhost".to_owned()),
+                    Some(String::from(uri.get_collection())),
+                    Some(record.rkey),
+                )
+                .ok()
             })
-            .await?;
-
-        if !exists {
-            // No records before this revision - possible account migration case
-            return Ok(Vec::new());
-        }
-
-        // Get records since the revision
-        self.db
-            .run(move |conn| {
-                let results = record::table
-                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
-                    .filter(record::did.eq(&did))
-                    .filter(record::repoRev.gt(&rev_str))
-                    .order(record::repoRev.asc())
-                    .limit(10)
-                    .select((
-                        record::uri,
-                        record::cid,
-                        record::indexedAt,
-                        repo_block::content,
-                    ))
-                    .load::<(String, String, String, Vec<u8>)>(conn)?;
-
-                let records = results
-                    .into_iter()
-                    .map(|(uri, cid, indexedAt, content)| {
-                        let value = serde_json::from_slice(&content)
-                            .with_context(|| format!("Failed to decode record {}", cid))?;
-
-                        Ok(RecordData {
-                            uri,
-                            cid,
-                            value,
-                            indexedAt,
-                            takedownRef: None, // Not included in the query
-                        })
-                    })
-                    .collect::<Result<Vec<_>>>()?;
-
-                Ok(records)
-            })
-            .await
+            .collect::<Vec<AtUri>>())
     }
 
     // Transactor methods
     // -----------------
 
     /// Index a record in the database.
+    #[tracing::instrument(skip_all)]
     pub(crate) async fn index_record(
         &self,
         uri: AtUri,
         cid: Cid,
-        record: Option<&serde_json::Value>,
-        action: WriteOpAction,
-        repoRev: &str,
+        record: Option<RepoRecord>,
+        action: Option<WriteOpAction>, // Create or update with a default of create
+        repo_rev: String,
         timestamp: Option<String>,
     ) -> Result<()> {
-        let uri_str = uri.to_string();
-        tracing::debug!("Indexing record {}", uri_str);
+        tracing::debug!("@LOG DEBUG RecordReader::index_record, indexing record {uri}");
 
-        if !uri_str.starts_with("at://did:") {
-            return Err(anyhow::anyhow!("Expected indexed URI to contain DID"));
-        }
+        let collection = uri.get_collection();
+        let rkey = uri.get_rkey();
+        let hostname = uri.get_hostname().to_string();
+        let action = action.unwrap_or(WriteOpAction::Create);
+        let indexed_at = timestamp.unwrap_or_else(|| rsky_common::now());
+        let row = Record {
+            did: self.did.clone(),
+            uri: uri.to_string(),
+            cid: cid.to_string(),
+            collection: collection.clone(),
+            rkey: rkey.to_string(),
+            repo_rev: Some(repo_rev.clone()),
+            indexed_at: indexed_at.clone(),
+            takedown_ref: None,
+        };
 
-        let collection = uri.get_collection().to_string();
-        let rkey = uri.get_rkey().to_string();
-
-        if collection.is_empty() {
-            return Err(anyhow::anyhow!(
-                "Expected indexed URI to contain a collection"
-            ));
+        if !hostname.starts_with("did:") {
+            bail!("Expected indexed URI to contain DID")
+        } else if collection.is_empty() {
+            bail!("Expected indexed URI to contain a collection")
         } else if rkey.is_empty() {
-            return Err(anyhow::anyhow!(
-                "Expected indexed URI to contain a record key"
-            ));
+            bail!("Expected indexed URI to contain a record key")
         }
 
-        let cid_str = cid.to_string();
-        let now = timestamp.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
-        let did = self.did.clone();
-        let repoRev = repoRev.to_string();
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        // Create the record for database insertion
-        let record_values = (
-            record::did.eq(&did),
-            record::uri.eq(&uri_str),
-            record::cid.eq(&cid_str),
-            record::collection.eq(&collection),
-            record::rkey.eq(&rkey),
-            record::repoRev.eq(&repoRev),
-            record::indexedAt.eq(&now),
-        );
-
-        self.db
-            .transaction(move |conn| {
-                // Track current version of record
-                diesel::insert_into(record::table)
-                    .values(&record_values)
-                    .on_conflict(record::uri)
+        // Track current version of record
+        let (record, uri) = self
+            .db
+            .run(move |conn| {
+                insert_into(RecordSchema::record)
+                    .values(row)
+                    .on_conflict(RecordSchema::uri)
                     .do_update()
                     .set((
-                        record::cid.eq(&cid_str),
-                        record::repoRev.eq(&repoRev),
-                        record::indexedAt.eq(&now),
+                        RecordSchema::cid.eq(cid.to_string()),
+                        RecordSchema::repoRev.eq(&repo_rev),
+                        RecordSchema::indexedAt.eq(&indexed_at),
                     ))
-                    .execute(conn)
-                    .context("Failed to insert/update record")?;
+                    .execute(conn)?;
+                Ok::<_, Error>((record, uri))
+            })
+            .await?;
 
-                // Maintain backlinks if record is provided
-                if let Some(record_value) = record {
-                    let backlinks = get_backlinks(&uri, record_value)?;
-
-                    if action == WriteOpAction::Update {
-                        // On update, clear old backlinks first
-                        diesel::delete(backlink::table)
-                            .filter(backlink::uri.eq(&uri_str))
-                            .execute(conn)
-                            .context("Failed to delete existing backlinks")?;
-                    }
-
-                    if !backlinks.is_empty() {
-                        // Insert all backlinks at once
-                        let backlink_values: Vec<_> = backlinks
-                            .into_iter()
-                            .map(|backlink| {
-                                (
-                                    backlink::uri.eq(&uri_str),
-                                    backlink::path.eq(&backlink.path),
-                                    backlink::linkTo.eq(&backlink.linkTo),
-                                )
-                            })
-                            .collect();
-
-                        diesel::insert_into(backlink::table)
-                            .values(&backlink_values)
-                            .on_conflict_do_nothing()
-                            .execute(conn)
-                            .context("Failed to insert backlinks")?;
-                    }
-                }
-
-                tracing::info!("Indexed record {}", uri_str);
-                Ok(())
-            })
-            .await
+        if let Some(record) = record {
+            // Maintain backlinks
+            let backlinks = get_backlinks(&uri, &record)?;
+            if let WriteOpAction::Update = action {
+                // On update just recreate backlinks from scratch for the record, so we can clear out
+                // the old ones. E.g. for weird cases like updating a follow to be for a different did.
+                self.remove_backlinks_by_uri(&uri).await?;
+            }
+            self.add_backlinks(backlinks).await?;
+        }
+        tracing::debug!("@LOG DEBUG RecordReader::index_record, indexed record {uri}");
+        Ok(())
     }
 
     /// Delete a record from the database.
+    #[tracing::instrument(skip_all)]
     pub(crate) async fn delete_record(&self, uri: &AtUri) -> Result<()> {
-        let uri_str = uri.to_string();
-        tracing::debug!("Deleting indexed record {}", uri_str);
-
+        tracing::debug!("@LOG DEBUG RecordReader::delete_record, deleting indexed record {uri}");
+        use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
+        let uri = uri.to_string();
         self.db
-            .transaction(move |conn| {
-                // Delete from record table
-                diesel::delete(record::table)
-                    .filter(record::uri.eq(&uri_str))
-                    .execute(conn)
-                    .context("Failed to delete record")?;
-
-                // Delete from backlink table
-                diesel::delete(backlink::table)
-                    .filter(backlink::uri.eq(&uri_str))
-                    .execute(conn)
-                    .context("Failed to delete record backlinks")?;
-
-                tracing::info!("Deleted indexed record {}", uri_str);
+            .run(move |conn| {
+                delete(RecordSchema::record)
+                    .filter(RecordSchema::uri.eq(&uri))
+                    .execute(conn)?;
+                delete(BacklinkSchema::backlink)
+                    .filter(BacklinkSchema::uri.eq(&uri))
+                    .execute(conn)?;
+                tracing::debug!(
+                    "@LOG DEBUG RecordReader::delete_record, deleted indexed record {uri}"
+                );
                 Ok(())
             })
             .await
     }
 
     /// Remove backlinks for a URI.
-    pub(crate) async fn remove_backlinks_by_uri(&self, uri: &str) -> Result<()> {
-        let uri_str = uri.to_string();
-
+    pub(crate) async fn remove_backlinks_by_uri(&self, uri: &AtUri) -> Result<()> {
+        use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
+        let uri = uri.to_string();
         self.db
             .run(move |conn| {
-                diesel::delete(backlink::table)
-                    .filter(backlink::uri.eq(&uri_str))
-                    .execute(conn)
-                    .context("Failed to remove backlinks")?;
-
+                delete(BacklinkSchema::backlink)
+                    .filter(BacklinkSchema::uri.eq(uri))
+                    .execute(conn)?;
                 Ok(())
             })
             .await
···
 
     /// Add backlinks to the database.
     pub(crate) async fn add_backlinks(&self, backlinks: Vec<Backlink>) -> Result<()> {
-        if backlinks.is_empty() {
-            return Ok(());
+        if backlinks.len() == 0 {
+            Ok(())
+        } else {
+            use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
+            self.db
+                .run(move |conn| {
+                    insert_into(BacklinkSchema::backlink)
+                        .values(&backlinks)
+                        .on_conflict_do_nothing()
+                        .execute(conn)?;
+                    Ok(())
+                })
+                .await
         }
-
-        self.db
-            .run(move |conn| {
-                let backlink_values: Vec<_> = backlinks
-                    .into_iter()
-                    .map(|backlink| {
-                        (
-                            backlink::uri.eq(&backlink.uri),
-                            backlink::path.eq(&backlink.path),
-                            backlink::linkTo.eq(&backlink.linkTo),
-                        )
-                    })
-                    .collect();
-
-                diesel::insert_into(backlink::table)
-                    .values(&backlink_values)
-                    .on_conflict_do_nothing()
-                    .execute(conn)
-                    .context("Failed to add backlinks")?;
-
-                Ok(())
-            })
-            .await
     }
 
     /// Update the takedown status of a record.
···
         uri: &AtUri,
         takedown: StatusAttr,
     ) -> Result<()> {
-        let uri_str = uri.to_string();
-        let did = self.did.clone();
-        let takedownRef = if takedown.applied {
-            takedown
-                .r#ref
-                .or_else(|| Some(chrono::Utc::now().to_rfc3339()))
-        } else {
-            None
+        use rsky_pds::schema::pds::record::dsl as RecordSchema;
+
+        let takedown_ref: Option<String> = match takedown.applied {
+            true => match takedown.r#ref {
+                Some(takedown_ref) => Some(takedown_ref),
+                None => Some(rsky_common::now()),
+            },
+            false => None,
         };
+        let uri_string = uri.to_string();
 
         self.db
             .run(move |conn| {
-                diesel::update(record::table)
-                    .filter(record::did.eq(&did))
-                    .filter(record::uri.eq(&uri_str))
-                    .set(record::takedownRef.eq(takedownRef))
-                    .execute(conn)
-                    .context("Failed to update record takedown status")?;
-
+                update(RecordSchema::record)
+                    .filter(RecordSchema::uri.eq(uri_string))
+                    .set(RecordSchema::takedownRef.eq(takedown_ref))
+                    .execute(conn)?;
                 Ok(())
             })
             .await
     }
 }
-
-/// Extract backlinks from a record.
-pub(super) fn get_backlinks(uri: &AtUri, record: &serde_json::Value) -> Result<Vec<Backlink>> {
-    let mut backlinks = Vec::new();
-
-    // Check for record type
-    if let Some(record_type) = record.get("$type").and_then(|t| t.as_str()) {
-        // Handle follow and block records
-        if record_type == "app.bsky.graph.follow" || record_type == "app.bsky.graph.block" {
-            if let Some(subject) = record.get("subject").and_then(|s| s.as_str()) {
-                // Verify it's a valid DID
-                if subject.starts_with("did:") {
-                    backlinks.push(Backlink {
-                        uri: uri.to_string(),
-                        path: "subject".to_string(),
-                        linkTo: subject.to_string(),
-                    });
-                }
-            }
-        }
-        // Handle like and repost records
-        else if record_type == "app.bsky.feed.like" || record_type == "app.bsky.feed.repost" {
-            if let Some(subject) = record.get("subject") {
-                if let Some(subject_uri) = subject.get("uri").and_then(|u| u.as_str()) {
-                    // Verify it's a valid AT URI
-                    if subject_uri.starts_with("at://") {
-                        backlinks.push(Backlink {
-                            uri: uri.to_string(),
-                            path: "subject.uri".to_string(),
-                            linkTo: subject_uri.to_string(),
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(backlinks)
-}

src/actor_store/repo.rs

···
-//! Repository operations for actor store.
-
-use std::str::FromStr as _;
-use std::sync::Arc;
-
-use anyhow::{Context as _, Result};
-use atrium_repo::Cid;
-use cidv10::Cid as CidV10;
-use diesel::prelude::*;
-use rsky_repo::{
-    block_map::BlockMap,
-    cid_set::CidSet,
-    repo::Repo,
-    storage::{readable_blockstore::ReadableBlockstore as _, types::RepoStorage},
-    types::{
-        CommitAction, CommitData, CommitDataWithOps, CommitOp, PreparedBlobRef, PreparedWrite,
-        WriteOpAction, write_to_op,
-    },
-    util::format_data_key,
-};
-use rsky_syntax::aturi::AtUri;
-use tokio::sync::RwLock;
-
-use super::{
-    ActorDb,
-    blob::{BackgroundQueue, BlobHandler, BlobStorePlaceholder},
-    record::RecordHandler,
-};
-use crate::SigningKey;
-
-use crate::actor_store::sql_repo::SqlRepoStorage;
-
-/// Data for sync events.
-pub(crate) struct SyncEventData {
-    /// The CID of the repository root.
-    pub cid: Cid,
-    /// The revision of the repository.
-    pub rev: String,
-    /// The blocks in the repository.
-    pub blocks: BlockMap,
-}
-
-/// Unified repository handler for the actor store with both read and write capabilities.
-pub(crate) struct RepoHandler {
-    /// Actor DID
-    pub did: String,
-    /// Backend storage
-    pub storage: Arc<RwLock<dyn RepoStorage>>,
-    /// BlobReader for handling blob operations
-    pub blob: BlobHandler,
-    /// RecordHandler for handling record operations
-    pub record: RecordHandler,
-    /// BlobTransactor for handling blob writes
-    pub blob_transactor: BlobHandler,
-    /// RecordHandler for handling record writes
-    pub record_transactor: RecordHandler,
-    /// Signing keypair
-    pub signing_key: Option<Arc<SigningKey>>,
-    /// Background queue for async operations
-    pub background_queue: BackgroundQueue,
-}
-
-impl RepoHandler {
-    /// Create a new repository handler with read/write capabilities.
-    pub(crate) fn new(
-        db: ActorDb,
-        blobstore: BlobStorePlaceholder,
-        did: String,
-        signing_key: Arc<SigningKey>,
-        background_queue: BackgroundQueue,
-    ) -> Self {
-        // Create readers
-        let blob = BlobHandler::new(db.clone(), blobstore.clone());
-        let record = RecordHandler::new(db.clone(), did.clone());
-
-        // Create storage backend with current timestamp
-        let now = chrono::Utc::now().to_rfc3339();
-        let storage = SqlRepoStorage::new(did.clone(), db.clone(), Some(now));
-
-        // Create transactors
-        let blob_transactor =
-            BlobHandler::new(db.clone(), blobstore.clone(), background_queue.clone());
-        let record_transactor = RecordHandler::new(db.clone(), blobstore);
-
-        Self {
-            did,
-            storage,
-            blob,
-            record,
-            blob_transactor,
-            record_transactor,
-            signing_key: Some(signing_key),
-            background_queue,
-        }
-    }
-
-    /// Get event data for synchronization.
-    pub(crate) async fn get_sync_event_data(&self) -> Result<SyncEventData> {
-        let root = self.storage.get_root_detailed().await?;
-        let blocks = self
-            .storage
-            .get_blocks(vec![CidV10::from_str(&root.cid.to_string()).unwrap()])
-            .await?;
-
-        Ok(SyncEventData {
-            cid: root.cid,
-            rev: root.rev,
-            blocks: blocks.blocks,
-        })
-    }
-
-    /// Try to load repository
-    pub(crate) async fn maybe_load_repo(&self) -> Result<Option<Repo>> {
-        match self.storage.get_root().await {
-            Some(cid) => {
-                let repo = Repo::load(&self.storage, cid).await?;
-                Ok(Some(repo))
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// Create a new repository with prepared writes
-    pub(crate) async fn create_repo(
-        &self,
-        writes: Vec<PreparedWrite>,
-    ) -> Result<CommitDataWithOps> {
-        let signing_key = self
-            .signing_key
-            .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("No signing key available for write operations"))?;
-
-        // Convert writes to operations
-        let ops = writes
-            .iter()
-            .map(|w| write_to_op(w))
-            .collect::<Result<Vec<_>>>()?;
-
-        // Format the initial commit
-        let commit = Repo::format_init_commit(&self.storage, &self.did, signing_key, ops).await?;
-
-        // Apply the commit, index the writes, and process blobs in parallel
-        let results = futures::future::join3(
-            self.storage.apply_commit(commit.clone(), Some(true)),
-            self.index_writes(&writes, &commit.rev),
-            self.blob_transactor
-                .process_write_blobs(&commit.rev, writes.clone()),
-        )
-        .await;
-
-        // Check for errors
-        results.0.context("Failed to apply commit")?;
-        results.1.context("Failed to index writes")?;
-        results.2.context("Failed to process blobs")?;
-
-        // Create commit operations
-        let ops = writes
-            .iter()
-            .filter_map(|w| match w {
-                PreparedWrite::Create(c) | PreparedWrite::Update(c) => {
-                    let uri = AtUri::from_str(&c.uri).ok()?;
-                    Some(CommitOp {
-                        action: CommitAction::Create,
-                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
-                        cid: Some(c.cid),
-                        prev: None,
-                    })
-                }
-                PreparedWrite::Delete(_) => None,
-            })
-            .collect();
-
-        Ok(CommitDataWithOps {
-            commit_data: commit,
-            ops,
-            prev_data: None,
-        })
-    }
-
-    /// Process writes to the repository
-    pub(crate) async fn process_writes(
-        &self,
-        writes: Vec<PreparedWrite>,
-        swap_commit_cid: Option<Cid>,
-    ) -> Result<CommitDataWithOps> {
-        // Check write limit
-        if writes.len() > 200 {
-            return Err(anyhow::anyhow!("Too many writes. Max: 200"));
-        }
-
-        // Format the commit
-        let commit = self.format_commit(writes.clone(), swap_commit_cid).await?;
-
-        // Check commit size limit (2MB)
-        if commit.commit_data.relevant_blocks.byte_size()? > 2_000_000 {
-            return Err(anyhow::anyhow!("Too many writes. Max event size: 2MB"));
-        }
-
-        // Apply the commit, index the writes, and process blobs in parallel
-        let results = futures::future::join3(
-            self.storage.apply_commit(commit.commit_data.clone(), None),
-            self.index_writes(&writes, &commit.commit_data.rev),
-            self.blob_transactor
-                .process_write_blobs(&commit.commit_data.rev, writes),
-        )
-        .await;
-
-        // Check for errors
-        results.0.context("Failed to apply commit")?;
-        results.1.context("Failed to index writes")?;
-        results.2.context("Failed to process blobs")?;
-
-        Ok(commit)
-    }
-
-    /// Format a commit for writes
-    pub(crate) async fn format_commit(
-        &self,
-        writes: Vec<PreparedWrite>,
-        swap_commit_cid: Option<Cid>,
-    ) -> Result<CommitDataWithOps> {
-        // Ensure we have a signing key
-        let signing_key = self
-            .signing_key
-            .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("No signing key available for write operations"))?;
-
-        // Get current root
-        let curr_root = self
-            .storage
-            .get_root_detailed()
-            .await
-            .context("Failed to get repository root")?;
-
-        // Check commit swap if requested
-        if let Some(swap) = swap_commit_cid {
-            if curr_root.cid != swap {
-                return Err(anyhow::anyhow!(
-                    "Bad commit swap: current={}, expected={}",
-                    curr_root.cid,
-                    swap
-                ));
-            }
-        }
-
-        // Cache the current revision for better performance
-        self.storage.cache_rev(&curr_root.rev).await?;
-
-        // Prepare collections for tracking changes
-        let mut new_record_cids = Vec::new();
-        let mut del_and_update_uris = Vec::new();
-        let mut commit_ops = Vec::new();
-
-        // Process each write to build operations and gather info
-        for write in &writes {
-            match write {
-                PreparedWrite::Create(w) => {
-                    new_record_cids.push(w.cid);
-                    let uri = AtUri::from_str(&w.uri)?;
-                    commit_ops.push(CommitOp {
-                        action: CommitAction::Create,
-                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
-                        cid: Some(w.cid),
-                        prev: None,
-                    });
-
-                    // Validate swap_cid conditions
-                    if w.swap_cid.is_some() && w.swap_cid != Some(None) {
-                        return Err(anyhow::anyhow!(
-                            "Bad record swap: there should be no current record for a create"
-                        ));
-                    }
-                }
-                PreparedWrite::Update(w) => {
-                    new_record_cids.push(w.cid);
-                    let uri = AtUri::from_str(&w.uri)?;
-                    del_and_update_uris.push(uri.clone());
-
-                    // Get the current record if it exists
-                    let record = self.record.get_record(&uri, None, true).await?;
-                    let curr_record = record.as_ref().map(|r| Cid::from_str(&r.cid).unwrap());
-
-                    commit_ops.push(CommitOp {
-                        action: CommitAction::Update,
-                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
-                        cid: Some(w.cid),
-                        prev: curr_record,
-                    });
-
-                    // Validate swap_cid conditions
-                    if w.swap_cid.is_some() {
-                        if w.swap_cid == Some(None) {
-                            return Err(anyhow::anyhow!(
-                                "Bad record swap: there should be a current record for an update"
-                            ));
-                        }
-
-                        if let Some(Some(swap)) = w.swap_cid {
-                            if curr_record.is_some() && curr_record != Some(swap) {
-                                return Err(anyhow::anyhow!(
-                                    "Bad record swap: current={:?}, expected={}",
-                                    curr_record,
-                                    swap
-                                ));
-                            }
-                        }
-                    }
-                }
-                PreparedWrite::Delete(w) => {
-                    let uri = AtUri::from_str(&w.uri)?;
-                    del_and_update_uris.push(uri.clone());
-
-                    // Get the current record if it exists
-                    let record = self.record.get_record(&uri, None, true).await?;
-                    let curr_record = record.as_ref().map(|r| Cid::from_str(&r.cid).unwrap());
-
-                    commit_ops.push(CommitOp {
-                        action: CommitAction::Delete,
-                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
-                        cid: None,
-                        prev: curr_record,
-                    });
-
-                    // Validate swap_cid conditions
-                    if w.swap_cid.is_some() {
-                        if w.swap_cid == Some(None) {
-                            return Err(anyhow::anyhow!(
-                                "Bad record swap: there should be a current record for a delete"
-                            ));
-                        }
-
-                        if let Some(Some(swap)) = w.swap_cid {
-                            if curr_record.is_some() && curr_record != Some(swap) {
-                                return Err(anyhow::anyhow!(
-                                    "Bad record swap: current={:?}, expected={}",
-                                    curr_record,
-                                    swap
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Load repository
-        let repo = Repo::load(&self.storage, curr_root.cid).await?;
-        let prev_data = repo.commit.data.clone();
-
-        // Convert writes to repo operations
-        let write_ops = writes
-            .iter()
-            .map(|w| write_to_op(w))
-            .collect::<Result<Vec<_>>>()?;
-
-        // Format the commit with the repository
-        let mut commit = repo.format_commit(write_ops, signing_key).await?;
-
-        // Find blocks that would be deleted but are referenced by another record
-        let dupe_record_cids = self
-            .get_duplicate_record_cids(&commit.removed_cids.to_list(), &del_and_update_uris)
-            .await?;
-
-        // Remove duplicates from removed_cids
-        for cid in &dupe_record_cids {
-            commit.removed_cids.delete(*cid);
-        }
-
-        // Find blocks that are relevant to ops but not included in diff
-        let new_record_blocks = commit.relevant_blocks.get_many(&new_record_cids)?;
-        if !new_record_blocks.missing.is_empty() {
-            let missing_blocks = self.storage.get_blocks(&new_record_blocks.missing).await?;
-            commit.relevant_blocks.add_map(missing_blocks.blocks)?;
-        }
-
-        Ok(CommitDataWithOps {
-            commit_data: commit,
-            ops: commit_ops,
-            prev_data: Some(prev_data),
-        })
-    }
-
-    /// Index writes to the database
-    pub(crate) async fn index_writes(&self, writes: &[PreparedWrite], rev: &str) -> Result<()> {
-        let timestamp = chrono::Utc::now().to_rfc3339();
-
-        for write in writes {
-            match write {
-                PreparedWrite::Create(w) => {
-                    let uri = AtUri::from_str(&w.uri)?;
-                    self.record_transactor
-                        .index_record(
-                            uri,
-                            w.cid,
-                            Some(&w.record),
-                            WriteOpAction::Create,
-                            rev,
-                            Some(timestamp.clone()),
-                        )
-                        .await?;
-                }
-                PreparedWrite::Update(w) => {
-                    let uri = AtUri::from_str(&w.uri)?;
-                    self.record_transactor
-                        .index_record(
-                            uri,
-                            w.cid,
-                            Some(&w.record),
-                            WriteOpAction::Update,
-                            rev,
-                            Some(timestamp.clone()),
-                        )
-                        .await?;
-                }
-                PreparedWrite::Delete(w) => {
-                    let uri = AtUri::from_str(&w.uri)?;
-                    self.record_transactor.delete_record(&uri).await?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Get record CIDs that are duplicated elsewhere in the repository
-    pub(crate) async fn get_duplicate_record_cids(
-        &self,
-        cids: &[Cid],
-        touched_uris: &[AtUri],
-    ) -> Result<Vec<Cid>> {
-        if touched_uris.is_empty() || cids.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        // Convert URIs to strings for the query
-        let uri_strings: Vec<String> = touched_uris.iter().map(|u| u.to_string()).collect();
-
-        // Convert CIDs to strings for the query
-        let cid_strings: Vec<String> = cids.iter().map(|c| c.to_string()).collect();
-
-        let did = self.did.clone();
-
-        // Query for records with these CIDs that aren't in the touched URIs
-        let duplicate_cids = self
-            .storage
-            .db
-            .run(move |conn| {
-                use rsky_pds::schema::pds::record::dsl::*;
-
-                record
-                    .filter(did.eq(&did))
-                    .filter(cid.eq_any(&cid_strings))
-                    .filter(uri.ne_all(&uri_strings))
-                    .select(cid)
-                    .load::<String>(conn)
-            })
-            .await?;
-
-        // Convert strings back to CIDs
-        let cids = duplicate_cids
-            .into_iter()
-            .filter_map(|c| Cid::from_str(&c).ok())
-            .collect();
-
-        Ok(cids)
-    }
-}

src/actor_store/sql_blob.rs

···
+use std::{path::PathBuf, str::FromStr as _};
+
+use anyhow::Result;
+use cidv10::Cid;
+use rsky_common::get_random_str;
+
+use crate::db::DatabaseConnection;
+
+/// Type for stream of blob data
+pub type BlobStream = Box<dyn std::io::Read + Send>;
+
+/// Placeholder implementation for blob store
+#[derive(Clone)]
+pub(crate) struct BlobStoreSql {
+    client: DatabaseConnection,
+    path: PathBuf,
+}
+
+impl BlobStoreSql {
+    pub fn new(did: String, cfg: &SdkConfig) -> Self {
+        // let client = aws_sdk_s3::Client::new(cfg);
+        // BlobStorePlaceholder {
+        //     client,
+        //     bucket: did,
+        // }
+        todo!();
+    }
+
+    pub fn creator(cfg: &SdkConfig) -> Box<dyn Fn(String) -> BlobStoreSql + '_> {
+        Box::new(move |did: String| BlobStoreSql::new(did, cfg))
+    }
+
+    fn gen_key(&self) -> String {
+        get_random_str()
+    }
+
+    fn get_tmp_path(&self, key: &String) -> String {
+        // format!("tmp/{0}/{1}", self.bucket, key)
+        todo!();
+    }
+
+    fn get_stored_path(&self, cid: Cid) -> String {
+        // format!("blocks/{0}/{1}", self.bucket, cid)
+        todo!();
+    }
+
+    fn get_quarantined_path(&self, cid: Cid) -> String {
+        // format!("quarantine/{0}/{1}", self.bucket, cid)
+        todo!();
+    }
+
+    pub async fn put_temp(&self, bytes: Vec<u8>) -> Result<String> {
+        let key = self.gen_key();
+        // let body = ByteStream::from(bytes);
+        // self.client
+        //     .put_object()
+        //     .body(body)
+        //     .bucket(&self.bucket)
+        //     .key(self.get_tmp_path(&key))
+        //     .acl(ObjectCannedAcl::PublicRead)
+        //     .send()
+        //     .await?;
+        // Ok(key)
+        todo!();
+    }
+
+    pub async fn make_permanent(&self, key: String, cid: Cid) -> Result<()> {
+        // let already_has = self.has_stored(cid).await?;
+        // if !already_has {
+        //     Ok(self
+        //         .move_object(MoveObject {
+        //             from: self.get_tmp_path(&key),
+        //             to: self.get_stored_path(cid),
+        //         })
+        //         .await?)
+        // } else {
+        //     // already saved, so we no-op & just delete the temp
+        //     Ok(self.delete_key(self.get_tmp_path(&key)).await?)
+        // }
+        todo!();
+    }
+
+    pub async fn put_permanent(&self, cid: Cid, bytes: Vec<u8>) -> Result<()> {
+        // let body = ByteStream::from(bytes);
+        // self.client
+        //     .put_object()
+        //     .body(body)
+        //     .bucket(&self.bucket)
+        //     .key(self.get_stored_path(cid))
+        //     .acl(ObjectCannedAcl::PublicRead)
+        //     .send()
+        //     .await?;
+        // Ok(())
+        todo!();
+    }
+
+    pub async fn quarantine(&self, cid: Cid) -> Result<()> {
+        // self.move_object(MoveObject {
+        //     from: self.get_stored_path(cid),
+        //     to: self.get_quarantined_path(cid),
+        // })
+        // .await
+        todo!();
+    }
+
+    pub async fn unquarantine(&self, cid: Cid) -> Result<()> {
+        // self.move_object(MoveObject {
+        //     from: self.get_quarantined_path(cid),
+        //     to: self.get_stored_path(cid),
+        // })
+        // .await
+        todo!();
+    }
+
+    async fn get_object(&self, cid: Cid) -> Result<ByteStream> {
+        // let res = self
+        //     .client
+        //     .get_object()
+        //     .bucket(&self.bucket)
+        //     .key(self.get_stored_path(cid))
+        //     .send()
+        //     .await;
+        // match res {
+        //     Ok(res) => Ok(res.body),
+        //     Err(SdkError::ServiceError(s)) => Err(anyhow::Error::new(s.into_err())),
+        //     Err(e) => Err(anyhow::Error::new(e.into_service_error())),
+        // }
+        todo!();
+    }
+
+    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())
+    }
+
+    pub async fn get_stream(&self, cid: Cid) -> Result<ByteStream> {
+        self.get_object(cid).await
+    }
+
+    pub async fn delete(&self, cid: String) -> Result<()> {
+        self.delete_key(self.get_stored_path(Cid::from_str(&cid)?))
+            .await
+    }
+
+    pub async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
+        let keys: Vec<String> = cids
+            .into_iter()
+            .map(|cid| self.get_stored_path(cid))
+            .collect();
+        self.delete_many_keys(keys).await
+    }
+
+    pub async fn has_stored(&self, cid: Cid) -> Result<bool> {
+        Ok(self.has_key(self.get_stored_path(cid)).await)
+    }
+
+    pub async fn has_temp(&self, key: String) -> Result<bool> {
+        Ok(self.has_key(self.get_tmp_path(&key)).await)
+    }
+
+    async fn has_key(&self, key: String) -> bool {
+        // let res = self
+        //     .client
+        //     .head_object()
+        //     .bucket(&self.bucket)
+        //     .key(key)
+        //     .send()
+        //     .await;
+        // res.is_ok()
+        todo!();
+    }
+
+    async fn delete_key(&self, key: String) -> Result<()> {
+        // self.client
+        //     .delete_object()
+        //     .bucket(&self.bucket)
+        //     .key(key)
+        //     .send()
+        //     .await?;
+        // Ok(())
+        todo!();
+    }
+
+    async fn delete_many_keys(&self, keys: Vec<String>) -> Result<()> {
+        // let objects: Vec<ObjectIdentifier> = keys
+        //     .into_iter()
+        //     .map(|key| Ok(ObjectIdentifier::builder().key(key).build()?))
+        //     .collect::<Result<Vec<ObjectIdentifier>>>()?;
+        // let deletes = Delete::builder().set_objects(Some(objects)).build()?;
+        // self.client
+        //     .delete_objects()
+        //     .bucket(&self.bucket)
+        //     .delete(deletes)
+        //     .send()
+        //     .await?;
+        // Ok(())
+        todo!();
+    }
+
+    async fn move_object(&self, keys: MoveObject) -> Result<()> {
+        // self.client
+        //     .copy_object()
+        //     .bucket(&self.bucket)
+        //     .copy_source(format!(
+        //         "{0}/{1}/{2}",
+        //         env_str("AWS_ENDPOINT_BUCKET").unwrap(),
+        //         self.bucket,
+        //         keys.from
+        //     ))
+        //     .key(keys.to)
+        //     .acl(ObjectCannedAcl::PublicRead)
+        //     .send()
+        //     .await?;
+        // self.client
+        //     .delete_object()
+        //     .bucket(&self.bucket)
+        //     .key(keys.from)
+        //     .send()
+        //     .await?;
+        // Ok(())
+        todo!();
+    }
+}

src/actor_store/sql_repo.rs

···
-use anyhow::{Context as _, Result};
-use atrium_repo::Cid;
-use atrium_repo::blockstore::{
-    AsyncBlockStoreRead, AsyncBlockStoreWrite, Error as BlockstoreError,
-};
+//! Based on https://github.com/blacksky-algorithms/rsky/blob/main/rsky-pds/src/actor_store/repo/sql_repo.rs
+//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
+//!
+//! Modified for SQLite backend
+
+use anyhow::Result;
+use cidv10::Cid;
+use diesel::dsl::sql;
 use diesel::prelude::*;
-use diesel::r2d2::{self, ConnectionManager};
-use diesel::sqlite::SqliteConnection;
+use diesel::sql_types::{Bool, Text};
+use diesel::*;
 use futures::{StreamExt, TryStreamExt, stream};
-use rsky_pds::models::{RepoBlock, RepoRoot};
+use rsky_pds::models;
+use rsky_pds::models::RepoBlock;
 use rsky_repo::block_map::{BlockMap, BlocksAndMissing};
 use rsky_repo::car::blocks_to_car_file;
 use rsky_repo::cid_set::CidSet;
···
 use rsky_repo::storage::readable_blockstore::ReadableBlockstore;
 use rsky_repo::storage::types::RepoStorage;
 use rsky_repo::types::CommitData;
-use sha2::{Digest, Sha256};
-use std::future::Future;
 use std::pin::Pin;
 use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::actor_store::db::ActorDb;
+use super::ActorDb;
 
 #[derive(Clone, Debug)]
-pub struct SqlRepoStorage {
-    /// In-memory cache for blocks
+pub struct SqlRepoReader {
     pub cache: Arc<RwLock<BlockMap>>,
-    /// Database connection
     pub db: ActorDb,
-    /// DID of the actor
-    pub did: String,
-    /// Current timestamp
+    pub root: Option<Cid>,
+    pub rev: Option<String>,
     pub now: String,
-}
-
-impl SqlRepoStorage {
-    /// Create a new SQL repository storage
-    pub fn new(did: String, db: ActorDb, now: Option<String>) -> Self {
-        let now = now.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
-
-        Self {
-            cache: Arc::new(RwLock::new(BlockMap::new())),
-            db,
-            did,
-            now,
-        }
-    }
-
-    /// Get the CAR stream for the repository
-    pub async fn get_car_stream(&self, since: Option<String>) -> Result<Vec<u8>> {
-        match self.get_root().await {
-            None => Err(anyhow::Error::new(RepoRootNotFoundError)),
-            Some(root) => {
-                let mut car = BlockMap::new();
-                let mut cursor: Option<CidAndRev> = None;
-
-                loop {
-                    let blocks = self.get_block_range(&since, &cursor).await?;
-                    if blocks.is_empty() {
-                        break;
-                    }
-
-                    // Add blocks to car
-                    for block in &blocks {
-                        car.set(Cid::from_str(&block.cid)?, block.content.clone());
-                    }
-
-                    if let Some(last_block) = blocks.last() {
-                        cursor = Some(CidAndRev {
-                            cid: Cid::from_str(&last_block.cid)?,
-                            rev: last_block.repoRev.clone(),
-                        });
-                    } else {
-                        break;
-                    }
-                }
-
-                blocks_to_car_file(Some(&root), car).await
-            }
-        }
-    }
-
-    /// Get a range of blocks from the database
-    pub async fn get_block_range(
-        &self,
-        since: &Option<String>,
-        cursor: &Option<CidAndRev>,
-    ) -> Result<Vec<RepoBlock>> {
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                let mut query = repo_block.filter(did.eq(&did)).limit(500).into_boxed();
-
-                if let Some(c) = cursor {
-                    query = query.filter(
-                        repoRev
-                            .lt(&c.rev)
-                            .or(repoRev.eq(&c.rev).and(cid.lt(&c.cid.to_string()))),
-                    );
-                }
-
-                if let Some(s) = since {
-                    query = query.filter(repoRev.gt(s));
-                }
-
-                query
-                    .order((repoRev.desc(), cid.desc()))
-                    .load::<RepoBlock>(conn)
-            })
-            .await
-    }
-
-    /// Count total blocks for this repository
-    pub async fn count_blocks(&self) -> Result<i64> {
-        let did = self.did.clone();
-
-        self.db
-            .run(move |conn| {
-                use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                repo_block.filter(did.eq(&did)).count().get_result(conn)
-            })
-            .await
-    }
-
-    /// Proactively cache blocks from a specific revision
-    pub async fn cache_rev(&mut self, rev: &str) -> Result<()> {
-        let did = self.did.clone();
-        let rev_string = rev.to_string();
-
-        let blocks = self
-            .db
-            .run(move |conn| {
-                use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                repo_block
-                    .filter(did.eq(&did))
-                    .filter(repoRev.eq(&rev_string))
-                    .select((cid, content))
-                    .limit(15)
-                    .load::<(String, Vec<u8>)>(conn)
-            })
-            .await?;
-
-        let mut cache_guard = self.cache.write().await;
-        for (cid_str, content) in blocks {
-            let cid = Cid::from_str(&cid_str)?;
-            cache_guard.set(cid, content);
-        }
-
-        Ok(())
-    }
-
-    /// Delete multiple blocks by their CIDs
-    pub async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
-        if cids.is_empty() {
-            return Ok(());
-        }
-
-        let did = self.did.clone();
-        let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();
-
-        // Process in chunks to avoid too many parameters
-        for chunk in cid_strings.chunks(100) {
-            let chunk_vec = chunk.to_vec();
-            let did_clone = did.clone();
-
-            self.db
-                .run(move |conn| {
-                    use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                    diesel::delete(repo_block)
-                        .filter(did.eq(&did_clone))
-                        .filter(cid.eq_any(&chunk_vec))
-                        .execute(conn)
-                })
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    /// Get the detailed root information
-    pub async fn get_root_detailed(&self) -> Result<CidAndRev> {
-        let did = self.did.clone();
-
-        let root = self
-            .db
-            .run(move |conn| {
-                use rsky_pds::schema::pds::repo_root::dsl::*;
-
-                repo_root
-                    .filter(did.eq(&did))
-                    .first::<RepoRoot>(conn)
-                    .optional()
-            })
-            .await?;
-
-        match root {
-            Some(r) => Ok(CidAndRev {
-                cid: Cid::from_str(&r.cid)?,
-                rev: r.rev,
-            }),
-            None => Err(anyhow::Error::new(RepoRootNotFoundError)),
-        }
-    }
+    pub did: String,
 }
 
-impl ReadableBlockstore for SqlRepoStorage {
+impl ReadableBlockstore for SqlRepoReader {
     fn get_bytes<'a>(
         &'a self,
         cid: &'a Cid,
     ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'a>> {
-        let did = self.did.clone();
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
         let cid = cid.clone();
 
         Box::pin(async move {
-            // Check cache first
-            {
+            use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
+            let cached = {
                 let cache_guard = self.cache.read().await;
-                if let Some(cached) = cache_guard.get(cid) {
-                    return Ok(Some(cached.clone()));
-                }
+                cache_guard.get(cid).map(|v| v.clone())
+            };
+            if let Some(cached_result) = cached {
+                return Ok(Some(cached_result.clone()));
             }
 
-            // Not in cache, query database
-            let cid_str = cid.to_string();
-            let result = self
-                .db
+            let found: Option<Vec<u8>> = db
                 .run(move |conn| {
-                    use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                    repo_block
-                        .filter(did.eq(&did))
-                        .filter(cid.eq(&cid_str))
-                        .select(content)
-                        .first::<Vec<u8>>(conn)
+                    RepoBlockSchema::repo_block
+                        .filter(RepoBlockSchema::cid.eq(cid.to_string()))
+                        .filter(RepoBlockSchema::did.eq(did))
+                        .select(RepoBlockSchema::content)
+                        .first(conn)
                         .optional()
                 })
                 .await?;
-
-            // Update cache if found
-            if let Some(content) = &result {
-                let mut cache_guard = self.cache.write().await;
-                cache_guard.set(cid, content.clone());
+            match found {
+                None => Ok(None),
+                Some(result) => {
+                    {
+                        let mut cache_guard = self.cache.write().await;
+                        cache_guard.set(cid, result.clone());
+                    }
+                    Ok(Some(result))
+                }
             }
-
-            Ok(result)
         })
     }
 
···
         cid: Cid,
     ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + Sync + 'a>> {
         Box::pin(async move {
-            let bytes = self.get_bytes(&cid).await?;
-            Ok(bytes.is_some())
+            let got = <Self as ReadableBlockstore>::get_bytes(self, &cid).await?;
+            Ok(got.is_some())
         })
     }
 
···
         &'a self,
         cids: Vec<Cid>,
     ) -> Pin<Box<dyn Future<Output = Result<BlocksAndMissing>> + Send + Sync + 'a>> {
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+
         Box::pin(async move {
-            // Check cache first
+            use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
             let cached = {
                 let mut cache_guard = self.cache.write().await;
-                cache_guard.get_many(cids.clone())?
+                cache_guard.get_many(cids)?
             };
 
             if cached.missing.is_empty() {
                 return Ok(cached);
             }
-
-            // Prepare data structures for missing blocks
             let missing = CidSet::new(Some(cached.missing.clone()));
             let missing_strings: Vec<String> =
-                cached.missing.iter().map(|c| c.to_string()).collect();
-            let did = self.did.clone();
+                cached.missing.into_iter().map(|c| c.to_string()).collect();
+
+            let blocks = Arc::new(tokio::sync::Mutex::new(BlockMap::new()));
+            let missing_set = Arc::new(tokio::sync::Mutex::new(missing));
+
+            let _: Vec<_> = stream::iter(missing_strings.chunks(500))
+                .then(|batch| {
+                    let this_db = db.clone();
+                    let this_did = did.clone();
+                    let blocks = Arc::clone(&blocks);
+                    let missing = Arc::clone(&missing_set);
+                    let batch = batch.to_vec(); // Convert to owned Vec
 
-            // Create block map for results
-            let mut blocks = BlockMap::new();
-            let mut missing_set = CidSet::new(Some(cached.missing.clone()));
+                    async move {
+                        // Database query
+                        let rows: Vec<(String, Vec<u8>)> = this_db
+                            .run(move |conn| {
+                                RepoBlockSchema::repo_block
+                                    .filter(RepoBlockSchema::cid.eq_any(batch))
+                                    .filter(RepoBlockSchema::did.eq(this_did))
+                                    .select((RepoBlockSchema::cid, RepoBlockSchema::content))
+                                    .load(conn)
+                            })
+                            .await?;
 
-            // Query database in chunks
-            for chunk in missing_strings.chunks(100) {
-                let chunk_vec = chunk.to_vec();
-                let did_clone = did.clone();
+                        // Process rows with locked access
+                        let mut blocks = blocks.lock().await;
+                        let mut missing = missing.lock().await;
 
-                let rows = self
-                    .db
-                    .run(move |conn| {
-                        use rsky_pds::schema::pds::repo_block::dsl::*;
+                        for row in rows {
+                            let cid = Cid::from_str(&row.0)?; // Proper error handling
+                            blocks.set(cid, row.1);
+                            missing.delete(cid);
+                        }
 
-                        repo_block
-                            .filter(did.eq(&did_clone))
-                            .filter(cid.eq_any(&chunk_vec))
-                            .select((cid, content))
-                            .load::<(String, Vec<u8>)>(conn)
-                    })
-                    .await?;
+                        Ok::<(), anyhow::Error>(())
+                    }
+                })
+                .try_collect()
+                .await?;
 
-                // Process results
-                for (cid_str, content) in rows {
-                    let block_cid = Cid::from_str(&cid_str)?;
-                    blocks.set(block_cid, content.clone());
-                    missing_set.delete(block_cid);
+            // Extract values from synchronization primitives
+            let mut blocks = Arc::try_unwrap(blocks)
+                .expect("Arc still has owners")
+                .into_inner();
+            let missing = Arc::try_unwrap(missing_set)
+                .expect("Arc still has owners")
+                .into_inner();
 
-                    // Update cache
-                    let mut cache_guard = self.cache.write().await;
-                    cache_guard.set(block_cid, content);
-                }
+            {
+                let mut cache_guard = self.cache.write().await;
+                cache_guard.add_map(blocks.clone())?;
             }
 
-            // Combine with cached blocks
             blocks.add_map(cached.blocks)?;
 
             Ok(BlocksAndMissing {
                 blocks,
-                missing: missing_set.to_list(),
+                missing: missing.to_list(),
             })
         })
     }
 }
 
-impl RepoStorage for SqlRepoStorage {
+impl RepoStorage for SqlRepoReader {
     fn get_root<'a>(&'a self) -> Pin<Box<dyn Future<Output = Option<Cid>> + Send + Sync + 'a>> {
         Box::pin(async move {
             match self.get_root_detailed().await {
···
         bytes: Vec<u8>,
         rev: String,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
-        let did = self.did.clone();
-        let bytes_clone = bytes.clone();
-
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        let bytes_cloned = bytes.clone();
         Box::pin(async move {
-            let cid_str = cid.to_string();
-            let size = bytes.len() as i32;
+            use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-            self.db
-                .run(move |conn| {
-                    use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                    diesel::insert_into(repo_block)
-                        .values((
-                            did.eq(&did),
-                            cid.eq(&cid_str),
-                            repoRev.eq(&rev),
-                            size.eq(size),
-                            content.eq(&bytes),
-                        ))
-                        .on_conflict_do_nothing()
-                        .execute(conn)
-                })
-                .await?;
-
-            // Update cache
-            let mut cache_guard = self.cache.write().await;
-            cache_guard.set(cid, bytes_clone);
-
+            db.run(move |conn| {
+                insert_into(RepoBlockSchema::repo_block)
+                    .values((
+                        RepoBlockSchema::did.eq(did),
+                        RepoBlockSchema::cid.eq(cid.to_string()),
+                        RepoBlockSchema::repoRev.eq(rev),
+                        RepoBlockSchema::size.eq(bytes.len() as i32),
+                        RepoBlockSchema::content.eq(bytes),
+                    ))
+                    .execute(conn)
+            })
+            .await?;
+            {
+                let mut cache_guard = self.cache.write().await;
+                cache_guard.set(cid, bytes_cloned);
+            }
             Ok(())
         })
     }
···
         to_put: BlockMap,
         rev: String,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
-        let did = self.did.clone();
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
 
         Box::pin(async move {
-            if to_put.size() == 0 {
-                return Ok(());
-            }
+            use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-            // Prepare blocks for insertion
-            let blocks: Vec<(String, String, String, i32, Vec<u8>)> = to_put
+            let blocks: Vec<RepoBlock> = to_put
                 .map
                 .iter()
-                .map(|(cid, bytes)| {
-                    (
-                        did.clone(),
-                        cid.to_string(),
-                        rev.clone(),
-                        bytes.0.len() as i32,
-                        bytes.0.clone(),
-                    )
+                .map(|(cid, bytes)| RepoBlock {
+                    cid: cid.to_string(),
+                    did: did.clone(),
+                    repo_rev: rev.clone(),
+                    size: bytes.0.len() as i32,
+                    content: bytes.0.clone(),
                 })
                 .collect();
 
-            // Process in chunks
-            for chunk in blocks.chunks(50) {
-                let chunk_vec = chunk.to_vec();
+            let chunks: Vec<Vec<RepoBlock>> =
+                blocks.chunks(50).map(|chunk| chunk.to_vec()).collect();
 
-                self.db
-                    .run(move |conn| {
-                        use rsky_pds::schema::pds::repo_block::dsl::*;
-
-                        let values: Vec<_> = chunk_vec
-                            .iter()
-                            .map(|(did_val, cid_val, rev_val, size_val, content_val)| {
-                                (
-                                    did.eq(did_val),
-                                    cid.eq(cid_val),
-                                    repoRev.eq(rev_val),
-                                    size.eq(*size_val),
-                                    content.eq(content_val),
-                                )
-                            })
-                            .collect();
-
-                        diesel::insert_into(repo_block)
-                            .values(&values)
-                            .on_conflict_do_nothing()
-                            .execute(conn)
-                    })
-                    .await?;
-            }
-
-            // Update cache with all blocks
-            {
-                let mut cache_guard = self.cache.write().await;
-                for (cid, bytes) in &to_put.map {
-                    cache_guard.set(*cid, bytes.0.clone());
-                }
-            }
+            let _: Vec<_> = stream::iter(chunks)
+                .then(|batch| {
+                    let db = db.clone();
+                    async move {
+                        db.run(move |conn| {
+                            insert_into(RepoBlockSchema::repo_block)
+                                .values(batch)
+                                .on_conflict_do_nothing()
+                                .execute(conn)
+                                .map(|_| ())
+                        })
+                        .await
+                        .map_err(anyhow::Error::from)
+                    }
+                })
+                .collect::<Vec<_>>()
+                .await
+                .into_iter()
+                .collect::<Result<Vec<()>>>()?;
 
             Ok(())
         })
     }
-
     fn update_root<'a>(
         &'a self,
         cid: Cid,
         rev: String,
         is_create: Option<bool>,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
-        let did = self.did.clone();
-        let now = self.now.clone();
-        let is_create = is_create.unwrap_or(false);
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        let now: String = self.now.clone();
 
         Box::pin(async move {
-            let cid_str = cid.to_string();
+            use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema;
 
+            let is_create = is_create.unwrap_or(false);
             if is_create {
-                // Insert new root
-                self.db
-                    .run(move |conn| {
-                        use rsky_pds::schema::pds::repo_root::dsl::*;
-
-                        diesel::insert_into(repo_root)
-                            .values((
-                                did.eq(&did),
-                                cid.eq(&cid_str),
-                                rev.eq(&rev),
-                                indexedAt.eq(&now),
-                            ))
-                            .execute(conn)
-                    })
-                    .await?;
+                db.run(move |conn| {
+                    insert_into(RepoRootSchema::repo_root)
+                        .values((
+                            RepoRootSchema::did.eq(did),
+                            RepoRootSchema::cid.eq(cid.to_string()),
+                            RepoRootSchema::rev.eq(rev),
+                            RepoRootSchema::indexedAt.eq(now),
+                        ))
+                        .execute(conn)
+                })
+                .await?;
             } else {
-                // Update existing root
-                self.db
-                    .run(move |conn| {
-                        use rsky_pds::schema::pds::repo_root::dsl::*;
-
-                        diesel::update(repo_root)
-                            .filter(did.eq(&did))
-                            .set((cid.eq(&cid_str), rev.eq(&rev), indexedAt.eq(&now)))
-                            .execute(conn)
-                    })
-                    .await?;
+                db.run(move |conn| {
+                    update(RepoRootSchema::repo_root)
+                        .filter(RepoRootSchema::did.eq(did))
+                        .set((
+                            RepoRootSchema::cid.eq(cid.to_string()),
+                            RepoRootSchema::rev.eq(rev),
+                            RepoRootSchema::indexedAt.eq(now),
+                        ))
+                        .execute(conn)
+                })
+                .await?;
             }
-
             Ok(())
         })
     }
···
         is_create: Option<bool>,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
         Box::pin(async move {
-            // Apply commit in three steps
             self.update_root(commit.cid, commit.rev.clone(), is_create)
                 .await?;
             self.put_many(commit.new_blocks, commit.rev).await?;
             self.delete_many(commit.removed_cids.to_list()).await?;
-
             Ok(())
         })
     }
 }
 
-#[async_trait::async_trait]
-impl AsyncBlockStoreRead for SqlRepoStorage {
-    async fn read_block(&mut self, cid: Cid) -> Result<Vec<u8>, BlockstoreError> {
-        let bytes = self
-            .get_bytes(&cid)
-            .await
-            .map_err(|e| BlockstoreError::Other(Box::new(e)))?
-            .ok_or(BlockstoreError::CidNotFound)?;
+// Basically handles getting ipld blocks from db
+impl SqlRepoReader {
+    pub fn new(did: String, now: Option<String>, db: ActorDb) -> Self {
+        let now = now.unwrap_or_else(rsky_common::now);
+        SqlRepoReader {
+            cache: Arc::new(RwLock::new(BlockMap::new())),
+            root: None,
+            rev: None,
+            db,
+            now,
+            did,
+        }
+    }
 
-        Ok(bytes)
+    pub async fn get_car_stream(&self, since: Option<String>) -> Result<Vec<u8>> {
+        match self.get_root().await {
+            None => Err(anyhow::Error::new(RepoRootNotFoundError)),
+            Some(root) => {
+                let mut car = BlockMap::new();
+                let mut cursor: Option<CidAndRev> = None;
+                let mut write_rows = |rows: Vec<RepoBlock>| -> Result<()> {
+                    for row in rows {
+                        car.set(Cid::from_str(&row.cid)?, row.content);
+                    }
+                    Ok(())
+                };
+                loop {
+                    let res = self.get_block_range(&since, &cursor).await?;
+                    write_rows(res.clone())?;
+                    if let Some(last_row) = res.last() {
+                        cursor = Some(CidAndRev {
+                            cid: Cid::from_str(&last_row.cid)?,
+                            rev: last_row.repo_rev.clone(),
+                        });
+                    } else {
+                        break;
+                    }
+                }
+                blocks_to_car_file(Some(&root), car).await
+            }
+        }
     }
 
-    fn read_block_into(
-        &mut self,
-        cid: Cid,
-        contents: &mut Vec<u8>,
-    ) -> impl Future<Output = Result<(), BlockstoreError>> + Send {
-        async move {
-            let bytes = self.read_block(cid).await?;
-            contents.clear();
-            contents.extend_from_slice(&bytes);
-            Ok(())
-        }
+    pub async fn get_block_range(
+        &self,
+        since: &Option<String>,
+        cursor: &Option<CidAndRev>,
+    ) -> Result<Vec<RepoBlock>> {
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        let since = since.clone();
+        let cursor = cursor.clone();
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
+
+        Ok(db
+            .run(move |conn| {
+                let mut builder = RepoBlockSchema::repo_block
+                    .select(RepoBlock::as_select())
+                    .order((RepoBlockSchema::repoRev.desc(), RepoBlockSchema::cid.desc()))
+                    .filter(RepoBlockSchema::did.eq(did))
+                    .limit(500)
+                    .into_boxed();
+
+                if let Some(cursor) = cursor {
+                    // use this syntax to ensure we hit the index
+                    builder = builder.filter(
+                        sql::<Bool>("((")
+                            .bind(RepoBlockSchema::repoRev)
+                            .sql(", ")
+                            .bind(RepoBlockSchema::cid)
+                            .sql(") < (")
+                            .bind::<Text, _>(cursor.rev.clone())
+                            .sql(", ")
+                            .bind::<Text, _>(cursor.cid.to_string())
+                            .sql("))"),
+                    );
+                }
+                if let Some(since) = since {
+                    builder = builder.filter(RepoBlockSchema::repoRev.gt(since));
+                }
+                builder.load(conn)
+            })
+            .await?)
     }
-}
 
-#[async_trait::async_trait]
-impl AsyncBlockStoreWrite for SqlRepoStorage {
-    fn write_block(
-        &mut self,
-        codec: u64,
-        hash: u64,
-        contents: &[u8],
-    ) -> impl Future<Output = Result<Cid, BlockstoreError>> + Send {
-        let contents = contents.to_vec();
-        let rev = self.now.clone();
+    pub async fn count_blocks(&self) -> Result<i64> {
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        async move {
-            // Calculate digest based on hash algorithm
-            let digest = match hash {
-                atrium_repo::blockstore::SHA2_256 => sha2::Sha256::digest(&contents),
-                _ => return Err(BlockstoreError::UnsupportedHash(hash)),
-            };
+        let res = db
+            .run(move |conn| {
+                RepoBlockSchema::repo_block
+                    .filter(RepoBlockSchema::did.eq(did))
+                    .count()
+                    .get_result(conn)
+            })
+            .await?;
+        Ok(res)
+    }
 
-            // Create multihash
-            let multihash = atrium_repo::Multihash::wrap(hash, &digest)
-                .map_err(|_| BlockstoreError::UnsupportedHash(hash))?;
+    // Transactors
+    // -------------------
 
-            // Create CID
-            let cid = Cid::new_v1(codec, multihash);
+    /// Proactively cache all blocks from a particular commit (to prevent multiple roundtrips)
+    pub async fn cache_rev(&mut self, rev: String) -> Result<()> {
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-            // Store the block
-            self.put_block(cid, contents, rev)
-                .await
-                .map_err(|e| BlockstoreError::Other(Box::new(e)))?;
+        let res: Vec<(String, Vec<u8>)> = db
+            .run(move |conn| {
+                RepoBlockSchema::repo_block
+                    .filter(RepoBlockSchema::did.eq(did))
+                    .filter(RepoBlockSchema::repoRev.eq(rev))
+                    .select((RepoBlockSchema::cid, RepoBlockSchema::content))
+                    .limit(15)
+                    .get_results::<(String, Vec<u8>)>(conn)
+            })
+            .await?;
+        for row in res {
+            let mut cache_guard = self.cache.write().await;
+            cache_guard.set(Cid::from_str(&row.0)?, row.1)
+        }
+        Ok(())
+    }
 
-            Ok(cid)
+    pub async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
+        if cids.is_empty() {
+            return Ok(());
         }
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
+
+        let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();
+        db.run(move |conn| {
+            delete(RepoBlockSchema::repo_block)
+                .filter(RepoBlockSchema::did.eq(did))
+                .filter(RepoBlockSchema::cid.eq_any(cid_strings))
+                .execute(conn)
+        })
+        .await?;
+        Ok(())
+    }
+
+    pub async fn get_root_detailed(&self) -> Result<CidAndRev> {
+        let did: String = self.did.clone();
+        let db: ActorDb = self.db.clone();
+        use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema;
+
+        let res = db
+            .run(move |conn| {
+                RepoRootSchema::repo_root
+                    .filter(RepoRootSchema::did.eq(did))
+                    .select(models::RepoRoot::as_select())
+                    .first(conn)
+            })
+            .await?;
+
+        Ok(CidAndRev {
+            cid: Cid::from_str(&res.cid)?,
+            rev: res.rev,
+        })
     }
 }

src/db/mod.rs

···
 use anyhow::{Context, Result};
 use diesel::connection::SimpleConnection;
-use diesel::prelude::*;
-use diesel::r2d2::{self, ConnectionManager, Pool, PooledConnection};
-use diesel::sqlite::{Sqlite, SqliteConnection};
+use diesel::r2d2::{ConnectionManager, Pool, PooledConnection};
+use diesel::sqlite::Sqlite;
+use diesel::*;
 use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations};
 use std::path::Path;
-use std::sync::Arc;
 use std::time::Duration;
 
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations");
···
         let manager = ConnectionManager::<SqliteConnection>::new(database_url);
 
         // Create the connection pool with SQLite-specific configurations
-        let pool = r2d2::Pool::builder()
+        let pool = Pool::builder()
             .max_size(10)
             .connection_timeout(Duration::from_secs(30))
             .test_on_check_out(true)
···
 
         Err(anyhow::anyhow!(
             "Max retries exceeded: {}",
-            last_error.unwrap_or_else(|| diesel::result::Error::RollbackTransaction)
+            last_error.unwrap_or_else(|| result::Error::RollbackTransaction)
         ))
     }
 
···
         T: Send + 'static,
     {
         self.run(|conn| {
-            conn.transaction(|tx| f(tx).map_err(|e| diesel::result::Error::RollbackTransaction))
+            conn.transaction(|tx| f(tx).map_err(|e| result::Error::RollbackTransaction))
         })
         .await
     }
···
     /// Run a transaction with no retry logic
     pub async fn transaction_no_retry<T, F>(&self, f: F) -> Result<T>
     where
-        F: FnOnce(&mut SqliteConnection) -> std::result::Result<T, diesel::result::Error> + Send,
+        F: FnOnce(&mut SqliteConnection) -> std::result::Result<T, result::Error> + Send,
         T: Send + 'static,
     {
         let mut conn = self