lint

src/account_manager/helpers/account.rs

···
     let AvailabilityFlags {
         include_taken_down,
         include_deactivated,
-    } = flags.unwrap_or_else(|| AvailabilityFlags {
+    } = flags.unwrap_or(AvailabilityFlags {
         include_taken_down: Some(false),
         include_deactivated: Some(false),
     });
···
     use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema;
 
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
-            delete(RepoRootSchema::repo_root)
+            _ = delete(RepoRootSchema::repo_root)
                 .filter(RepoRootSchema::did.eq(&did))
                 .execute(conn)?;
-            delete(EmailTokenSchema::email_token)
+            _ = delete(EmailTokenSchema::email_token)
                 .filter(EmailTokenSchema::did.eq(&did))
                 .execute(conn)?;
-            delete(RefreshTokenSchema::refresh_token)
+            _ = delete(RefreshTokenSchema::refresh_token)
                 .filter(RefreshTokenSchema::did.eq(&did))
                 .execute(conn)?;
-            delete(AccountSchema::account)
+            _ = delete(AccountSchema::account)
                 .filter(AccountSchema::did.eq(&did))
                 .execute(conn)?;
             delete(ActorSchema::actor)
···
     >,
 ) -> Result<()> {
     let takedown_ref: Option<String> = match takedown.applied {
-        true => match takedown.r#ref {
-            Some(takedown_ref) => Some(takedown_ref),
-            None => Some(rsky_common::now()),
-        },
+        true => takedown
+            .r#ref
+            .map_or_else(|| Some(rsky_common::now()), Some),
         false => None,
     };
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             update(ActorSchema::actor)
···
     >,
 ) -> Result<()> {
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             update(ActorSchema::actor)
···
     >,
 ) -> Result<()> {
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             update(ActorSchema::actor)
···
     >,
 ) -> Result<()> {
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             update(AccountSchema::account)
···
     match res {
         None => Ok(None),
         Some(res) => {
-            let takedown = match res.0 {
-                Some(takedown_ref) => StatusAttr {
-                    applied: true,
-                    r#ref: Some(takedown_ref),
-                },
-                None => StatusAttr {
+            let takedown = res.0.map_or(
+                StatusAttr {
                     applied: false,
                     r#ref: None,
                 },
-            };
+                |takedown_ref| StatusAttr {
+                    applied: true,
+                    r#ref: Some(takedown_ref),
+                },
+            );
             let deactivated = match res.1 {
                 Some(_) => StatusAttr {
                     applied: true,

src/account_manager/helpers/auth.rs

···
 
     let exp = from_micros_to_utc((payload.exp.as_millis() / 1000) as i64);
 
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             insert_into(RefreshTokenSchema::refresh_token)
···
     db.get()
         .await?
         .interact(move |conn| {
-            delete(RefreshTokenSchema::refresh_token)
+            _ = delete(RefreshTokenSchema::refresh_token)
                 .filter(RefreshTokenSchema::did.eq(did))
                 .filter(RefreshTokenSchema::expiresAt.le(now))
                 .execute(conn)?;
···
             } = opts;
             use rsky_pds::schema::pds::refresh_token::dsl as RefreshTokenSchema;
 
-            update(RefreshTokenSchema::refresh_token)
-                .filter(RefreshTokenSchema::id.eq(id))
-                .filter(
-                    RefreshTokenSchema::nextId
-                        .is_null()
-                        .or(RefreshTokenSchema::nextId.eq(&next_id)),
-                )
-                .set((
-                    RefreshTokenSchema::expiresAt.eq(expires_at),
-                    RefreshTokenSchema::nextId.eq(&next_id),
-                ))
-                .returning(models::RefreshToken::as_select())
-                .get_results(conn)
-                .map_err(|error| {
-                    anyhow::Error::new(AuthHelperError::ConcurrentRefresh).context(error)
-                })?;
+            drop(
+                update(RefreshTokenSchema::refresh_token)
+                    .filter(RefreshTokenSchema::id.eq(id))
+                    .filter(
+                        RefreshTokenSchema::nextId
+                            .is_null()
+                            .or(RefreshTokenSchema::nextId.eq(&next_id)),
+                    )
+                    .set((
+                        RefreshTokenSchema::expiresAt.eq(expires_at),
+                        RefreshTokenSchema::nextId.eq(&next_id),
+                    ))
+                    .returning(models::RefreshToken::as_select())
+                    .get_results(conn)
+                    .map_err(|error| {
+                        anyhow::Error::new(AuthHelperError::ConcurrentRefresh).context(error)
+                    })?,
+            );
             Ok(())
         })
         .await

src/account_manager/helpers/email_token.rs

···
 //! blacksky-algorithms/rsky is licensed under the Apache License 2.0
 //!
 //! Modified for SQLite backend
+#![allow(unnameable_types, unused_qualifications)]
 use anyhow::{Result, bail};
 use diesel::*;
 use rsky_common::time::{MINUTE, from_str_to_utc, less_than_ago_s};
···
     db.get()
         .await?
         .interact(move |conn| {
-            insert_into(EmailTokenSchema::email_token)
+            _ = insert_into(EmailTokenSchema::email_token)
                 .values((
                     EmailTokenSchema::purpose.eq(purpose),
                     EmailTokenSchema::did.eq(did),
···
 }
 
 impl EmailTokenPurpose {
-    pub fn as_str(&self) -> &'static str {
+    pub const fn as_str(&self) -> &'static str {
         match self {
-            EmailTokenPurpose::ConfirmEmail => "confirm_email",
-            EmailTokenPurpose::UpdateEmail => "update_email",
-            EmailTokenPurpose::ResetPassword => "reset_password",
-            EmailTokenPurpose::DeleteAccount => "delete_account",
-            EmailTokenPurpose::PlcOperation => "plc_operation",
+            Self::ConfirmEmail => "confirm_email",
+            Self::UpdateEmail => "update_email",
+            Self::ResetPassword => "reset_password",
+            Self::DeleteAccount => "delete_account",
+            Self::PlcOperation => "plc_operation",
         }
     }
 
     pub fn from_str(s: &str) -> Result<Self> {
         match s {
-            "confirm_email" => Ok(EmailTokenPurpose::ConfirmEmail),
-            "update_email" => Ok(EmailTokenPurpose::UpdateEmail),
-            "reset_password" => Ok(EmailTokenPurpose::ResetPassword),
-            "delete_account" => Ok(EmailTokenPurpose::DeleteAccount),
-            "plc_operation" => Ok(EmailTokenPurpose::PlcOperation),
+            "confirm_email" => Ok(Self::ConfirmEmail),
+            "update_email" => Ok(Self::UpdateEmail),
+            "reset_password" => Ok(Self::ResetPassword),
+            "delete_account" => Ok(Self::DeleteAccount),
+            "plc_operation" => Ok(Self::PlcOperation),
             _ => bail!("Unable to parse as EmailTokenPurpose: `{s:?}`"),
         }
     }
···
     type Row = String;
 
     fn build(s: String) -> deserialize::Result<Self> {
-        Ok(EmailTokenPurpose::from_str(&s)?)
+        Ok(Self::from_str(&s)?)
     }
 }
 
···
     ) -> serialize::Result {
         serialize::ToSql::<sql_types::Text, sqlite::Sqlite>::to_sql(
             match self {
-                EmailTokenPurpose::ConfirmEmail => "confirm_email",
-                EmailTokenPurpose::UpdateEmail => "update_email",
-                EmailTokenPurpose::ResetPassword => "reset_password",
-                EmailTokenPurpose::DeleteAccount => "delete_account",
-                EmailTokenPurpose::PlcOperation => "plc_operation",
+                Self::ConfirmEmail => "confirm_email",
+                Self::UpdateEmail => "update_email",
+                Self::ResetPassword => "reset_password",
+                Self::DeleteAccount => "delete_account",
+                Self::PlcOperation => "plc_operation",
             },
             out,
         )
···
 ) -> Result<()> {
     use rsky_pds::schema::pds::email_token::dsl as EmailTokenSchema;
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             delete(EmailTokenSchema::email_token)
···
     use rsky_pds::schema::pds::email_token::dsl as EmailTokenSchema;
 
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             delete(EmailTokenSchema::email_token)

src/account_manager/helpers/invite.rs

···
             .first(conn)
             .optional()?;
 
-        if invite.is_none() || invite.clone().unwrap().disabled > 0 {
-            bail!("InvalidInviteCode: None or disabled. Provided invite code not available `{invite_code:?}`")
-        }
+        if let Some(invite) = invite {
+            if invite.disabled > 0 {
+                bail!("InvalidInviteCode: Disabled. Provided invite code not available `{invite_code:?}`");
+            }
 
-        let uses: i64 = InviteCodeUseSchema::invite_code_use
-            .count()
-            .filter(InviteCodeUseSchema::code.eq(&invite_code))
-            .first(conn)?;
+            let uses: i64 = InviteCodeUseSchema::invite_code_use
+                .count()
+                .filter(InviteCodeUseSchema::code.eq(&invite_code))
+                .first(conn)?;
 
-        if invite.unwrap().available_uses as i64 <= uses {
-            bail!("InvalidInviteCode: Not enough uses. Provided invite code not available `{invite_code:?}`")
+            if invite.available_uses as i64 <= uses {
+                bail!("InvalidInviteCode: Not enough uses. Provided invite code not available `{invite_code:?}`");
+            }
+        } else {
+            bail!("InvalidInviteCode: None. Provided invite code not available `{invite_code:?}`");
         }
+
         Ok(())
     }).await.expect("Failed to check invite code availability")?;
 
···
     if let Some(invite_code) = invite_code {
         use rsky_pds::schema::pds::invite_code_use::dsl as InviteCodeUseSchema;
 
-        db.get()
+        _ = db
+            .get()
             .await?
             .interact(move |conn| {
                 insert_into(InviteCodeUseSchema::invite_code_use)
···
     use rsky_pds::schema::pds::invite_code::dsl as InviteCodeSchema;
     let created_at = rsky_common::now();
 
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             let rows: Vec<models::InviteCode> = to_create
···
                 })
                 .collect();
 
-            insert_into(InviteCodeSchema::invite_code)
+            _ = insert_into(InviteCodeSchema::invite_code)
                 .values(&rows)
                 .execute(conn)?;
 
···
             } = invite_code_use;
             match uses.get_mut(&code) {
                 None => {
-                    uses.insert(code, vec![CodeUse { used_by, used_at }]);
+                    drop(uses.insert(code, vec![CodeUse { used_by, used_at }]));
                 }
                 Some(matched_uses) => matched_uses.push(CodeUse { used_by, used_at }),
             };
···
         BTreeMap::new(),
         |mut acc: BTreeMap<String, CodeDetail>, cur| {
             for code_use in &cur.uses {
-                acc.insert(code_use.used_by.clone(), cur.clone());
+                drop(acc.insert(code_use.used_by.clone(), cur.clone()));
             }
             acc
         },
···
 
     let disabled: i16 = if disabled { 1 } else { 0 };
     let did = did.to_owned();
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             update(AccountSchema::account)
···
 
     let DisableInviteCodesOpts { codes, accounts } = opts;
     if !codes.is_empty() {
-        db.get()
+        _ = db
+            .get()
             .await?
             .interact(move |conn| {
                 update(InviteCodeSchema::invite_code)
···
             .expect("Failed to disable invite codes")?;
     }
     if !accounts.is_empty() {
-        db.get()
+        _ = db
+            .get()
             .await?
             .interact(move |conn| {
                 update(InviteCodeSchema::invite_code)

src/account_manager/helpers/password.rs

···
     db.get()
         .await?
         .interact(move |conn| {
-            update(AccountSchema::account)
+            _ = update(AccountSchema::account)
                 .filter(AccountSchema::did.eq(opts.did))
                 .set(AccountSchema::password.eq(opts.password_encrypted))
                 .execute(conn)?;
···
     db.get()
         .await?
         .interact(move |conn| {
-            delete(AppPasswordSchema::app_password)
+            _ = delete(AppPasswordSchema::app_password)
                 .filter(AppPasswordSchema::did.eq(did))
                 .filter(AppPasswordSchema::name.eq(name))
                 .execute(conn)?;

src/account_manager/helpers/repo.rs

···
 
     let now = rsky_common::now();
 
-    db.get()
+    _ = db
+        .get()
         .await?
         .interact(move |conn| {
             insert_into(RepoRootSchema::repo_root)

src/account_manager/mod.rs

···
 >;
 
 impl AccountManager {
-    pub fn new(
+    pub const fn new(
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
             deadpool_diesel::sqlite::Object,
···
                 deadpool_diesel::Manager<SqliteConnection>,
                 deadpool_diesel::sqlite::Object,
             >|
-                  -> AccountManager { AccountManager::new(db) },
+                  -> Self { Self::new(db) },
         )
     }
 
···
         let (access_jwt, refresh_jwt) = auth::create_tokens(CreateTokensOpts {
             did: did.clone(),
             jwt_key,
-            service_did: env::var("PDS_SERVICE_DID").unwrap(),
+            service_did: env::var("PDS_SERVICE_DID").expect("PDS_SERVICE_DID not set"),
             scope: Some(AuthScope::Access),
             jti: None,
             expires_in: None,
···
         let (access_jwt, refresh_jwt) = auth::create_tokens(CreateTokensOpts {
             did,
             jwt_key,
-            service_did: env::var("PDS_SERVICE_DID").unwrap(),
+            service_did: env::var("PDS_SERVICE_DID").expect("PDS_SERVICE_DID not set"),
             scope: Some(scope),
             jti: None,
             expires_in: None,
···
             let next_id = token.next_id.unwrap_or_else(auth::get_refresh_token_id);
 
             let secp = Secp256k1::new();
-            let private_key = env::var("PDS_JWT_KEY_K256_PRIVATE_KEY_HEX").unwrap();
+            let private_key = env::var("PDS_JWT_KEY_K256_PRIVATE_KEY_HEX")
+                .expect("PDS_JWT_KEY_K256_PRIVATE_KEY_HEX not set");
             let secret_key =
-                SecretKey::from_slice(&hex::decode(private_key.as_bytes()).unwrap()).unwrap();
+                SecretKey::from_slice(&hex::decode(private_key.as_bytes()).expect("Invalid key"))?;
             let jwt_key = Keypair::from_secret_key(&secp, &secret_key);
 
             let (access_jwt, refresh_jwt) = auth::create_tokens(CreateTokensOpts {
                 did: token.did,
                 jwt_key,
-                service_did: env::var("PDS_SERVICE_DID").unwrap(),
+                service_did: env::var("PDS_SERVICE_DID").expect("PDS_SERVICE_DID not set"),
                 scope: Some(if token.app_password_name.is_none() {
                     AuthScope::Access
                 } else {

src/actor_store/blob.rs

···
             deadpool_diesel::sqlite::Object,
         >,
     ) -> Self {
-        BlobReader {
+        Self {
             did: blobstore.did.clone(),
             blobstore,
             db,
···
             size,
             cid,
             mime_type,
-            width: if let Some(ref info) = img_info {
-                Some(info.width as i32)
-            } else {
-                None
-            },
+            width: img_info.as_ref().map(|info| info.width as i32),
             height: if let Some(info) = img_info {
                 Some(info.height as i32)
             } else {
···
         SET \"tempKey\" = EXCLUDED.\"tempKey\" \
             WHERE pds.blob.\"tempKey\" is not null;");
             #[expect(trivial_casts)]
-            upsert
+            let _ = 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<Text>, _>(Some(temp_key))
                 .bind::<Nullable<Integer>, _>(width)
                 .bind::<Nullable<Integer>, _>(height)
                 .bind::<Text, _>(created_at)
···
     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?;
+        drop(
+            stream::iter(writes)
+                .then(async move |write| {
+                    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?;
+                        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?;
+                            }
                         }
-                    }
-                    _ => (),
+                        _ => (),
+                    };
+                    Ok::<(), anyhow::Error>(())
                 })
-            })
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()?;
+                .collect::<Vec<_>>()
+                .await
+                .into_iter()
+                .collect::<Result<Vec<_>, _>>()?,
+        );
 
         Ok(())
     }
···
 
         // Now perform the delete
         let uris_clone = uris.clone();
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
         // Delete from the blob table
         let cids = cids_to_delete.clone();
         let did_clone = self.did.clone();
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
 
         // Delete from blob storage
         // Ideally we'd use a background queue here, but for now:
-        let _ = stream::iter(cids_to_delete)
-            .then(|cid| async move {
-                match Cid::from_str(&cid) {
+        drop(
+            stream::iter(cids_to_delete)
+                .then(async move |cid| match Cid::from_str(&cid) {
                     Ok(cid) => self.blobstore.delete(cid.to_string()).await,
                     Err(e) => Err(anyhow::Error::new(e)),
-                }
-            })
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()?;
+                })
+                .collect::<Vec<_>>()
+                .await
+                .into_iter()
+                .collect::<Result<Vec<_>, _>>()?,
+        );
 
         Ok(())
     }
···
                     .make_permanent(temp_key.clone(), blob.cid)
                     .await?;
             }
-            self.db
+            _ = self
+                .db
                 .get()
                 .await?
                 .interact(move |conn| {
···
         let cid = blob.cid.to_string();
         let did = self.did.clone();
 
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
 
                 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),
-                        })),
-                    },
+                    Some(res) => res.takedown_ref.map_or_else(
+                        || {
+                            Ok(Some(StatusAttr {
+                                applied: false,
+                                r#ref: None,
+                            }))
+                        },
+                        |takedown_ref| {
+                            Ok(Some(StatusAttr {
+                                applied: true,
+                                r#ref: Some(takedown_ref),
+                            }))
+                        },
+                    ),
                 }
             })
             .await
···
         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()),
-            },
+            true => takedown.r#ref.map_or_else(|| Some(now()), Some),
             false => None,
         };
 
         let blob_cid = blob.to_string();
         let did_clone = self.did.clone();
 
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
-                update(BlobSchema::blob)
+                _ = update(BlobSchema::blob)
                     .filter(BlobSchema::cid.eq(blob_cid))
                     .filter(BlobSchema::did.eq(did_clone))
                     .set(BlobSchema::takedownRef.eq(takedown_ref))

src/actor_store/mod.rs

···
         >,
         conn: deadpool_diesel::sqlite::Object,
     ) -> Self {
-        ActorStore {
+        Self {
             storage: Arc::new(RwLock::new(SqlRepoReader::new(did.clone(), None, conn))),
             record: RecordReader::new(did.clone(), db.clone()),
             pref: PreferenceReader::new(did.clone(), db.clone()),
             did,
-            blob: BlobReader::new(blobstore, db.clone()),
+            blob: BlobReader::new(blobstore, db),
         }
     }
 
···
             Some(write_ops),
         )
         .await?;
-        let storage_guard = self.storage.read().await;
-        storage_guard.apply_commit(commit.clone(), None).await?;
+        self.storage
+            .read()
+            .await
+            .apply_commit(commit.clone(), None)
+            .await?;
         let writes = writes
             .into_iter()
             .map(PreparedWrite::Create)
···
             Some(write_ops),
         )
         .await?;
-        let storage_guard = self.storage.read().await;
-        storage_guard.apply_commit(commit.clone(), None).await?;
+        self.storage
+            .read()
+            .await
+            .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>> {
···
                 acc.push(CommitOp {
                     action: CommitAction::Create,
                     path: format_data_key(aturi.get_collection(), aturi.get_rkey()),
-                    cid: Some(w.cid.clone()),
+                    cid: Some(w.cid),
                     prev: None,
                 });
                 Ok(acc)
···
                 .await?;
         }
         // persist the commit to repo storage
-        let storage_guard = self.storage.read().await;
-        storage_guard.apply_commit(commit.clone(), None).await?;
+        self.storage
+            .read()
+            .await
+            .apply_commit(commit.clone(), None)
+            .await?;
         // process blobs
         self.blob.process_write_blobs(writes).await?;
         Ok(())
···
                 .await?;
         }
         // persist the commit to repo storage
-        let storage_guard = self.storage.read().await;
-        storage_guard
+        self.storage
+            .read()
+            .await
             .apply_commit(commit.commit_data.clone(), None)
             .await?;
         // process blobs
···
     }
 
     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?;
+        let current_root = self.storage.read().await.get_root_detailed().await?;
+        let blocks_and_missing = self
+            .storage
+            .read()
+            .await
+            .get_blocks(vec![current_root.cid])
+            .await?;
         Ok(SyncEvtData {
             cid: current_root.cid,
             rev: current_root.rev,
···
                 }
             }
             {
-                let mut storage_guard = self.storage.write().await;
-                storage_guard.cache_rev(current_root.rev).await?;
+                self.storage
+                    .write()
+                    .await
+                    .cache_rev(current_root.rev)
+                    .await?;
             }
             let mut new_record_cids: Vec<Cid> = vec![];
             let mut delete_and_update_uris = vec![];
···
                     cid,
                     prev: None,
                 };
-                if let Some(_) = current_record {
+                if current_record.is_some() {
                     op.prev = current_record;
                 };
                 commit_ops.push(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_private_key = env::var("PDS_REPO_SIGNING_KEY_K256_PRIVATE_KEY_HEX")
+                .expect("PDS_REPO_SIGNING_KEY_K256_PRIVATE_KEY_HEX not set");
+            let repo_secret_key = SecretKey::from_slice(
+                &hex::decode(repo_private_key.as_bytes()).expect("Failed to decode hex"),
+            )
+            .expect("Failed to create secret key from hex");
             let repo_signing_key = Keypair::from_secret_key(&secp, &repo_secret_key);
 
             let mut commit = repo
···
     pub async fn index_writes(&self, writes: Vec<PreparedWrite>, rev: &str) -> Result<()> {
         let now: &str = &rsky_common::now();
 
-        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?
+        drop(
+            stream::iter(writes)
+                .then(async move |write| {
+                    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_owned()),
+                                )
+                                .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_owned()),
+                                )
+                                .await?;
+                        }
+                        PreparedWrite::Delete(write) => {
+                            let write_at_uri: AtUri = write.uri.try_into()?;
+                            self.record.delete_record(&write_at_uri).await?;
+                        }
                     }
+                    Ok::<(), anyhow::Error>(())
                 })
-            })
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()?;
+                .collect::<Vec<_>>()
+                .await
+                .into_iter()
+                .collect::<Result<Vec<_>, _>>()?,
+        );
         Ok(())
     }
 
     pub async fn destroy(&mut self) -> Result<()> {
         let did: String = self.did.clone();
-        let storage_guard = self.storage.read().await;
         use rsky_pds::schema::pds::blob::dsl as BlobSchema;
 
-        let blob_rows: Vec<String> = storage_guard
+        let blob_rows: Vec<String> = self
+            .storage
+            .read()
+            .await
             .db
             .interact(move |conn| {
                 BlobSchema::blob
···
             .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<_>, _>>()?;
+        drop(
+            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(())
     }
 
···
             return Ok(vec![]);
         }
         let did: String = self.did.clone();
-        let storage_guard = self.storage.read().await;
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
         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> = storage_guard
+        let res: Vec<String> = self
+            .storage
+            .read()
+            .await
             .db
             .interact(move |conn| {
                 RecordSchema::record
···
             .await
             .expect("Failed to get duplicate record cids")?;
         res.into_iter()
-            .map(|row| Cid::from_str(&row).map_err(|error| anyhow::Error::new(error)))
+            .map(|row| Cid::from_str(&row).map_err(anyhow::Error::new))
             .collect::<Result<Vec<Cid>>>()
     }
 }

src/actor_store/preference.rs

···
 }
 
 impl PreferenceReader {
-    pub fn new(
+    pub const fn new(
         did: String,
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
             deadpool_diesel::sqlite::Object,
         >,
     ) -> Self {
-        PreferenceReader { did, db }
+        Self { did, db }
     }
 
     pub async fn get_preferences(
···
                     .load(conn)?;
                 let account_prefs = prefs_res
                     .into_iter()
-                    .filter(|pref| match &namespace {
-                        None => true,
-                        Some(namespace) => pref_match_namespace(namespace, &pref.name),
+                    .filter(|pref| {
+                        namespace
+                            .as_ref()
+                            .is_none_or(|namespace| pref_match_namespace(namespace, &pref.name))
                     })
                     .filter(|pref| pref_in_scope(scope.clone(), pref.name.clone()))
                     .map(|pref| {
···
                 {
                     false => bail!("Some preferences are not in the {namespace} namespace"),
                     true => {
-                        let not_in_scope = values
-                            .iter()
-                            .filter(|value| !pref_in_scope(scope.clone(), value.get_type()))
-                            .collect::<Vec<&RefPreferences>>();
-                        if !not_in_scope.is_empty() {
+                        if values
+                            .iter().any(|value| !pref_in_scope(scope.clone(), value.get_type())) {
                             tracing::info!(
                         "@LOG: PreferenceReader::put_preferences() debug scope: {:?}, values: {:?}",
                         scope,
···
                             .collect::<Vec<i32>>();
                         // replace all prefs in given namespace
                         if !all_pref_ids_in_namespace.is_empty() {
-                            delete(AccountPrefSchema::account_pref)
+                            _ = delete(AccountPrefSchema::account_pref)
                                 .filter(AccountPrefSchema::id.eq_any(all_pref_ids_in_namespace))
                                 .execute(conn)?;
                         }
                         if !put_prefs.is_empty() {
-                            insert_into(AccountPrefSchema::account_pref)
+                            _ = insert_into(AccountPrefSchema::account_pref)
                                 .values(
                                     put_prefs
                                         .into_iter()

src/actor_store/record.rs

···
 
 impl RecordReader {
     /// Create a new record handler.
-    pub(crate) fn new(
+    pub(crate) const fn new(
         did: String,
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
···
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
         use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
-            include_soft_deleted
-        } else {
-            false
-        };
+        let include_soft_deleted: bool = include_soft_deleted.unwrap_or(false);
         let mut builder = RecordSchema::record
             .inner_join(RepoBlockSchema::repo_block.on(RepoBlockSchema::cid.eq(RecordSchema::cid)))
             .limit(limit)
···
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
         use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
-            include_soft_deleted
-        } else {
-            false
-        };
+        let include_soft_deleted: bool = include_soft_deleted.unwrap_or(false);
         let mut builder = RecordSchema::record
             .inner_join(RepoBlockSchema::repo_block.on(RepoBlockSchema::cid.eq(RecordSchema::cid)))
             .select((Record::as_select(), RepoBlock::as_select()))
···
     ) -> Result<bool> {
         use rsky_pds::schema::pds::record::dsl as RecordSchema;
 
-        let include_soft_deleted: bool = if let Some(include_soft_deleted) = include_soft_deleted {
-            include_soft_deleted
-        } else {
-            false
-        };
+        let include_soft_deleted: bool = include_soft_deleted.unwrap_or(false);
         let mut builder = RecordSchema::record
             .select(RecordSchema::uri)
             .filter(RecordSchema::uri.eq(uri))
···
             .interact(move |conn| builder.first::<String>(conn).optional())
             .await
             .expect("Failed to check record")?;
-        Ok(!!record_uri.is_some())
+        Ok(record_uri.is_some())
     }
 
     /// Get the takedown status of a record.
···
             })
             .await
             .expect("Failed to get takedown status")?;
-        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)
-        }
+        res.map_or_else(
+            || Ok(None),
+            |res| {
+                res.map_or_else(
+                    || {
+                        Ok(Some(StatusAttr {
+                            applied: false,
+                            r#ref: None,
+                        }))
+                    },
+                    |takedown_ref| {
+                        Ok(Some(StatusAttr {
+                            applied: true,
+                            r#ref: Some(takedown_ref),
+                        }))
+                    },
+                )
+            },
+        )
     }
 
     /// Get the current CID for a record URI.
···
         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 indexed_at = timestamp.unwrap_or_else(rsky_common::now);
         let row = Record {
             did: self.did.clone(),
             uri: uri.to_string(),
···
             .get()
             .await?
             .interact(move |conn| {
-                insert_into(RecordSchema::record)
+                _ = insert_into(RecordSchema::record)
                     .values(row)
                     .on_conflict(RecordSchema::uri)
                     .do_update()
···
         if let Some(record) = record {
             // Maintain backlinks
             let backlinks = get_backlinks(&uri, &record)?;
-            if let WriteOpAction::Update = action {
+            if action == WriteOpAction::Update {
                 // 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?;
···
             .get()
             .await?
             .interact(move |conn| {
-                delete(RecordSchema::record)
+                _ = delete(RecordSchema::record)
                     .filter(RecordSchema::uri.eq(&uri))
                     .execute(conn)?;
-                delete(BacklinkSchema::backlink)
+                _ = delete(BacklinkSchema::backlink)
                     .filter(BacklinkSchema::uri.eq(&uri))
                     .execute(conn)?;
                 tracing::debug!(
···
             .get()
             .await?
             .interact(move |conn| {
-                delete(BacklinkSchema::backlink)
+                _ = delete(BacklinkSchema::backlink)
                     .filter(BacklinkSchema::uri.eq(uri))
                     .execute(conn)?;
                 Ok(())
···
 
     /// Add backlinks to the database.
     pub(crate) async fn add_backlinks(&self, backlinks: Vec<Backlink>) -> Result<()> {
-        if backlinks.len() == 0 {
+        if backlinks.is_empty() {
             Ok(())
         } else {
             use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema;
···
                 .get()
                 .await?
                 .interact(move |conn| {
-                    insert_or_ignore_into(BacklinkSchema::backlink)
+                    _ = insert_or_ignore_into(BacklinkSchema::backlink)
                         .values(&backlinks)
                         .execute(conn)?;
                     Ok(())
···
         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()),
-            },
+            true => takedown
+                .r#ref
+                .map_or_else(|| Some(rsky_common::now()), Some),
             false => None,
         };
         let uri_string = uri.to_string();
···
             .get()
             .await?
             .interact(move |conn| {
-                update(RecordSchema::record)
+                _ = update(RecordSchema::record)
                     .filter(RecordSchema::uri.eq(uri_string))
                     .set(RecordSchema::takedownRef.eq(takedown_ref))
                     .execute(conn)?;

src/actor_store/sql_blob.rs

···
 #![expect(
     clippy::pub_use,
     clippy::single_char_lifetime_names,
-    unused_qualifications
+    unused_qualifications,
+    unnameable_types
 )]
 use anyhow::{Context, Result};
 use cidv10::Cid;
···
 }
 
 impl ByteStream {
-    pub fn new(bytes: Vec<u8>) -> Self {
+    pub const fn new(bytes: Vec<u8>) -> Self {
         Self { bytes }
     }
 
···
 
 impl BlobStoreSql {
     /// Create a new SQL-based blob store for the given DID
-    pub fn new(
+    pub const fn new(
         did: String,
         db: deadpool_diesel::Pool<
             deadpool_diesel::Manager<SqliteConnection>,
             deadpool_diesel::sqlite::Object,
         >,
     ) -> Self {
-        BlobStoreSql { db, did }
+        Self { db, did }
     }
 
     // /// Create a factory function for blob stores
···
         self.put_permanent_with_mime(
             Cid::try_from(format!("bafy{}", key)).unwrap_or_else(|_| Cid::default()),
             bytes,
-            "application/octet-stream".to_string(),
+            "application/octet-stream".to_owned(),
         )
         .await?;
 
···
         let bytes_len = bytes.len() as i32;
 
         // Store directly in the database
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
 
     /// Store a blob directly as permanent
     pub async fn put_permanent(&self, cid: Cid, bytes: Vec<u8>) -> Result<()> {
-        self.put_permanent_with_mime(cid, bytes, "application/octet-stream".to_string())
+        self.put_permanent_with_mime(cid, bytes, "application/octet-stream".to_owned())
             .await
     }
 
···
         let did_clone = self.did.clone();
 
         // Update the quarantine flag in the database
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
         let did_clone = self.did.clone();
 
         // Update the quarantine flag in the database
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
         let did_clone = self.did.clone();
 
         // Delete from database
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {
···
         let did_clone = self.did.clone();
 
         // Delete all blobs in one operation
-        self.db
+        _ = self
+            .db
             .get()
             .await?
             .interact(move |conn| {

src/actor_store/sql_repo.rs

···
         cid: &'life Cid,
     ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'life>> {
         let did: String = self.did.clone();
-        let cid = cid.clone();
+        let cid = *cid;
 
         Box::pin(async move {
             use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
             let cached = {
                 let cache_guard = self.cache.read().await;
-                cache_guard.get(cid).map(|v| v.clone())
+                cache_guard.get(cid).cloned()
             };
             if let Some(cached_result) = cached {
-                return Ok(Some(cached_result.clone()));
+                return Ok(Some(cached_result));
             }
 
             let found: Option<Vec<u8>> = self
···
             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))
+            let stream: Vec<_> = stream::iter(missing_strings.chunks(500))
                 .then(|batch| {
                     let this_did = did.clone();
                     let blocks = Arc::clone(&blocks);
···
                 })
                 .try_collect()
                 .await?;
+            drop(stream);
 
             // Extract values from synchronization primitives
             let mut blocks = Arc::try_unwrap(blocks)
···
         Box::pin(async move {
             use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
-            self.db
+            _ = self
+                .db
                 .interact(move |conn| {
                     insert_into(RepoBlockSchema::repo_block)
                         .values((
···
                 blocks.chunks(50).map(|chunk| chunk.to_vec()).collect();
 
             for batch in chunks {
-                self.db
+                _ = self
+                    .db
                     .interact(move |conn| {
                         insert_or_ignore_into(RepoBlockSchema::repo_block)
                             .values(&batch)
···
 
             let is_create = is_create.unwrap_or(false);
             if is_create {
-                self.db
+                _ = self
+                    .db
                     .interact(move |conn| {
                         insert_into(RepoRootSchema::repo_root)
                             .values((
···
                     .await
                     .expect("Failed to create root")?;
             } else {
-                self.db
+                _ = self
+                    .db
                     .interact(move |conn| {
                         update(RepoRootSchema::repo_root)
                             .filter(RepoRootSchema::did.eq(did))
···
 impl SqlRepoReader {
     pub fn new(did: String, now: Option<String>, db: deadpool_diesel::sqlite::Object) -> Self {
         let now = now.unwrap_or_else(rsky_common::now);
-        SqlRepoReader {
+        Self {
             cache: Arc::new(RwLock::new(BlockMap::new())),
             root: None,
             rev: None,
···
         use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema;
 
         let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();
-        self.db
+        _ = self
+            .db
             .interact(move |conn| {
                 delete(RepoBlockSchema::repo_block)
                     .filter(RepoBlockSchema::did.eq(did))

src/auth.rs

···
     use crate::schema::pds::oauth_used_jtis::dsl as JtiSchema;
 
     // Check if JTI has been used before
-    let jti_string = jti.to_string();
+    let jti_string = jti.to_owned();
     let jti_used = state
         .db
         .get()
···
         .unwrap_or_else(|| timestamp.checked_add(60).unwrap_or(timestamp));
 
     // Convert SQLx INSERT to Diesel
-    let jti_str = jti.to_string();
+    let jti_str = jti.to_owned();
     let thumbprint_str = calculated_thumbprint.to_string();
-    state
+    let _ = state
         .db
         .get()
         .await

src/main.rs

···
             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(
+            drop(actor_pools.insert(
                 did.to_string(),
                 ActorPools {
                     repo: actor_repo_pool,
                     blob: actor_blob_pool,
                 },
-            );
+            ));
         }
     }
     // Apply pending migrations
···
         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 = conn.interact(move |conn| {
         diesel::sql_query(
             "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count",
···
         let uuid = Uuid::new_v4().to_string();
 
         let uuid_clone = uuid.clone();
-        conn.interact(move |conn| {
-            diesel::sql_query(
+        _ = 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)
         .execute(conn)
         .context("failed to create new invite code")
         .expect("should be able to create invite code")
-        });
+            })
+            .await
+            .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/oauth.rs

···
 //! OAuth endpoints
-
+#![allow(unnameable_types, unused_qualifications)]
 use crate::metrics::AUTH_FAILED;
 use crate::{AppConfig, AppState, Client, Error, Result, SigningKey};
 use anyhow::{Context as _, anyhow};

src/schema.rs

···
+#![allow(unnameable_types, unused_qualifications)]
 pub mod pds {
 
     // Legacy tables