prototype deadpool_diesel connection pooling

Cargo.lock

···
  "clap",
  "clap-verbosity-flag",
  "constcat",
+ "deadpool-diesel",
  "diesel",
  "diesel_migrations",
  "dotenvy",
···
 dependencies = [
  "data-encoding",
  "syn 2.0.101",
+]
+
+[[package]]
+name = "deadpool"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ed5957ff93768adf7a65ab167a17835c3d2c3c50d084fe305174c112f468e2f"
+dependencies = [
+ "deadpool-runtime",
+ "num_cpus",
+ "serde",
+ "tokio",
+]
+
+[[package]]
+name = "deadpool-diesel"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "590573e9e29c5190a5ff782136f871e6e652e35d598a349888e028693601adf1"
+dependencies = [
+ "deadpool",
+ "deadpool-sync",
+ "diesel",
+]
+
+[[package]]
+name = "deadpool-runtime"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "deadpool-sync"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524bc3df0d57e98ecd022e21ba31166c2625e7d3e5bcc4510efaeeab4abcab04"
+dependencies = [
+ "deadpool-runtime",
+ "tracing",
 ]
 
 [[package]]

Cargo.toml

···
 lazy_static = "1.5.0"
 secp256k1 = "0.28.2"
 dotenvy = "0.15.7"
+deadpool-diesel = { version = "0.6.1", features = ["serde", "sqlite", "tracing"] }
 [dependencies.rocket_sync_db_pools]
 version = "=0.1.0"
 features = ["diesel_sqlite_pool"]

src/account_manager/mod.rs

···
 
 #[derive(Clone, Debug)]
 pub struct AccountManager {
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
 }
 
-pub type AccountManagerCreator = Box<dyn Fn(Arc<DbConn>) -> AccountManager + Send + Sync>;
+pub type AccountManagerCreator =
+    Box<dyn Fn(deadpool_diesel::Connection<SqliteConnection>) -> AccountManager + Send + Sync>;
 
 impl AccountManager {
-    pub fn new(db: Arc<DbConn>) -> Self {
+    pub fn new(db: deadpool_diesel::Connection<SqliteConnection>) -> Self {
         Self { db }
     }
 
     pub fn creator() -> AccountManagerCreator {
-        Box::new(move |db: Arc<DbConn>| -> AccountManager { AccountManager::new(db) })
+        Box::new(
+            move |db: deadpool_diesel::Connection<SqliteConnection>| -> AccountManager {
+                AccountManager::new(db)
+            },
+        )
     }
 
     pub async fn get_account(

src/actor_store/blob.rs

···
 use rsky_repo::error::BlobError;
 use rsky_repo::types::{PreparedBlobRef, PreparedWrite};
 use std::str::FromStr as _;
-use std::sync::Arc;
 
 use super::sql_blob::{BlobStoreSql, ByteStream};
-use crate::db::DbConn;
 
 pub struct GetBlobOutput {
     pub size: i32,
···
     /// DID of the actor
     pub did: String,
     /// Database connection
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
 }
 
 impl BlobReader {
     /// Create a new blob reader
-    pub fn new(blobstore: BlobStoreSql, db: Arc<DbConn>) -> Self {
+    pub fn new(blobstore: BlobStoreSql, db: deadpool_diesel::Connection<SqliteConnection>) -> Self {
         BlobReader {
             did: blobstore.did.clone(),
             blobstore,
···
         let did = self.did.clone();
         let found = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 BlobSchema::blob
                     .filter(BlobSchema::did.eq(did))
                     .filter(BlobSchema::cid.eq(cid.to_string()))
···
                     .first(conn)
                     .optional()
             })
-            .await?;
+            .await
+            .expect("Failed to get blob metadata")?;
 
         match found {
             None => bail!("Blob not found"),
···
         let did = self.did.clone();
         let res = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let results = RecordBlobSchema::record_blob
                     .filter(RecordBlobSchema::blobCid.eq(cid.to_string()))
                     .filter(RecordBlobSchema::did.eq(did))
···
                     .get_results(conn)?;
                 Ok::<_, result::Error>(results.into_iter().map(|row| row.record_uri))
             })
-            .await?
+            .await
+            .expect("Failed to get records for blob")?
             .collect::<Vec<String>>();
 
         Ok(res)
···
         use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
         let did = self.did.clone();
-        self.db.run(move |conn| {
+        self.db.interact(move |conn| {
             let BlobMetadata {
                 temp_key,
                 size,
···
                 .execute(conn)?;
 
             Ok(BlobRef::new(cid, mime_type, size, None))
-        }).await
+        }).await.expect("Failed to track untethered blob")
     }
 
     /// Process blobs associated with writes
···
         let uris_clone = uris.clone();
         let deleted_repo_blobs: Vec<models::RecordBlob> = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 RecordBlobSchema::record_blob
                     .filter(RecordBlobSchema::recordUri.eq_any(&uris_clone))
                     .filter(RecordBlobSchema::did.eq(&did))
                     .load::<models::RecordBlob>(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to get deleted repo blobs")?;
 
         if deleted_repo_blobs.is_empty() {
             return Ok(());
···
         // Now perform the delete
         let uris_clone = uris.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 delete(RecordBlobSchema::record_blob)
                     .filter(RecordBlobSchema::recordUri.eq_any(uris_clone))
                     .execute(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to delete repo blobs")?;
 
         // Extract blob cids from the deleted records
         let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs
···
         let did_clone = self.did.clone();
         let duplicated_cids: Vec<String> = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 RecordBlobSchema::record_blob
                     .filter(RecordBlobSchema::blobCid.eq_any(cids_clone))
                     .filter(RecordBlobSchema::did.eq(did_clone))
                     .select(RecordBlobSchema::blobCid)
                     .load::<String>(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to get duplicated cids")?;
 
         // Extract new blob cids from writes (creates and updates)
         let new_blob_cids: Vec<String> = writes
···
         let cids = cids_to_delete.clone();
         let did_clone = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 delete(BlobSchema::blob)
                     .filter(BlobSchema::cid.eq_any(cids))
                     .filter(BlobSchema::did.eq(did_clone))
                     .execute(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to delete blobs")?;
 
         // Delete from blob storage
         // Ideally we'd use a background queue here, but for now:
···
 
         let found = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 BlobSchema::blob
                     .filter(
                         BlobSchema::cid
···
                     .first(conn)
                     .optional()
             })
-            .await?;
+            .await
+            .expect("Failed to verify blob")?;
 
         if let Some(found) = found {
             verify_blob(&blob, &found).await?;
···
                     .await?;
             }
             self.db
-                .run(move |conn| {
+                .interact(move |conn| {
                     update(BlobSchema::blob)
                         .filter(BlobSchema::tempKey.eq(found.temp_key))
                         .set(BlobSchema::tempKey.eq::<Option<String>>(None))
                         .execute(conn)
                 })
-                .await?;
+                .await
+                .expect("Failed to update blob")?;
             Ok(())
         } else {
             bail!("Could not find blob: {:?}", blob.cid.to_string())
···
         let did = self.did.clone();
 
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 insert_into(RecordBlobSchema::record_blob)
                     .values((
                         RecordBlobSchema::blobCid.eq(cid),
···
                     .on_conflict_do_nothing()
                     .execute(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to associate blob")?;
 
         Ok(())
     }
···
 
         let did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let res = BlobSchema::blob
                     .filter(BlobSchema::did.eq(&did))
                     .count()
···
                 Ok(res)
             })
             .await
+            .expect("Failed to count blobs")
     }
 
     /// Count blobs associated with records
···
 
         let did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let res: i64 = RecordBlobSchema::record_blob
                     .filter(RecordBlobSchema::did.eq(&did))
                     .select(count_distinct(RecordBlobSchema::blobCid))
···
                 Ok(res)
             })
             .await
+            .expect("Failed to count record blobs")
     }
 
     /// List blobs that are referenced but missing
···
 
         let did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let ListMissingBlobsOpts { cursor, limit } = opts;
 
                 if limit > 1000 {
···
                 Ok(result)
             })
             .await
+            .expect("Failed to list missing blobs")
     }
 
     /// List all blobs with optional filtering
···
             if let Some(cursor) = cursor {
                 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor));
             }
-            self.db.run(move |conn| builder.load(conn)).await?
+            self.db
+                .interact(move |conn| builder.load(conn))
+                .await
+                .expect("Failed to list blobs")?
         } else {
             let mut builder = RecordBlobSchema::record_blob
                 .select(RecordBlobSchema::blobCid)
···
             if let Some(cursor) = cursor {
                 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor));
             }
