chore: formatting & clippy fixes i've been neglecting

consumer/src/db/copy.rs

···
 use deadpool_postgres::Transaction;
 use futures::pin_mut;
 use ipld_core::cid::Cid;
+use lexica::StrongRef;
 use tokio_postgres::binary_copy::BinaryCopyInWriter;
 use tokio_postgres::types::Type;
-use lexica::StrongRef;
 
 // StrongRefs are used in both likes and reposts
 const STRONGREF_TYPES: &[Type] = &[
···
     Type::TEXT,
     Type::TIMESTAMP,
 ];
-type StrongRefRow = (
-    String,
-    StrongRef,
-    Option<StrongRef>,
-    DateTime<Utc>,
-);
+type StrongRefRow = (String, StrongRef, Option<StrongRef>, DateTime<Utc>);
 
 // SubjectRefs are used in both blocks and follows
 const SUBJECT_TYPES: &[Type] = &[Type::TEXT, Type::TEXT, Type::TEXT, Type::TIMESTAMP];

consumer/src/db/record.rs

···
 
     conn.execute(
         include_str!("sql/bookmarks_upsert.sql"),
-        &[&repo, &rkey, &rec.subject, &rec_type, &rec.tags, &rec.created_at],
+        &[
+            &repo,
+            &rkey,
+            &rec.subject,
+            &rec_type,
+            &rec.tags,
+            &rec.created_at,
+        ],
     )
     .await
 }

consumer/src/firehose/mod.rs

···
                         }
                         "#sync" => {
                             counter!("firehose_events.total", "event" => "sync").increment(1);
-                            let event: AtpSyncEvent =
-                                serde_ipld_dagcbor::from_reader(&mut reader)?;
+                            let event: AtpSyncEvent = serde_ipld_dagcbor::from_reader(&mut reader)?;
 
                             // increment the seq
                             if self.seq < event.seq {

consumer/src/indexer/mod.rs

···
     rc: &mut MultiplexedConnection,
     sync: AtpSyncEvent,
 ) -> eyre::Result<()> {
-    let Some((sync_state, Some(current_rev))) = db::actor_get_repo_status(conn, &sync.did).await? else {
+    let Some((sync_state, Some(current_rev))) = db::actor_get_repo_status(conn, &sync.did).await?
+    else {
         return Ok(());
     };
 
···
             redis::AsyncTypedCommands::del(rc, format!("profile#{repo}")).await?;
             db::chat_decl_delete(conn, repo).await?
         }
-        CollectionType::CommunityLexiconBookmark => {
-            db::bookmark_delete(conn, rkey, repo).await?
-        }
+        CollectionType::CommunityLexiconBookmark => db::bookmark_delete(conn, rkey, repo).await?,
         _ => unreachable!(),
     };
 

consumer/src/indexer/types.rs

···
     #[serde(rename = "chat.bsky.actor.declaration")]
     ChatBskyActorDeclaration(records::ChatBskyActorDeclaration),
     #[serde(rename = "community.lexicon.bookmarks.bookmark")]
-    CommunityLexiconBookmark(lexica::community_lexicon::bookmarks::Bookmark)
+    CommunityLexiconBookmark(lexica::community_lexicon::bookmarks::Bookmark),
 }
 
 #[derive(Debug, PartialOrd, PartialEq, Deserialize, Serialize)]

consumer/src/utils.rs

···
-use serde::{Deserialize, Deserializer};
 use lexica::{Blob, StrongRef};
+use serde::{Deserialize, Deserializer};
 
 // see https://deer.social/profile/did:plc:63y3oh7iakdueqhlj6trojbq/post/3ltuv4skhqs2h
 pub fn safe_string<'de, D: Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
···
     blob.map(|blob| blob.cid.to_string())
 }
 
-pub fn strongref_to_parts(
-    strongref: Option<&StrongRef>,
-) -> (Option<String>, Option<String>) {
+pub fn strongref_to_parts(strongref: Option<&StrongRef>) -> (Option<String>, Option<String>) {
     strongref
         .map(|sr| (sr.uri.clone(), sr.cid.to_string()))
         .unzip()

lexica/src/app_bsky/feed.rs

···
     #[serde(rename = "app.bsky.feed.defs#skeletonReasonPin")]
     Pin {},
     #[serde(rename = "app.bsky.feed.defs#skeletonReasonRepost")]
-    Repost {
-        repost: String,
-    },
+    Repost { repost: String },
 }

lexica/src/community_lexicon/bookmarks.rs

···
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub tags: Vec<String>,
     pub created_at: DateTime<Utc>,
-}
+}

lexica/src/community_lexicon/mod.rs

···
-pub mod bookmarks;
+pub mod bookmarks;

lexica/src/utils.rs

···
     LinkRef {
         link: inp.to_string(),
     }
-        .serialize(serializer)
-}
+    .serialize(serializer)
+}

parakeet-db/src/models.rs

···
     pub indexed_at: NaiveDateTime,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable, Associations)]
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable, Associations,
+)]
 #[diesel(table_name = crate::schema::labeler_defs)]
 #[diesel(belongs_to(LabelerService, foreign_key = labeler))]
 #[diesel(check_for_backend(diesel::pg::Pg))]
···
     pub subject_cid: Option<String>,
     pub subject_type: &'a str,
     pub tags: Vec<String>,
-}
+}

parakeet-db/src/types.rs

···
                 use std::io::Write;
                 let val = self.to_string();
 
-                out.write(val.as_bytes())?;
+                out.write_all(val.as_bytes())?;
                 Ok(diesel::serialize::IsNull::No)
             }
         }

parakeet/src/xrpc/app_bsky/bookmark.rs

···
 use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
 use lexica::app_bsky::bookmark::{BookmarkView, BookmarkViewItem};
+use lexica::StrongRef;
 use parakeet_db::{models, schema};
 use serde::{Deserialize, Serialize};
-use lexica::StrongRef;
 
 const BSKY_ALLOWED_TYPES: &[&str] = &["app.bsky.feed.post"];
 
···
             // otherwise just ditch. we should have one.
             let cid = bookmark.subject_cid.or(maybe_cid)?;
 
-            let item = maybe_item.map(BookmarkViewItem::Post).unwrap_or(
-                BookmarkViewItem::NotFound {
-                    uri: bookmark.subject.clone(),
-                    not_found: true,
-                },
-            );
+            let item =
+                maybe_item
+                    .map(BookmarkViewItem::Post)
+                    .unwrap_or(BookmarkViewItem::NotFound {
+                        uri: bookmark.subject.clone(),
+                        not_found: true,
+                    });
 
             let subject = StrongRef::new_from_str(bookmark.subject, &cid).ok()?;
 

parakeet/src/xrpc/app_bsky/graph/relations.rs

···
         .map(|(last, _)| last.timestamp_millis().to_string());
 
     let dids = results.iter().map(|(_, did)| did.clone()).collect();
-    
+
     let profiles = hyd.hydrate_profiles(dids).await;
     let blocks = profiles.into_values().collect::<Vec<_>>();
 

parakeet/src/xrpc/app_bsky/mod.rs

···
 
 async fn not_implemented() -> axum::http::StatusCode {
     axum::http::StatusCode::NOT_IMPLEMENTED
-}
+}