chore: formatting and linting

src/bin/quickdid.rs

···
                 );
                 println!();
                 println!("    JETSTREAM:");
-                println!(
-                    "    JETSTREAM_ENABLED       Enable Jetstream consumer (default: false)"
-                );
+                println!("    JETSTREAM_ENABLED       Enable Jetstream consumer (default: false)");
                 println!(
                     "    JETSTREAM_HOSTNAME      Jetstream hostname (default: jetstream.atproto.tools)"
                 );
···
                         compression: false,
                         zstd_dictionary_location: String::new(),
                         jetstream_hostname: jetstream_hostname.clone(),
-                        collections: vec![],  // Listen to all collections
+                        collections: vec![], // Listen to all collections
                         dids: vec![],
                         max_message_size_bytes: None,
                         cursor: None,

src/config.rs

···
             proactive_refresh_threshold: parse_env("PROACTIVE_REFRESH_THRESHOLD", 0.8)?,
             static_files_dir: get_env_or_default("STATIC_FILES_DIR", Some("www")).unwrap(),
             jetstream_enabled: parse_env("JETSTREAM_ENABLED", false)?,
-            jetstream_hostname: get_env_or_default("JETSTREAM_HOSTNAME", Some("jetstream.atproto.tools")).unwrap(),
+            jetstream_hostname: get_env_or_default(
+                "JETSTREAM_HOSTNAME",
+                Some("jetstream.atproto.tools"),
+            )
+            .unwrap(),
         };
 
         // Calculate the Cache-Control header value if enabled

src/handle_resolver/memory.rs

···
     async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
         // Normalize the handle to lowercase
         let handle = handle.to_lowercase();
-        
+
         // Update the in-memory cache
         {
             let mut cache = self.cache.write().await;
···
             );
             self.metrics.incr("resolver.memory.set").await;
             tracing::debug!("Set handle {} -> DID {} in memory cache", handle, did);
-            
+
             // Track cache size
             let cache_size = cache.len() as u64;
             self.metrics
                 .gauge("resolver.memory.cache_entries", cache_size)
                 .await;
         }
-        
+
         // Chain to inner resolver
         self.inner.set(&handle, did).await
     }

src/handle_resolver/redis.rs

···
 use crate::handle_resolution_result::HandleResolutionResult;
 use crate::metrics::SharedMetricsPublisher;
 use async_trait::async_trait;
-use atproto_identity::resolve::{parse_input, InputType};
+use atproto_identity::resolve::{InputType, parse_input};
 use deadpool_redis::{Pool as RedisPool, redis::AsyncCommands};
 use metrohash::MetroHash64;
 use std::hash::Hasher as _;
···
     /// This method removes both the handle->DID mapping and the reverse DID->handle mapping.
     async fn purge_handle(&self, handle: &str) -> Result<(), HandleResolverError> {
         let handle_key = self.make_key(handle);
-        
+
         match self.pool.get().await {
             Ok(mut conn) => {
                 // First, try to get the cached result to find the associated DID
···
                     if let Ok(cached_result) = HandleResolutionResult::from_bytes(&cached_bytes) {
                         if let Some(did) = cached_result.to_did() {
                             let did_key = self.make_key(&did);
-                            
+
                             // Delete both the handle key and the DID key
                             let _: Result<(), _> = conn.del(&[&handle_key, &did_key]).await;
-                            
+
                             tracing::debug!("Purged handle {} and associated DID {}", handle, did);
-                            self.metrics.incr("resolver.redis.purge_handle_success").await;
+                            self.metrics
+                                .incr("resolver.redis.purge_handle_success")
+                                .await;
                         } else {
                             // Just delete the handle key if no DID was resolved
                             let _: Result<(), _> = conn.del(&handle_key).await;
                             tracing::debug!("Purged unresolved handle {}", handle);
-                            self.metrics.incr("resolver.redis.purge_handle_unresolved").await;
+                            self.metrics
+                                .incr("resolver.redis.purge_handle_unresolved")
+                                .await;
                         }
                     } else {
                         // If we can't deserialize, just delete the handle key
                         let _: Result<(), _> = conn.del(&handle_key).await;
                         tracing::warn!("Purged handle {} with undeserializable data", handle);
-                        self.metrics.incr("resolver.redis.purge_handle_corrupt").await;
+                        self.metrics
+                            .incr("resolver.redis.purge_handle_corrupt")
+                            .await;
                     }
                 } else {
                     tracing::debug!("Handle {} not found in cache for purging", handle);
-                    self.metrics.incr("resolver.redis.purge_handle_not_found").await;
+                    self.metrics
+                        .incr("resolver.redis.purge_handle_not_found")
+                        .await;
                 }
-                
+
                 Ok(())
             }
             Err(e) => {
                 tracing::warn!("Failed to get Redis connection for purging: {}", e);
-                self.metrics.incr("resolver.redis.purge_connection_error").await;
-                Err(HandleResolverError::ResolutionFailed(format!("Redis connection error: {}", e)))
+                self.metrics
+                    .incr("resolver.redis.purge_connection_error")
+                    .await;
+                Err(HandleResolverError::ResolutionFailed(format!(
+                    "Redis connection error: {}",
+                    e
+                )))
             }
         }
     }