-            self.db.run(move |conn| builder.load(conn)).await?
+            self.db
+                .interact(move |conn| builder.load(conn))
+                .await
+                .expect("Failed to list blobs")?
         };
 
         Ok(res)
···
         use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let res = BlobSchema::blob
                     .filter(BlobSchema::cid.eq(cid.to_string()))
                     .select(models::Blob::as_select())
···
                 }
             })
             .await
+            .expect("Failed to get blob takedown status")
     }
 
     /// Update the takedown status of a blob
···
         let did_clone = self.did.clone();
 
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 update(BlobSchema::blob)
                     .filter(BlobSchema::cid.eq(blob_cid))
                     .filter(BlobSchema::did.eq(did_clone))
···
                     .execute(conn)?;
                 Ok::<_, result::Error>(blob)
             })
-            .await?;
+            .await
+            .expect("Failed to update blob takedown status")?;
 
         let res = match takedown.applied {
             true => self.blobstore.quarantine(blob).await,

src/actor_store/mod.rs

···
 use std::{env, fmt};
 use tokio::sync::RwLock;
 
-use crate::db::DbConn;
-
 use blob::BlobReader;
 use preference::PreferenceReader;
 use record::RecordReader;
···
 // Combination of RepoReader/Transactor, BlobReader/Transactor, SqlRepoReader/Transactor
 impl ActorStore {
     /// Concrete reader of an individual repo (hence BlobStoreSql which takes `did` param)
-    pub fn new(did: String, blobstore: BlobStoreSql, db: DbConn) -> Self {
-        let db = Arc::new(db);
+    pub fn new(
+        did: String,
+        blobstore: BlobStoreSql,
+        db: deadpool_diesel::Connection<SqliteConnection>,
+    ) -> Self {
         ActorStore {
             storage: Arc::new(RwLock::new(SqlRepoReader::new(
                 did.clone(),
···
     pub async fn destroy(&mut self) -> Result<()> {
         let did: String = self.did.clone();
         let storage_guard = self.storage.read().await;
-        let db: Arc<DbConn> = storage_guard.db.clone();
+        let db: deadpool_diesel::Connection<SqliteConnection> = storage_guard.db.clone();
         use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
         let blob_rows: Vec<String> = db
···
         }
         let did: String = self.did.clone();
         let storage_guard = self.storage.read().await;
-        let db: Arc<DbConn> = storage_guard.db.clone();
+        let db: deadpool_diesel::Connection<SqliteConnection> = storage_guard.db.clone();
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
         let cid_strs: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();

src/actor_store/preference.rs

···
 //!
 //! Modified for SQLite backend
 
-use std::sync::Arc;
-
 use anyhow::{Result, bail};
 use diesel::*;
 use rsky_lexicon::app::bsky::actor::RefPreferences;
···
 use rsky_pds::actor_store::preference::util::pref_in_scope;
 use rsky_pds::auth_verifier::AuthScope;
 use rsky_pds::models::AccountPref;
-
-use crate::db::DbConn;
 
 pub struct PreferenceReader {
     pub did: String,
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
 }
 
 impl PreferenceReader {
-    pub fn new(did: String, db: Arc<DbConn>) -> Self {
+    pub fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self {
         PreferenceReader { did, db }
     }
 
···
 
         let did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let prefs_res = AccountPrefSchema::account_pref
                     .filter(AccountPrefSchema::did.eq(&did))
                     .select(AccountPref::as_select())
···
                 Ok(account_prefs)
             })
             .await
+            .expect("Failed to get preferences")
     }
 
     #[tracing::instrument(skip_all)]
···
     ) -> Result<()> {
         let did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 match values
                     .iter()
                     .all(|value| pref_match_namespace(&namespace, &value.get_type()))
···
                 }
             })
             .await
+            .expect("Failed to put preferences")
     }
 }

src/actor_store/record.rs

···
 use rsky_syntax::aturi::AtUri;
 use std::env;
 use std::str::FromStr;
-use std::sync::Arc;
-
-use crate::db::DbConn;
 
 /// Combined handler for record operations with both read and write capabilities.
 pub(crate) struct RecordReader {
     /// Database connection.
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
     /// DID of the actor.
     pub did: String,
 }
 
 impl RecordReader {
     /// Create a new record handler.
-    pub(crate) fn new(did: String, db: Arc<DbConn>) -> Self {
+    pub(crate) fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self {
         Self { did, db }
     }
 
···
 
         let other_did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let res: i64 = record.filter(did.eq(&other_did)).count().get_result(conn)?;
                 Ok(res)
             })
             .await
+            .expect("Failed to count records")
     }
 
     /// List all collections in the repository.
···
 
         let other_did = self.did.clone();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let collections = record
                     .filter(did.eq(&other_did))
                     .select(collection)
···
                 Ok(collections)
             })
             .await
