chore: cleanup in advance of release

Signed-off-by: Nick Gerakines <[e-mail]>

crates/atproto-identity/src/bin/atproto-identity-resolve.rs

···
 use atproto_identity::{
     config::{CertificateBundles, DnsNameservers, default_env, optional_env, version},
     plc::query as plc_query,
-    resolve::{InputType, HickoryDnsResolver, parse_input, resolve_subject},
+    resolve::{HickoryDnsResolver, InputType, parse_input, resolve_subject},
     web::query as web_query,
 };
 use clap::Parser;
···
     for subject in args.subjects {
         let resolved_did = resolve_subject(&http_client, &dns_resolver, &subject).await;
         let resolved_did = match resolved_did {
-            Ok(value) => {
-                value
-            }
+            Ok(value) => value,
             Err(err) => {
                 eprintln!("{err}");
                 continue;

crates/atproto-identity/src/lib.rs

···
 #[cfg(feature = "lru")]
 pub mod storage_lru;
 pub mod validation;
-pub mod web;
+pub mod web;

crates/atproto-identity/src/resolve.rs

···
 use crate::web::query as web_query;
 
 /// Trait for AT Protocol identity resolution.
-/// 
+///
 /// Implementations must be thread-safe (Send + Sync) and usable in async environments.
 /// This trait provides the core functionality for resolving AT Protocol subjects
 /// (handles or DIDs) to their corresponding DID documents.
···
             tracing::debug!("Using custom DNS nameservers: {:?}", nameservers);
             let nameserver_group = NameServerConfigGroup::from_ips_clear(nameservers, 53, true);
             let resolver_config = ResolverConfig::from_parts(None, vec![], nameserver_group);
-            Resolver::builder_with_config(resolver_config, TokioConnectionProvider::default()).build()
+            Resolver::builder_with_config(resolver_config, TokioConnectionProvider::default())
+                .build()
         } else {
             tracing::debug!("Using system default DNS nameservers");
             Resolver::builder_tokio().unwrap().build()
···
 #[async_trait::async_trait]
 impl DnsResolver for HickoryDnsResolver {
     async fn resolve_txt(&self, domain: &str) -> Result<Vec<String>, ResolveError> {
-        let lookup = self.resolver
+        let lookup = self
+            .resolver
             .txt_lookup(domain)
             .instrument(tracing::info_span!("txt_lookup"))
             .await
             .map_err(|error| ResolveError::DNSResolutionFailed { error })?;
 
-        Ok(lookup
-            .iter()
-            .map(|record| record.to_string())
-            .collect())
+        Ok(lookup.iter().map(|record| record.to_string()).collect())
     }
 }
 
···
 
     let dids = txt_records
         .iter()
-        .filter_map(|record| {
-            record
-                .strip_prefix("did=")
-                .map(|did| did.to_string())
-        })
+        .filter_map(|record| record.strip_prefix("did=").map(|did| did.to_string()))
         .collect::<HashSet<String>>();
 
     if dids.len() > 1 {
···
         InputType::Plc(did) | InputType::Web(did) => Ok(did),
     }
 }
-
 
 /// Core identity resolution components for AT Protocol subjects.
 ///

crates/atproto-oauth-axum/src/bin/atproto-oauth-tool.rs

···
 
 #[cfg(feature = "hickory-dns")]
 use atproto_identity::resolve::HickoryDnsResolver;
+use atproto_identity::resolve::IdentityResolver;
+use atproto_identity::resolve::InnerIdentityResolver;
+use atproto_identity::resolve::SharedIdentityResolver;
 use atproto_oauth::{
     pkce,
     resources::pds_resources,
···
     storage_lru::LruOAuthRequestStorage,
     workflow::{OAuthClient, OAuthRequest, OAuthRequestState, oauth_init, oauth_refresh},
 };
-use atproto_identity::resolve::InnerIdentityResolver;
-use atproto_identity::resolve::SharedIdentityResolver;
-use atproto_identity::resolve::IdentityResolver;
 use atproto_oauth_axum::errors::OAuthLoginError;
 use atproto_oauth_axum::{handle_complete::handle_oauth_callback, handle_jwks::handle_oauth_jwks};
 use atproto_oauth_axum::{handler_metadata::handle_oauth_metadata, state::OAuthClientConfig};
···
         signing_key_storage.insert(public_signing_key, signing_key.clone());
     }
 
-    let identity_resolver = Arc::new(SharedIdentityResolver(
-        Arc::new(InnerIdentityResolver {
-            dns_resolver: Arc::new(dns_resolver),
-            http_client: http_client.clone(),
-            plc_hostname: plc_hostname.clone(),
-        })
-    ));
+    let identity_resolver = Arc::new(SharedIdentityResolver(Arc::new(InnerIdentityResolver {
+        dns_resolver: Arc::new(dns_resolver),
+        http_client: http_client.clone(),
+        plc_hostname: plc_hostname.clone(),
+    })));
 
     let web_context = WebContext(Arc::new(InnerWebContext {
         http_client: http_client.clone(),

crates/atproto-oauth-axum/src/handle_complete.rs

···
 
 use anyhow::Result;
 use atproto_identity::{
-    key::{identify_key, KeyProvider}, storage::DidDocumentStorage,
+    key::{KeyProvider, identify_key},
+    storage::DidDocumentStorage,
 };
 use atproto_oauth::{
-    resources::pds_resources, storage::OAuthRequestStorage, workflow::{oauth_complete, OAuthClient}
+    resources::pds_resources,
+    storage::OAuthRequestStorage,
+    workflow::{OAuthClient, oauth_complete},
 };
 use axum::{
-    extract::State, response::{IntoResponse, Response}, Form
+    Form,
+    extract::State,
+    response::{IntoResponse, Response},
 };
 use http::StatusCode;
 use serde::{Deserialize, Serialize};

crates/atproto-oauth/src/lib.rs

···
 pub mod storage_lru;
 /// OAuth workflow implementation for AT Protocol authorization flows.
 pub mod workflow;
-

crates/atproto-xrpcs-helloworld/src/main.rs

···
 
 use anyhow::Result;
 use async_trait::async_trait;
+use atproto_identity::resolve::SharedIdentityResolver;
 use atproto_identity::{
     config::{CertificateBundles, DnsNameservers, default_env, optional_env, require_env, version},
     key::{KeyData, KeyProvider, identify_key, to_public},
-    resolve::{IdentityResolver, InnerIdentityResolver, HickoryDnsResolver},
+    resolve::{HickoryDnsResolver, IdentityResolver, InnerIdentityResolver},
     storage::DidDocumentStorage,
     storage_lru::LruDidDocumentStorage,
 };
-use atproto_identity::resolve::SharedIdentityResolver;
 use atproto_xrpcs::authorization::ResolvingAuthorization;
 use axum::{
-    extract::{FromRef, Query, State}, response::{Html, IntoResponse, Response}, routing::get, Json, Router
+    Json, Router,
+    extract::{FromRef, Query, State},
+    response::{Html, IntoResponse, Response},
+    routing::get,
 };
 use clap::Parser;
 use http::{HeaderMap, StatusCode};
···
 
     let service_did = ServiceDID(service_did);
 
-    let identity_resolver = Arc::new(SharedIdentityResolver(
-        Arc::new(InnerIdentityResolver {
-            dns_resolver: Arc::new(dns_resolver),
-            http_client: http_client.clone(),
-            plc_hostname,
-        })
-    ));
+    let identity_resolver = Arc::new(SharedIdentityResolver(Arc::new(InnerIdentityResolver {
+        dns_resolver: Arc::new(dns_resolver),
+        http_client: http_client.clone(),
+        plc_hostname,
+    })));
 
     let web_context = WebContext(Arc::new(InnerWebContext {
         http_client: http_client.clone(),
···
 }
 
 // /.well-known/did.json
-async fn handle_wellknown_did_web(service_document: State<ServiceDocument>) -> Json<serde_json::Value> {
+async fn handle_wellknown_did_web(
+    service_document: State<ServiceDocument>,
+) -> Json<serde_json::Value> {
     Json(service_document.0.0)
 }