···
     /// This method removes both the DID->handle mapping and the handle->DID mapping.
     async fn purge_did(&self, did: &str) -> Result<(), HandleResolverError> {
         let did_key = self.make_key(did);
-        
+
         match self.pool.get().await {
             Ok(mut conn) => {
                 // First, try to get the associated handle from the reverse mapping
···
                 if let Some(handle_bytes) = handle_bytes {
                     if let Ok(handle) = String::from_utf8(handle_bytes) {
                         let handle_key = self.make_key(&handle);
-                        
+
                         // Delete both the DID key and the handle key
                         let _: Result<(), _> = conn.del(&[&did_key, &handle_key]).await;
-                        
+
                         tracing::debug!("Purged DID {} and associated handle {}", did, handle);
                         self.metrics.incr("resolver.redis.purge_did_success").await;
                     } else {
···
                     }
                 } else {
                     tracing::debug!("DID {} not found in cache for purging", did);
-                    self.metrics.incr("resolver.redis.purge_did_not_found").await;
+                    self.metrics
+                        .incr("resolver.redis.purge_did_not_found")
+                        .await;
                 }
-                
+
                 Ok(())
             }
             Err(e) => {
                 tracing::warn!("Failed to get Redis connection for purging: {}", e);
-                self.metrics.incr("resolver.redis.purge_connection_error").await;
-                Err(HandleResolverError::ResolutionFailed(format!("Redis connection error: {}", e)))
+                self.metrics
+                    .incr("resolver.redis.purge_connection_error")
+                    .await;
+                Err(HandleResolverError::ResolutionFailed(format!(
+                    "Redis connection error: {}",
+                    e
+                )))
             }
         }
     }
