chore: clippy and formatting

consumer/src/db/gates.rs

···
         })
         .collect::<Vec<_>>();
 
-    let allow: HashSet<_> = HashSet::from_iter(allow.into_iter().map(|v| v.as_str()));
+    let allow: HashSet<_> = HashSet::from_iter(allow.iter().map(|v| v.as_str()));
 
     if allow.contains(THREADGATE_RULE_FOLLOWER) && !dids.is_empty() {
         let current_dids: Vec<_> = dids.iter().collect();

parakeet/src/cache.rs

···
     type Val = V;
 
     async fn get(&mut self, key: &Self::Key) -> Option<Self::Val> {
-        let res: Option<Vec<u8>> = redis::AsyncCommands::get(&mut self.conn, &key).await.ok()?;
+        let res: Option<Vec<u8>> = redis::AsyncCommands::get(&mut self.conn, key).await.ok()?;
 
         match serde_ipld_dagcbor::from_slice(&res?) {
             Ok(v) => Some(v),
···
     }
 
     async fn remove(&mut self, key: &Self::Key) -> Option<Self::Val> {
-        let res: Option<Vec<u8>> = redis::AsyncCommands::get_del(&mut self.conn, &key)
+        let res: Option<Vec<u8>> = redis::AsyncCommands::get_del(&mut self.conn, key)
             .await
             .ok()?;
 

parakeet/src/db.rs

···
 use diesel::prelude::*;
 use diesel::sql_types::{Array, Bool, Integer, Nullable, Text};
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
-use tracing::instrument;
-use parakeet_db::{schema, types};
 use parakeet_db::models::TextArray;
+use parakeet_db::{schema, types};
+use tracing::instrument;
 
 #[instrument(skip_all)]
 pub async fn get_actor_status(

parakeet/src/hydration/starter_packs.rs

···
         let creator = self.hydrate_profile_basic(sp.owner.clone()).await?;
         let list = self.hydrate_list_basic(sp.list.clone()).await;
 
-        let feeds = sp
-            .feeds
-            .clone()
-            .unwrap_or_default();
-        let feeds = self.hydrate_feedgens(feeds.into()).await.into_values().collect();
+        let feeds = sp.feeds.clone().unwrap_or_default();
+        let feeds = self
+            .hydrate_feedgens(feeds.into())
+            .await
+            .into_values()
+            .collect();
 
         Some(build_spview(sp, creator, labels, list, feeds))
     }

parakeet/src/loaders.rs

···
     ) -> Dataloaders {
         Dataloaders {
             embed: new_plc_loader(EmbedLoader(pool.clone()), &rc, "embed", 3600),
-            feedgen: new_plc_loader(FeedGenLoader(pool.clone(), idxc.clone()), &rc, "feedgen", 600),
+            feedgen: new_plc_loader(FeedGenLoader(pool.clone()), &rc, "feedgen", 600),
             handle: new_plc_loader(HandleLoader(pool.clone()), &rc, "handle", 60),
             label: LabelLoader(pool.clone()), // CARE: never cache this.
-            labeler: new_plc_loader(LabelServiceLoader(pool.clone(), idxc.clone()), &rc, "labeler", 600),
+            labeler: new_plc_loader(LabelServiceLoader(pool.clone()), &rc, "labeler", 600),
             like: NonCachedLoader::new(LikeLoader(idxc.clone())),
             like_state: LikeRecordLoader(pool.clone()),
             list: new_plc_loader(ListLoader(pool.clone()), &rc, "list", 600),
···
     }
 }
 
-pub struct FeedGenLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
+pub struct FeedGenLoader(Pool<AsyncPgConnection>);
 impl BatchFn<String, models::FeedGen> for FeedGenLoader {
     #[instrument(name = "FeedGenLoader", skip_all)]
     async fn load(&mut self, keys: &[String]) -> HashMap<String, models::FeedGen> {
···
     }
 }
 
-pub struct LabelServiceLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
+pub struct LabelServiceLoader(Pool<AsyncPgConnection>);
 type LabelServiceLoaderRet = (models::LabelerService, Vec<models::LabelDefinition>);
 impl BatchFn<String, LabelServiceLoaderRet> for LabelServiceLoader {
     #[instrument(name = "LabelServiceLoader", skip_all)]

parakeet/src/xrpc/app_bsky/bookmark.rs

···
         rkey: None,
         subject: &form.uri,
         subject_cid: Some(form.cid),
-        subject_type: &parts[1],
+        subject_type: parts[1],
         tags: vec![],
     };
 

parakeet/src/xrpc/app_bsky/feed/posts.rs

···
 
 #[derive(Debug, Default, Eq, PartialEq, Deserialize)]
 #[serde(rename_all = "snake_case")]
+#[allow(clippy::enum_variant_names)]
 pub enum GetAuthorFeedFilter {
     #[default]
     PostsWithReplies,
···
         if let Some(psr) = crate::db::get_profile_state(&mut conn, &auth.0, &did).await? {
             if psr.blocked.unwrap_or_default() {
                 // they block us
-                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedByActor", None))
+                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedByActor", None));
             } else if psr.blocking.is_some() {
                 // we block them
-                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedActor", None))
+                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedActor", None));
             }
         }
     }

parakeet/src/xrpc/app_bsky/unspecced/thread_v2.rs

···
         .hydrate_posts(reply_uris)
         .await
         .into_iter()
-        .filter(|(_, post)| match &post.author.viewer {
-            Some(viewer) if viewer.blocked_by || viewer.blocking.is_some() => false,
-            _ => true,
-        })
+        .filter(|(_, post)| matches!(&post.author.viewer, Some(viewer) if viewer.blocked_by || viewer.blocking.is_some()))
         .map(|(uri, post)| {
             let post = ThreadItemPost {
                 post,