+            .expect("Failed to list collections")
     }
 
     /// List records for a specific collection.
···
                 builder = builder.filter(RecordSchema::rkey.lt(rkey_end));
             }
         }
-        let res: Vec<(Record, RepoBlock)> = self.db.run(move |conn| builder.load(conn)).await?;
+        let res: Vec<(Record, RepoBlock)> = self
+            .db
+            .interact(move |conn| builder.load(conn))
+            .await
+            .expect("Failed to load records")?;
         res.into_iter()
             .map(|row| {
                 Ok(RecordsForCollection {
···
         }
         let record: Option<(Record, RepoBlock)> = self
             .db
-            .run(move |conn| builder.first(conn).optional())
-            .await?;
+            .interact(move |conn| builder.first(conn).optional())
+            .await
+            .expect("Failed to load record")?;
         if let Some(record) = record {
             Ok(Some(GetRecord {
                 uri: record.0.uri,
···
         }
         let record_uri = self
             .db
-            .run(move |conn| builder.first::<String>(conn).optional())
-            .await?;
+            .interact(move |conn| builder.first::<String>(conn).optional())
+            .await
+            .expect("Failed to check record")?;
         Ok(!!record_uri.is_some())
     }
 
···
 
         let res = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 RecordSchema::record
                     .select(RecordSchema::takedownRef)
                     .filter(RecordSchema::uri.eq(uri))
                     .first::<Option<String>>(conn)
                     .optional()
             })
-            .await?;
+            .await
+            .expect("Failed to get takedown status")?;
         if let Some(res) = res {
             if let Some(takedown_ref) = res {
                 Ok(Some(StatusAttr {
···
 
         let res = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 RecordSchema::record
                     .select(RecordSchema::cid)
                     .filter(RecordSchema::uri.eq(uri))
                     .first::<String>(conn)
                     .optional()
             })
-            .await?;
+            .await
+            .expect("Failed to get current CID")?;
         if let Some(res) = res {
             Ok(Some(Cid::from_str(&res)?))
         } else {
···
 
         let res = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 RecordSchema::record
                     .inner_join(
                         BacklinkSchema::backlink.on(BacklinkSchema::uri.eq(RecordSchema::uri)),
···
                     .filter(RecordSchema::collection.eq(collection))
                     .load::<Record>(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to get backlinks")?;
         Ok(res)
     }
 
···
         // Track current version of record
         let (record, uri) = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 insert_into(RecordSchema::record)
                     .values(row)
                     .on_conflict(RecordSchema::uri)
···
                     .execute(conn)?;
                 Ok::<_, Error>((record, uri))
             })
-            .await?;
+            .await
+            .expect("Failed to index record")?;
 
         if let Some(record) = record {
             // Maintain backlinks
···
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
         let uri = uri.to_string();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 delete(RecordSchema::record)
                     .filter(RecordSchema::uri.eq(&uri))
                     .execute(conn)?;
···
                 Ok(())
             })
             .await
+            .expect("Failed to delete record")
     }
 
     /// Remove backlinks for a URI.
···
         use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
         let uri = uri.to_string();
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 delete(BacklinkSchema::backlink)
                     .filter(BacklinkSchema::uri.eq(uri))
                     .execute(conn)?;
                 Ok(())
             })
             .await
+            .expect("Failed to remove backlinks")
     }
 
     /// Add backlinks to the database.
···
         } else {
             use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
             self.db
-                .run(move |conn| {
+                .interact(move |conn| {
                     insert_or_ignore_into(BacklinkSchema::backlink)
                         .values(&backlinks)
                         .execute(conn)?;
                     Ok(())
                 })
                 .await
+                .expect("Failed to add backlinks")
         }
     }
 
···
         let uri_string = uri.to_string();
 
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 update(RecordSchema::record)
                     .filter(RecordSchema::uri.eq(uri_string))
                     .set(RecordSchema::takedownRef.eq(takedown_ref))
···
                 Ok(())
             })
             .await