···
                             self.metrics.incr("resolver.redis.cache_set_error").await;
                         } else {
                             self.metrics.incr("resolver.redis.cache_set").await;
-                            
+
                             // For successful resolutions, also store reverse DID -> handle mapping
                             if let Ok((did, _)) = &result {
                                 let did_key = self.make_key(did);
                                 if let Err(e) = conn
-                                    .set_ex::<_, _, ()>(&did_key, handle.as_bytes(), self.ttl_seconds())
+                                    .set_ex::<_, _, ()>(
+                                        &did_key,
+                                        handle.as_bytes(),
+                                        self.ttl_seconds(),
+                                    )
                                     .await
                                 {
-                                    tracing::warn!("Failed to cache reverse DID->handle mapping in Redis: {}", e);
-                                    self.metrics.incr("resolver.redis.reverse_cache_set_error").await;
+                                    tracing::warn!(
+                                        "Failed to cache reverse DID->handle mapping in Redis: {}",
+                                        e
+                                    );
+                                    self.metrics
+                                        .incr("resolver.redis.reverse_cache_set_error")
+                                        .await;
                                 } else {
-                                    tracing::debug!("Cached reverse mapping for DID {}: {}", did, handle);
+                                    tracing::debug!(
+                                        "Cached reverse mapping for DID {}: {}",
+                                        did,
+                                        handle
+                                    );
                                     self.metrics.incr("resolver.redis.reverse_cache_set").await;
                                 }
                             }
···
 
     async fn purge(&self, subject: &str) -> Result<(), HandleResolverError> {
         // Use atproto_identity's parse_input to properly identify the input type
-        let parsed_input = parse_input(subject).map_err(|_| HandleResolverError::InvalidSubject(subject.to_string()))?;
+        let parsed_input = parse_input(subject)
+            .map_err(|_| HandleResolverError::InvalidSubject(subject.to_string()))?;
         match parsed_input {
             InputType::Handle(handle) => {
                 // It's a handle, purge using the lowercase version
···
                 let resolution_result = match HandleResolutionResult::success(did) {
                     Ok(res) => res,
                     Err(e) => {
-                        tracing::warn!("Failed to create resolution result for set operation: {}", e);
-                        self.metrics.incr("resolver.redis.set_result_create_error").await;
-                        return Err(HandleResolverError::InvalidSubject(
-                            format!("Failed to create resolution result: {}", e)
-                        ));
+                        tracing::warn!(
+                            "Failed to create resolution result for set operation: {}",
+                            e
+                        );
+                        self.metrics
+                            .incr("resolver.redis.set_result_create_error")
+                            .await;
+                        return Err(HandleResolverError::InvalidSubject(format!(
+                            "Failed to create resolution result: {}",
+                            e
+                        )));
                     }
                 };
 
···
                         {
                             tracing::warn!("Failed to set handle->DID mapping in Redis: {}", e);
                             self.metrics.incr("resolver.redis.set_cache_error").await;
-                            return Err(HandleResolverError::ResolutionFailed(
-                                format!("Failed to set cache: {}", e)
-                            ));
+                            return Err(HandleResolverError::ResolutionFailed(format!(
+                                "Failed to set cache: {}",
+                                e
+                            )));
                         }
 
                         // Set the reverse DID -> handle mapping
···
                             .await
                         {
                             tracing::warn!("Failed to set DID->handle mapping in Redis: {}", e);
-                            self.metrics.incr("resolver.redis.set_reverse_cache_error").await;
+                            self.metrics
+                                .incr("resolver.redis.set_reverse_cache_error")
+                                .await;
                             // Don't fail the operation, but log the warning
                         }
 
···
                         Ok(())
                     }
                     Err(e) => {
-                        tracing::warn!("Failed to serialize resolution result for set operation: {}", e);
-                        self.metrics.incr("resolver.redis.set_serialize_error").await;
-                        Err(HandleResolverError::InvalidSubject(
-                            format!("Failed to serialize: {}", e)
-                        ))
+                        tracing::warn!(
+                            "Failed to serialize resolution result for set operation: {}",
+                            e
+                        );
+                        self.metrics
+                            .incr("resolver.redis.set_serialize_error")
+                            .await;
+                        Err(HandleResolverError::InvalidSubject(format!(
+                            "Failed to serialize: {}",
+                            e
+                        )))
                     }
                 }
             }
             Err(e) => {
                 tracing::warn!("Failed to get Redis connection for set operation: {}", e);
-                self.metrics.incr("resolver.redis.set_connection_error").await;
-                Err(HandleResolverError::ResolutionFailed(
-                    format!("Redis connection error: {}", e)
-                ))
+                self.metrics
+                    .incr("resolver.redis.set_connection_error")
+                    .await;
+                Err(HandleResolverError::ResolutionFailed(format!(
+                    "Redis connection error: {}",
+                    e
+                )))
             }
         }
     }
···
             let mut h = MetroHash64::default();
             h.write(test_handle.as_bytes());
             let handle_key = format!("{}{}", test_prefix, h.finish());
-            
+
             let mut h2 = MetroHash64::default();
             h2.write(expected_did.as_bytes());
             let did_key = format!("{}{}", test_prefix, h2.finish());
-            
+
             // Check handle -> DID mapping exists
             let handle_exists: bool = conn.exists(&handle_key).await.unwrap();
             assert!(handle_exists, "Handle key should exist in cache");
-            
+
             // Check DID -> handle mapping exists
             let did_exists: bool = conn.exists(&did_key).await.unwrap();
             assert!(did_exists, "DID key should exist in cache");
-            
+
             // Test purge by handle using the trait method
             redis_resolver.purge(test_handle).await.unwrap();
-            
+
             // Verify both keys were deleted
             let handle_exists_after: bool = conn.exists(&handle_key).await.unwrap();
-            assert!(!handle_exists_after, "Handle key should be deleted after purge");
-            
+            assert!(
+                !handle_exists_after,
+                "Handle key should be deleted after purge"
+            );
+
             let did_exists_after: bool = conn.exists(&did_key).await.unwrap();
             assert!(!did_exists_after, "DID key should be deleted after purge");
         }
···
 
         // Test purge by DID using the trait method
         redis_resolver.purge(expected_did).await.unwrap();
-        
+
         // Verify both keys were deleted again
         if let Ok(mut conn) = pool.get().await {
             let mut h = MetroHash64::default();
             h.write(test_handle.as_bytes());
             let handle_key = format!("{}{}", test_prefix, h.finish());
-            
+
             let mut h2 = MetroHash64::default();
             h2.write(expected_did.as_bytes());
             let did_key = format!("{}{}", test_prefix, h2.finish());
-            
+
             let handle_exists: bool = conn.exists(&handle_key).await.unwrap();
-            assert!(!handle_exists, "Handle key should be deleted after DID purge");
-            
+            assert!(
+                !handle_exists,
+                "Handle key should be deleted after DID purge"
+            );
+
             let did_exists: bool = conn.exists(&did_key).await.unwrap();
             assert!(!did_exists, "DID key should be deleted after DID purge");
         }
···
 
         // Test different input formats
         let test_cases = vec![
-            ("alice.bsky.social", "alice.bsky.social"),  // Handle
-            ("ALICE.BSKY.SOCIAL", "alice.bsky.social"),  // Handle (uppercase)
-            ("did:plc:abc123", "did:plc:abc123"),        // PLC DID
+            ("alice.bsky.social", "alice.bsky.social"),     // Handle
+            ("ALICE.BSKY.SOCIAL", "alice.bsky.social"),     // Handle (uppercase)
+            ("did:plc:abc123", "did:plc:abc123"),           // PLC DID
             ("did:web:example.com", "did:web:example.com"), // Web DID
         ];
 
···
                 let mut h = MetroHash64::default();
                 h.write(expected_key.as_bytes());
                 let key = format!("{}{}", test_prefix, h.finish());
-                
+
                 // After purge, key should not exist
                 let exists: bool = conn.exists(&key).await.unwrap_or(false);
                 assert!(!exists, "Key for {} should not exist after purge", input);
···
         assert_eq!(resolved_did, test_did);
 
         // Test that uppercase handles are normalized
-        redis_resolver.set("DAVE.BSKY.SOCIAL", "did:plc:dave456").await.unwrap();
+        redis_resolver
+            .set("DAVE.BSKY.SOCIAL", "did:plc:dave456")
+            .await
+            .unwrap();
         let (resolved_did2, _) = redis_resolver.resolve("dave.bsky.social").await.unwrap();
         assert_eq!(resolved_did2, "did:plc:dave456");
 
···
             let mut h = MetroHash64::default();
             h.write(test_handle.as_bytes());
             let handle_key = format!("{}{}", test_prefix, h.finish());
-            
+
             let mut h2 = MetroHash64::default();
             h2.write(test_did.as_bytes());
             let did_key = format!("{}{}", test_prefix, h2.finish());
-            
+
             // Check both keys exist
             let handle_exists: bool = conn.exists(&handle_key).await.unwrap();
             assert!(handle_exists, "Handle key should exist after set");
-            
+
             let did_exists: bool = conn.exists(&did_key).await.unwrap();
             assert!(did_exists, "DID key should exist after set");