+            .expect("Failed to update takedown status")
     }
 }

src/actor_store/sql_blob.rs

···
 use anyhow::{Context, Result};
 use cidv10::Cid;
 use diesel::prelude::*;
-use std::sync::Arc;
-
-use crate::db::DbConn;
 
 /// ByteStream implementation for blob data
 pub struct ByteStream {
···
 }
 
 /// SQL-based implementation of blob storage
-#[derive(Clone)]
 pub struct BlobStoreSql {
     /// Database connection for metadata
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
     /// DID of the actor
     pub did: String,
 }
···
 
 impl BlobStoreSql {
     /// Create a new SQL-based blob store for the given DID
-    pub fn new(did: String, db: Arc<DbConn>) -> Self {
+    pub fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self {
         BlobStoreSql { db, did }
     }
 
-    /// Create a factory function for blob stores
-    pub fn creator(db: Arc<DbConn>) -> Box<dyn Fn(String) -> BlobStoreSql> {
-        let db_clone = db.clone();
-        Box::new(move |did: String| BlobStoreSql::new(did, db_clone.clone()))
-    }
+    // /// Create a factory function for blob stores
+    // pub fn creator(
+    //     db: deadpool_diesel::Connection<SqliteConnection>,
+    // ) -> Box<dyn Fn(String) -> BlobStoreSql> {
+    //     let db_clone = db.clone();
+    //     Box::new(move |did: String| BlobStoreSql::new(did, db_clone.clone()))
+    // }
 
     /// Store a blob temporarily - now just stores permanently with a key returned for API compatibility
     pub async fn put_temp(&self, bytes: Vec<u8>) -> Result<String> {
···
 
         // Store directly in the database
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 let data_clone = bytes.clone();
                 let entry = BlobEntry {
                     cid: cid_str.clone(),
···
                     .execute(conn)
                     .context("Failed to insert blob data")
             })
-            .await?;
+            .await
+            .expect("Failed to store blob data")?;
 
         Ok(())
     }
···
 
         // Update the quarantine flag in the database
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 diesel::update(blobs::table)
                     .filter(blobs::cid.eq(&cid_str))
                     .filter(blobs::did.eq(&did_clone))
···
                     .execute(conn)
                     .context("Failed to quarantine blob")
             })
-            .await?;
+            .await
+            .expect("Failed to update quarantine status")?;
 
         Ok(())
     }
···
 
         // Update the quarantine flag in the database
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 diesel::update(blobs::table)
                     .filter(blobs::cid.eq(&cid_str))
                     .filter(blobs::did.eq(&did_clone))
···
                     .execute(conn)
                     .context("Failed to unquarantine blob")
             })
-            .await?;
+            .await
+            .expect("Failed to update unquarantine status")?;
 
         Ok(())
     }
···
         // Get the blob data from the database
         let blob_data = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 blobs
                     .filter(self::blobs::cid.eq(&cid_str))
                     .filter(did.eq(&did_clone))
···
                     .optional()
                     .context("Failed to query blob data")
             })
-            .await?;
+            .await
+            .expect("Failed to get blob data")?;
 
         if let Some(bytes) = blob_data {
             Ok(ByteStream::new(bytes))
···
 
         // Delete from database
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 diesel::delete(blobs)
                     .filter(self::blobs::cid.eq(&blob_cid))
                     .filter(did.eq(&did_clone))
                     .execute(conn)
                     .context("Failed to delete blob")
             })
-            .await?;
+            .await
+            .expect("Failed to delete blob")?;
 
         Ok(())
     }
···
 
         // Delete all blobs in one operation
         self.db