-            
+
             // Clean up test data
             let _: Result<(), _> = conn.del(&[&handle_key, &did_key]).await;
         }

src/handle_resolver/sqlite.rs

···
     async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
         // Normalize the handle to lowercase
         let handle = handle.to_lowercase();
-        
+
         // Update the SQLite cache
         if let Ok(mut conn) = self.pool.acquire().await {
             // Create a resolution result for the successful mapping
             let resolution_result = match HandleResolutionResult::success(did) {
                 Ok(res) => res,
                 Err(e) => {
-                    tracing::warn!("Failed to create resolution result for set operation: {}", e);
-                    self.metrics.incr("resolver.sqlite.set_result_create_error").await;
+                    tracing::warn!(
+                        "Failed to create resolution result for set operation: {}",
+                        e
+                    );
+                    self.metrics
+                        .incr("resolver.sqlite.set_result_create_error")
+                        .await;
                     // Still chain to inner resolver even if we can't cache
                     return self.inner.set(&handle, did).await;
                 }
···
                         .duration_since(std::time::UNIX_EPOCH)
                         .unwrap_or_default()
                         .as_secs() as i64;
-                    
+
                     let expires_at = timestamp + self.ttl_seconds as i64;
-                    
+
                     match sqlx::query(
                         "INSERT OR REPLACE INTO handle_resolution_cache (handle, resolved_value, created_at, expires_at) VALUES (?, ?, ?, ?)"
                     )
···
                     }
                 }
                 Err(e) => {
-                    tracing::warn!("Failed to serialize resolution result for set operation: {}", e);
-                    self.metrics.incr("resolver.sqlite.set_serialize_error").await;
+                    tracing::warn!(
+                        "Failed to serialize resolution result for set operation: {}",
+                        e
+                    );
+                    self.metrics
+                        .incr("resolver.sqlite.set_serialize_error")
+                        .await;
                     // Still chain to inner resolver even if serialization fails
                 }
             }
         } else {
             tracing::warn!("Failed to get SQLite connection for set operation");
-            self.metrics.incr("resolver.sqlite.set_connection_error").await;
+            self.metrics
+                .incr("resolver.sqlite.set_connection_error")
+                .await;
         }
-        
+
         // Chain to inner resolver
         self.inner.set(&handle, did).await
     }

src/handle_resolver/traits.rs

···
     #[tokio::test]
     async fn test_default_purge_implementation() {
         let resolver = NoOpTestResolver;
-        
+
         // Default implementation should always return Ok(())
         assert!(resolver.purge("alice.bsky.social").await.is_ok());
         assert!(resolver.purge("did:plc:xyz123").await.is_ok());
···
     #[tokio::test]
     async fn test_default_set_implementation() {
         let resolver = NoOpTestResolver;
-        
+
         // Default implementation should always return Ok(())
-        assert!(resolver.set("alice.bsky.social", "did:plc:xyz123").await.is_ok());
-        assert!(resolver.set("bob.example.com", "did:web:example.com").await.is_ok());
+        assert!(
+            resolver
+                .set("alice.bsky.social", "did:plc:xyz123")
+                .await
+                .is_ok()
+        );
+        assert!(
+            resolver
+                .set("bob.example.com", "did:web:example.com")
+                .await
+                .is_ok()
+        );
         assert!(resolver.set("", "").await.is_ok());
     }
 }

src/jetstream_handler.rs

···
         // Verify the set method was called
         let set_calls = resolver.get_set_calls();
         assert_eq!(set_calls.len(), 1);
-        assert_eq!(set_calls[0], ("alice.bsky.social".to_string(), "did:plc:testuser".to_string()));
+        assert_eq!(
+            set_calls[0],
+            (
+                "alice.bsky.social".to_string(),
+                "did:plc:testuser".to_string()
+            )
+        );
 
         // Verify no purge was called
         let purge_calls = resolver.get_purge_calls();
···
 
         assert_eq!(handler.handler_id(), "quickdid_handler");
     }
-}
+}