-            .run(move |conn| {
+            .interact(move |conn| {
                 diesel::delete(blobs)
                     .filter(self::blobs::cid.eq_any(cid_strings))
                     .filter(did.eq(&did_clone))
                     .execute(conn)
                     .context("Failed to delete multiple blobs")
             })
-            .await?;
+            .await
+            .expect("Failed to delete multiple blobs")?;
 
         Ok(())
     }
···
 
         let exists = self
             .db
-            .run(move |conn| {
+            .interact(move |conn| {
                 diesel::select(diesel::dsl::exists(
                     blobs
                         .filter(self::blobs::cid.eq(&cid_str))
···
                 .get_result::<bool>(conn)
                 .context("Failed to check if blob exists")
             })
-            .await?;
+            .await
+            .expect("Failed to check blob existence")?;
 
         Ok(exists)
     }

src/actor_store/sql_repo.rs

···
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::db::DbConn;
-
-#[derive(Clone, Debug)]
 pub struct SqlRepoReader {
     pub cache: Arc<RwLock<BlockMap>>,
-    pub db: Arc<DbConn>,
+    pub db: deadpool_diesel::Connection<SqliteConnection>,
     pub root: Option<Cid>,
     pub rev: Option<String>,
     pub now: String,
     pub did: String,
 }
 
+impl std::fmt::Debug for SqlRepoReader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SqlRepoReader")
+            .field("did", &self.did)
+            .field("root", &self.root)
+            .field("rev", &self.rev)
+            .finish()
+    }
+}
+
 impl ReadableBlockstore for SqlRepoReader {
     fn get_bytes<'life>(
         &'life self,
         cid: &'life Cid,
     ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
         let cid = cid.clone();
 
         Box::pin(async move {
···
                 return Ok(Some(cached_result.clone()));
             }
 
-            let found: Option<Vec<u8>> = db
-                .run(move |conn| {
+            let found: Option<Vec<u8>> = self
+                .db
+                .interact(move |conn| {
                     RepoBlockSchema::repo_block
                         .filter(RepoBlockSchema::cid.eq(cid.to_string()))
                         .filter(RepoBlockSchema::did.eq(did))
···
                         .first(conn)
                         .optional()
                 })
-                .await?;
+                .await
+                .expect("Failed to get block")?;
             match found {
                 None => Ok(None),
                 Some(result) => {
···
         cids: Vec<Cid>,
     ) -> Pin<Box<dyn Future<Output = Result<BlocksAndMissing>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
 
         Box::pin(async move {
             use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
···
 
             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);
···
 
                     async move {
                         // Database query
-                        let rows: Vec<(String, Vec<u8>)> = this_db
-                            .run(move |conn| {
+                        let rows: Vec<(String, Vec<u8>)> = self
+                            .db
+                            .interact(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?;
+                            .await
+                            .expect("Failed to get blocks")?;
 
                         // Process rows with locked access
                         let mut blocks = blocks.lock().await;
···
         rev: String,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
         let bytes_cloned = bytes.clone();
         Box::pin(async move {
             use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-            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?;
+            self.db
+                .interact(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
+                .expect("Failed to put block")?;
             {
                 let mut cache_guard = self.cache.write().await;
                 cache_guard.set(cid, bytes_cloned);
···
         rev: String,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
 
         Box::pin(async move {
             use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
···
             let chunks: Vec<Vec<RepoBlock>> =
                 blocks.chunks(50).map(|chunk| chunk.to_vec()).collect();
 
-            let _: Vec<_> = stream::iter(chunks)
-                .then(|batch| {
-                    let db = db.clone();
-                    async move {
-                        db.run(move |conn| {
-                            insert_or_ignore_into(RepoBlockSchema::repo_block)
-                                .values(batch)
-                                .execute(conn)
-                                .map(|_| ())
-                        })
-                        .await
-                        .map_err(anyhow::Error::from)
-                    }
-                })
-                .collect::<Vec<_>>()
-                .await
-                .into_iter()
-                .collect::<Result<Vec<()>>>()?;
+            for batch in chunks {
+                self.db
+                    .interact(move |conn| {
+                        insert_or_ignore_into(RepoBlockSchema::repo_block)
+                            .values(&batch)
+                            .execute(conn)
+                    })
+                    .await
+                    .expect("Failed to insert blocks")?;
+            }
 
             Ok(())
         })
···
         is_create: Option<bool>,
     ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
         let now: String = self.now.clone();
 
         Box::pin(async move {
···
 
             let is_create = is_create.unwrap_or(false);
             if is_create {
-                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?;
+                self.db
+                    .interact(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
+                    .expect("Failed to create root")?;
             } else {
-                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?;
+                self.db
+                    .interact(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
+                    .expect("Failed to update root")?;
             }
             Ok(())
         })
···
 
 // Basically handles getting ipld blocks from db
 impl SqlRepoReader {
-    pub fn new(did: String, now: Option<String>, db: Arc<DbConn>) -> Self {
+    pub fn new(
+        did: String,
+        now: Option<String>,
+        db: deadpool_diesel::Connection<SqliteConnection>,
+    ) -> Self {
         let now = now.unwrap_or_else(rsky_common::now);
         SqlRepoReader {
             cache: Arc::new(RwLock::new(BlockMap::new())),
···
         cursor: &Option<CidAndRev>,
     ) -> Result<Vec<RepoBlock>> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = 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| {
+        Ok(self
+            .db
+            .interact(move |conn| {
                 let mut builder = RepoBlockSchema::repo_block
                     .select(RepoBlock::as_select())
                     .order((RepoBlockSchema::repoRev.desc(), RepoBlockSchema::cid.desc()))
···
                 }
                 builder.load(conn)
             })
-            .await?)
+            .await
+            .expect("Failed to get block range")?)
     }
 
     pub async fn count_blocks(&self) -> Result<i64> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
         use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        let res = db
-            .run(move |conn| {
+        let res = self
+            .db
+            .interact(move |conn| {
                 RepoBlockSchema::repo_block
                     .filter(RepoBlockSchema::did.eq(did))
                     .count()
                     .get_result(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to count blocks")?;
         Ok(res)
     }
 
···
     /// 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: Arc<DbConn> = self.db.clone();
         use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        let result: Vec<(String, Vec<u8>)> = db
-            .run(move |conn| {
+        let result: Vec<(String, Vec<u8>)> = self
+            .db
+            .interact(move |conn| {
                 RepoBlockSchema::repo_block
                     .filter(RepoBlockSchema::did.eq(did))
                     .filter(RepoBlockSchema::repoRev.eq(rev))
···
                     .limit(15)
                     .get_results::<(String, Vec<u8>)>(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to cache rev")?;
         for row in result {
             let mut cache_guard = self.cache.write().await;
             cache_guard.set(Cid::from_str(&row.0)?, row.1)
···
             return Ok(());
         }
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = 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?;
+        self.db
+            .interact(move |conn| {
+                delete(RepoBlockSchema::repo_block)
+                    .filter(RepoBlockSchema::did.eq(did))
+                    .filter(RepoBlockSchema::cid.eq_any(cid_strings))
+                    .execute(conn)
+            })
+            .await
+            .expect("Failed to delete many")?;
         Ok(())
     }
 
     pub async fn get_root_detailed(&self) -> Result<CidAndRev> {
         let did: String = self.did.clone();
-        let db: Arc<DbConn> = self.db.clone();
         use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema;
 
-        let res = db
-            .run(move |conn| {
+        let res = self
+            .db
+            .interact(move |conn| {
                 RepoRootSchema::repo_root
                     .filter(RepoRootSchema::did.eq(did))
                     .select(models::RepoRoot::as_select())
                     .first(conn)
             })
-            .await?;
+            .await
+            .expect("Failed to get root")?;
 
         Ok(CidAndRev {
             cid: Cid::from_str(&res.cid)?,

src/auth.rs

···
 };
 use axum::{extract::FromRequestParts, http::StatusCode};
 use base64::Engine as _;
+use diesel::prelude::*;
 use sha2::{Digest as _, Sha256};
 
-use crate::{AppState, Error, error::ErrorMessage};
+use crate::{AppState, Error, db::DbConn, error::ErrorMessage};
 
 /// Request extractor for authenticated users.
 /// If specified in an API endpoint, this guarantees the API can only be called
···
 
     // Extract subject (DID)
     if let Some(did) = claims.get("sub").and_then(serde_json::Value::as_str) {
-        let _status = sqlx::query_scalar!(r#"SELECT status FROM accounts WHERE did = ?"#, did)
-            .fetch_one(&state.db)
+        // Convert SQLx query to Diesel query
+        use crate::schema::accounts::dsl as AccountSchema;
+
+        let _status = state
+            .db
+            .run(move |conn| {
+                AccountSchema::accounts
+                    .filter(AccountSchema::did.eq(did.to_string()))
+                    .select(AccountSchema::status)
+                    .first::<String>(conn)
+            })
             .await
             .with_context(|| format!("failed to query account {did}"))
             .context("should fetch account status")?;
···
 
     let timestamp = chrono::Utc::now().timestamp();
 
+    // Convert SQLx JTI check to Diesel
+    use crate::schema::oauth_used_jtis::dsl as JtiSchema;
+
     // Check if JTI has been used before
-    let jti_used =
-        sqlx::query_scalar!(r#"SELECT COUNT(*) FROM oauth_used_jtis WHERE jti = ?"#, jti)
-            .fetch_one(&state.db)
-            .await
-            .context("failed to check JTI")?;
+    let jti_string = jti.to_string();
+    let jti_used = state
+        .db
+        .run(move |conn| {
+            JtiSchema::oauth_used_jtis
+                .filter(JtiSchema::jti.eq(jti_string))
+                .count()
+                .get_result::<i64>(conn)
+        })
+        .await
+        .context("failed to check JTI")?;
 
     if jti_used > 0 {
         return Err(Error::with_status(
···
         .and_then(serde_json::Value::as_i64)
         .unwrap_or_else(|| timestamp.checked_add(60).unwrap_or(timestamp));
 
-    _ = sqlx::query!(
-        r#"
-        INSERT INTO oauth_used_jtis (jti, issuer, created_at, expires_at)
-        VALUES (?, ?, ?, ?)
-        "#,
-        jti,
-        calculated_thumbprint, // Use thumbprint as issuer identifier
-        timestamp,
-        exp
-    )
-    .execute(&state.db)
-    .await
-    .context("failed to store JTI")?;
+    // Convert SQLx INSERT to Diesel
+    let jti_str = jti.to_string();
+    let thumbprint_str = calculated_thumbprint.to_string();
+    state
+        .db
+        .run(move |conn| {
+            diesel::insert_into(JtiSchema::oauth_used_jtis)
+                .values((
+                    JtiSchema::jti.eq(jti_str),
+                    JtiSchema::issuer.eq(thumbprint_str),
+                    JtiSchema::created_at.eq(timestamp),
+                    JtiSchema::expires_at.eq(exp),
+                ))
+                .execute(conn)
+        })
+        .await
+        .context("failed to store JTI")?;
 
     // Extract subject (DID) from access token
-    if let Some(did) = claims.get("sub").and_then(|v| v.as_str()) {
-        let _status = sqlx::query_scalar!(r#"SELECT status FROM accounts WHERE did = ?"#, did)
-            .fetch_one(&state.db)
+    if let Some(did) = claims.get("sub").and_then(|v| v.as_str) {
+        // Convert SQLx query to Diesel
+        use crate::schema::accounts::dsl as AccountSchema;
+
+        let _status = state
+            .db
+            .run(move |conn| {
+                AccountSchema::accounts
+                    .filter(AccountSchema::did.eq(did.to_string()))
+                    .select(AccountSchema::status)
+                    .first::<String>(conn)
+            })
             .await
             .with_context(|| format!("failed to query account {did}"))
             .context("should fetch account status")?;

src/db.rs

···
 use anyhow::Result;
-use diesel::prelude::*;
-use dotenvy::dotenv;
-use rocket_sync_db_pools::database;
-use std::env;
-use std::fmt::{Debug, Formatter};
-
-#[database("sqlite_db")]
-pub struct DbConn(SqliteConnection);
-
-impl Debug for DbConn {
-    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
-        todo!()
-    }
-}
+use deadpool_diesel::sqlite::{Manager, Pool, Runtime};
 
 #[tracing::instrument(skip_all)]
-pub fn establish_connection_for_sequencer() -> Result<SqliteConnection> {
-    dotenv().ok();
-    tracing::debug!("Establishing database connection for Sequencer");
-    let database_url = env::var("BLUEPDS_DB").unwrap_or("sqlite://data/sqlite.db".into());
-    let db = SqliteConnection::establish(&database_url).map_err(|error| {
-        let context = format!("Error connecting to {database_url:?}");
-        anyhow::Error::new(error).context(context)
-    })?;
-    Ok(db)
+/// Establish a connection to the database
+/// Takes a database URL as an argument (like "sqlite://data/sqlite.db")
+pub(crate) fn establish_pool(database_url: &str) -> Result<Pool> {
+    tracing::debug!("Establishing database connection");
+    let manager = Manager::new(database_url, Runtime::Tokio1);
+    let pool = Pool::builder(manager)
+        .max_size(8)
+        .build()
+        .expect("should be able to create connection pool");
+    tracing::debug!("Database connection established");
+    Ok(pool)
 }

src/endpoints/repo/apply_writes.rs

···
 //! Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.
 use crate::{
-    AppState, Db, Error, Result, SigningKey,
-    actor_store::ActorStore,
-    actor_store::sql_blob::BlobStoreSql,
+    ActorPools, AppState, Db, Error, Result, SigningKey,
+    actor_store::{ActorStore, sql_blob::BlobStoreSql},
     auth::AuthenticatedUser,
     config::AppConfig,
     error::ErrorMessage,
···
     State(skey): State<SigningKey>,
     State(config): State<AppConfig>,
     State(db): State<Db>,
+    State(db_actors): State<std::collections::HashMap<String, ActorPools>>,
     State(fhp): State<FirehoseProducer>,
     Json(input): Json<ApplyWritesInput>,
 ) -> Result<Json<repo::apply_writes::Output>> {
···
             None => None,
         };
 
-        let mut actor_store = ActorStore::new(did.clone(), BlobStoreSql::new(did.clone(), db), db);
+        let actor_db = db_actors
+            .get(did)
+            .ok_or_else(|| anyhow!("Actor DB not found"))?;
+        let mut actor_store = ActorStore::new(
+            did.clone(),
+            BlobStoreSql::new(did.clone(), actor_db.blob),
+            actor_db.repo,
+        );
 
         let commit = actor_store
             .process_writes(writes.clone(), swap_commit_cid)

src/main.rs

···
 use clap::Parser;
 use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter};
 use config::AppConfig;
+use db::establish_pool;
+use deadpool_diesel::sqlite::Pool;
 use diesel::prelude::*;
-use diesel::r2d2::{self, ConnectionManager};
-use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations};
+use diesel_migrations::{EmbeddedMigrations, embed_migrations};
 #[expect(clippy::pub_use, clippy::useless_attribute)]
 pub use error::Error;
 use figment::{Figment, providers::Format as _};
···
 pub type Result<T> = std::result::Result<T, Error>;
 /// The reqwest client type with middleware.
 pub type Client = reqwest_middleware::ClientWithMiddleware;
-/// The database connection pool.
-pub type Db = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 /// The Azure credential type.
 pub type Cred = Arc<dyn TokenCredential>;
 
···
     verbosity: Verbosity<InfoLevel>,
 }
 
+struct ActorPools {
+    repo: Pool,
+    blob: Pool,
+}
+impl Clone for ActorPools {
+    fn clone(&self) -> Self {
+        Self {
+            repo: self.repo.clone(),
+            blob: self.blob.clone(),
+        }
+    }
+}
+
 #[expect(clippy::arbitrary_source_item_ordering, reason = "arbitrary")]
 #[derive(Clone, FromRef)]
 struct AppState {
···
     config: AppConfig,
     /// The Azure credential.
     cred: Cred,
-    /// The database connection pool.
-    db: Db,
+    /// The main database connection pool. Used for common PDS data, like invite codes.
+    db: Pool,
+    /// Actor-specific database connection pools. Hashed by DID.
+    db_actors: std::collections::HashMap<String, ActorPools>,
 
     /// The HTTP client with middleware.
     client: Client,
···
 #[expect(
     clippy::cognitive_complexity,
     clippy::too_many_lines,
+    unused_qualifications,
     reason = "main function has high complexity"
 )]
 async fn run() -> anyhow::Result<()> {
···
     let cred = azure_identity::DefaultAzureCredential::new()
         .context("failed to create Azure credential")?;
 
-    // Create a database connection manager and pool
-    let manager = ConnectionManager::<SqliteConnection>::new(&config.db);
-    let db = r2d2::Pool::builder()
-        .build(manager)
-        .context("failed to create database connection pool")?;
+    // Create a database connection manager and pool for the main database.
+    let pool =
+        establish_pool(&config.db).context("failed to establish database connection pool")?;
+    // Create a dictionary of database connection pools for each actor.
+    let mut actor_pools = std::collections::HashMap::new();
+    // let mut actor_blob_pools = std::collections::HashMap::new();
+    // We'll determine actors by looking in the data/repo dir for .db files.
+    let mut actor_dbs = tokio::fs::read_dir(&config.repo.path)
+        .await
+        .context("failed to read repo directory")?;
+    while let Some(entry) = actor_dbs
+        .next_entry()
+        .await
+        .context("failed to read repo dir")?
+    {
+        let path = entry.path();
+        if path.extension().and_then(|s| s.to_str()) == Some("db") {
+            let did = path
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .context("failed to get actor DID")?;
+            let did = Did::from_str(did).expect("should be able to parse actor DID");
 
+            // Create a new database connection manager and pool for the actor.
+            // The path for the SQLite connection needs to look like "sqlite://data/repo/<actor>.db"
+            let path_repo = format!("sqlite://{}", path.display());
+            let actor_repo_pool =
+                establish_pool(&path_repo).context("failed to create database connection pool")?;
+            // Create a new database connection manager and pool for the actor blobs.
+            // The path for the SQLite connection needs to look like "sqlite://data/blob/<actor>.db"
+            let path_blob = path_repo.replace("repo", "blob");
+            let actor_blob_pool =
+                establish_pool(&path_blob).context("failed to create database connection pool")?;
+            actor_pools.insert(
+                did.to_string(),
+                ActorPools {
+                    repo: actor_repo_pool,
+                    blob: actor_blob_pool,
+                },
+            );
+        }
+    }
     // Apply pending migrations
-    let conn = &mut db
-        .get()
-        .context("failed to get database connection for migrations")?;
-    conn.run_pending_migrations(MIGRATIONS)
-        .expect("should be able to run migrations");
+    // let conn = pool.get().await?;
+    // conn.run_pending_migrations(MIGRATIONS)
+    //     .expect("should be able to run migrations");
 
     let (_fh, fhp) = firehose::spawn(client.clone(), config.clone());
 
···
         .with_state(AppState {
             cred,
             config: config.clone(),
-            db: db.clone(),
+            db: pool.clone(),
+            db_actors: actor_pools.clone(),
             client: client.clone(),
             simple_client,
             firehose: fhp,
···
 
     // Determine whether or not this was the first startup (i.e. no accounts exist and no invite codes were created).
     // If so, create an invite code and share it via the console.
-    let conn = &mut db.get().context("failed to get database connection")?;
+    let conn = pool.get().await.context("failed to get db connection")?;
 
     #[derive(QueryableByName)]
     struct TotalCount {
···
         total_count: i32,
     }
 
-    let result = diesel::sql_query(
-        "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count",
-    )
-    .get_result::<TotalCount>(conn)
-    .context("failed to query database")?;
+    // let result = diesel::sql_query(
+    //     "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count",
+    // )
+    // .get_result::<TotalCount>(conn)
+    // .context("failed to query database")?;
+    let result = conn.interact(move |conn| {
+        diesel::sql_query(
+            "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count",
+        )
+        .get_result::<TotalCount>(conn)
+    })
+    .await
+    .expect("should be able to query database")?;
 
     let c = result.total_count;
 
···
     if c == 0 {
         let uuid = Uuid::new_v4().to_string();
 
-        diesel::sql_query(
+        let uuid_clone = uuid.clone();
+        conn.interact(move |conn| {
+            diesel::sql_query(
             "INSERT INTO invites (id, did, count, created_at) VALUES (?, NULL, 1, datetime('now'))",
         )
-        .bind::<diesel::sql_types::Text, _>(uuid.clone())
+        .bind::<diesel::sql_types::Text, _>(uuid_clone)
         .execute(conn)
-        .context("failed to create new invite code")?;
+        .context("failed to create new invite code")
+        .expect("should be able to create invite code")
+        });
 
         // N.B: This is a sensitive message, so we're bypassing `tracing` here and
         // logging it directly to console.

src/tests.rs

···
             let opts = SqliteConnectOptions::from_str(&config.db)
                 .context("failed to parse database options")?
                 .create_if_missing(true);
-            let db = SqlitePool::connect_with(opts).await?;
+            let db = SqliteDbConn::connect_with(opts).await?;
 
             sqlx::migrate!()
                 .run(&db)