refactor(identity): eliminate async_trait dependency

Signed-off-by: tjh <did:plc:65gha4t3avpfpzmvpbwovss7>

Cargo.lock

···
 name = "identity"
 version = "0.0.0"
 dependencies = [
- "async-trait",
  "atproto",
+ "futures-util",
  "hickory-resolver",
  "moka",
  "reqwest",

crates/identity/Cargo.toml

···
 tracing.workspace = true
 url.workspace = true
 
-async-trait = "0.1.89"
+futures-util = "0.3.31"
 hickory-resolver = "0.25.2"
 moka = "0.12.11"
 tokio = { version = "1.47.1", default-features = false, features = ["macros"] }

crates/identity/src/lib.rs

···
 mod document;
 mod resolvers;
 
+use core::fmt;
+
+use futures_util::{FutureExt as _, future::BoxFuture};
+
 pub use atproto::did::Did;
 pub use document::{DidDocument, Service, VerificationMethod};
 
···
 pub type HttpClient = reqwest::Client;
 pub type HttpError = reqwest::Error;
 
-// @NOT We need async_trait here because we want this trait to be dyn compatible.
-#[async_trait::async_trait]
-trait HandleResolve: std::fmt::Debug {
+trait HandleResolve: fmt::Debug + Sync {
     /// Resolve a handle or a DID to a DID and DID document.
-    async fn resolve(&self, ident: &str) -> Result<(Box<Did>, DidDocument), ResolveError> {
+    ///
+    fn resolve<'s: 'a, 'a>(
+        &'s self,
+        ident: &'a str,
+    ) -> BoxFuture<'a, Result<(Box<Did>, DidDocument), ResolveError>> {
         match ident.parse::<Box<Did>>() {
             Ok(did) => {
-                let doc = self.resolve_did(&did).await?;
-                let handle = doc.primary_alias().ok_or(ResolveError::InvalidDocument)?;
+                async {
+                    let doc = self.resolve_did(&did).await?;
+                    let handle = doc.primary_alias().ok_or(ResolveError::InvalidDocument)?;
 
-                // Verify the primary handle in the DID document resolves to
-                // the DID we were given.
-                let resolved = self.resolve_handle(handle).await?;
-                match did == resolved {
-                    true => Ok((did, doc)),
-                    false => Err(ResolveError::BidirectionalFailure),
+                    // Verify the primary handle in the DID document resolves to
+                    // the DID we were given.
+                    let resolved = self.resolve_handle(handle).await?;
+                    match did == resolved {
+                        true => Ok((did, doc)),
+                        false => Err(ResolveError::BidirectionalFailure),
+                    }
                 }
+                .boxed()
             }
             Err(_) => {
                 let handle = ident.trim_start_matches('@');
-                let did = self.resolve_handle(handle).await?;
-                let doc = self.resolve_did(&did).await?;
+                async move {
+                    let did = self.resolve_handle(handle).await?;
+                    let doc = self.resolve_did(&did).await?;
 
-                // Verify the document has a matching handle.
-                for alias in &doc.also_known_as {
-                    if alias.domain().is_some_and(|host| host == ident) {
-                        return Ok((did, doc));
+                    // Verify the document has a matching handle.
+                    for alias in &doc.also_known_as {
+                        if alias.domain().is_some_and(|host| host == ident) {
+                            return Ok((did, doc));
+                        }
                     }
-                }
 
-                Err(ResolveError::BidirectionalFailure)
+                    Err(ResolveError::BidirectionalFailure)
+                }
+                .boxed()
             }
         }
     }
 
     /// Resolve a handle to a DID.
     ///
+    /// Implementors are not required to bi-directionally confirm the resolution.
+    ///
+    /// [`HandleResolve::resolve`] should be preferred.
+    ///
     /// Related: <https://docs.bsky.app/docs/api/com-atproto-identity-resolve-handle>
-    async fn resolve_handle(&self, handle: &str) -> Result<Box<Did>, ResolveError>;
+    fn resolve_handle<'s: 'h, 'h>(
+        &'s self,
+        handle: &'h str,
+    ) -> BoxFuture<'h, Result<Box<Did>, ResolveError>>;
 
     /// Resolve a DID to DID document.
     ///
-    /// Related: <https://docs.bsky.app/docs/api/com-atproto-identity-resolve-did>
-    async fn resolve_did(&self, did: &Did) -> Result<DidDocument, ResolveError>;
+    /// Implementors are not required to bi-directionally confirm the resolution.
+    ///
+    /// [`HandleResolve::resolve`] should be preferred.
+    ///
+    /// Ref: <https://docs.bsky.app/docs/api/com-atproto-identity-resolve-did>
+    fn resolve_did<'s: 'd, 'd>(
+        &'s self,
+        did: &'d Did,
+    ) -> BoxFuture<'d, Result<DidDocument, ResolveError>>;
 
-    async fn invalidate_did(&self, _: &Did) {}
+    /// Instruct a caching resolver to remove any cached resolutions for the
+    /// specified DID.
+    ///
+    /// This will have no effect on system-level caches, like DNS caches.
+    ///
+    fn invalidate_did<'s: 'd, 'd>(&'s self, _: &'d Did) -> BoxFuture<'d, ()> {
+        async {}.boxed()
+    }
 }
 
 #[derive(Debug, thiserror::Error)]
···
     }
 }
 
-#[async_trait::async_trait]
 impl HandleResolve for Resolver {
-    async fn resolve(&self, ident: &str) -> Result<(Box<Did>, DidDocument), ResolveError> {
-        Self::resolve(self, ident).await
+    fn resolve<'s: 'i, 'i>(
+        &'s self,
+        ident: &'i str,
+    ) -> BoxFuture<'i, Result<(Box<Did>, DidDocument), ResolveError>> {
+        Self::resolve(self, ident).boxed()
     }
 
-    async fn resolve_handle(&self, handle: &str) -> Result<Box<Did>, ResolveError> {
-        Self::resolve_handle(self, handle).await
+    fn resolve_handle<'s: 'h, 'h>(
+        &'s self,
+        handle: &'h str,
+    ) -> BoxFuture<'h, Result<Box<Did>, ResolveError>> {
+        Self::resolve_handle(self, handle).boxed()
     }
 
-    async fn resolve_did(&self, did: &Did) -> Result<DidDocument, ResolveError> {
-        Self::resolve_did(self, did).await
+    fn resolve_did<'s: 'd, 'd>(
+        &'s self,
+        did: &'d Did,
+    ) -> BoxFuture<'d, Result<DidDocument, ResolveError>> {
+        Self::resolve_did(self, did).boxed()
     }
 
-    async fn invalidate_did(&self, did: &Did) {
-        Self::invalidate_did(&self, did).await
+    fn invalidate_did<'s: 'd, 'd>(&'s self, did: &'d Did) -> BoxFuture<'d, ()> {
+        Self::invalidate_did(self, did).boxed()
     }
 }
 

crates/identity/src/resolvers/direct.rs

···
-use crate::{DEFAULT_PLC_DIRECTORY, Did, DidDocument, HandleResolve, HttpClient, ResolveError};
+use std::borrow::Cow;
+
+use futures_util::{FutureExt as _, future::BoxFuture};
 use hickory_resolver::name_server::TokioConnectionProvider;
 use hickory_resolver::{
     ResolveError as DnsResolveError, Resolver as DnsClient, TokioResolver,
     name_server::ConnectionProvider,
 };
-use std::borrow::Cow;
 use tokio::time::Instant;
+
+use crate::{DEFAULT_PLC_DIRECTORY, Did, DidDocument, HandleResolve, HttpClient, ResolveError};
 
 pub struct DirectResolver<'plc, R: ConnectionProvider> {
     plc: Cow<'plc, str>,
···
     }
 }
 
-#[async_trait::async_trait]
 impl<R: ConnectionProvider> HandleResolve for DirectResolver<'_, R> {
-    async fn resolve_handle(&self, handle: &str) -> Result<Box<Did>, ResolveError> {
+    fn resolve_handle<'s: 'h, 'h>(
+        &'s self,
+        handle: &'h str,
+    ) -> BoxFuture<'h, Result<Box<Did>, ResolveError>> {
         let dns = resolve_handle_dns(&self.dns, handle);
         let http = resolve_handle_http(&self.http, handle);
 
···
         //       technically incorrect.
 
         let start = Instant::now();
-        tokio::select! {
-            Ok(Some(did)) = dns => {
-                tracing::trace!(?handle, %did, elapsed = ?start.elapsed(), "resolved via dns");
-                Ok(did)
-            },
-            Ok(Some(did)) = http => {
-                tracing::trace!(?handle, %did, elapsed = ?start.elapsed(), "resolved via http");
-                Ok(did)
+        async move {
+            tokio::select! {
+                Ok(Some(did)) = dns => {
+                    tracing::trace!(?handle, %did, elapsed = ?start.elapsed(), "resolved via dns");
+                    Ok(did)
+                },
+                Ok(Some(did)) = http => {
+                    tracing::trace!(?handle, %did, elapsed = ?start.elapsed(), "resolved via http");
+                    Ok(did)
+                }
+                else => Err(ResolveError::UnresolvedHandle),
             }
-            else => Err(ResolveError::UnresolvedHandle),
         }
+        .boxed()
     }
 
-    async fn resolve_did(&self, did: &Did) -> Result<DidDocument, ResolveError> {
-        match did.method() {
-            "plc" => Ok(self.fetch_plc_did_document(did).await?),
-            "web" => Ok(self.fetch_web_did_document(did).await?),
-            method => Err(ResolveError::UnsupportedDidMethod(method.to_string())),
+    fn resolve_did<'s: 'd, 'd>(
+        &'s self,
+        did: &'d Did,
+    ) -> BoxFuture<'d, Result<DidDocument, ResolveError>> {
+        async {
+            match did.method() {
+                "plc" => Ok(self.fetch_plc_did_document(did).await?),
+                "web" => Ok(self.fetch_web_did_document(did).await?),
+                method => Err(ResolveError::UnsupportedDidMethod(method.to_string())),
+            }
         }
+        .boxed()
     }
 }
 

crates/identity/src/resolvers/memcache.rs

···
-use super::direct::DirectResolver;
-use crate::{DEFAULT_PLC_DIRECTORY, Did, DidDocument, HandleResolve, HttpClient, ResolveError};
+use std::{borrow::Cow, time::Duration};
+
+use futures_util::{FutureExt as _, future::BoxFuture};
 use hickory_resolver::name_server::TokioConnectionProvider;
 use moka::sync::{Cache, CacheBuilder};
-use std::{borrow::Cow, time::Duration};
+
+use crate::{DEFAULT_PLC_DIRECTORY, Did, DidDocument, HandleResolve, HttpClient, ResolveError};
+
+use super::direct::DirectResolver;
 
 const DEFAULT_DID_CACHE_CAP: u64 = 1024;
 const DEFAULT_DOC_CACHE_CAP: u64 = 1024;
···
     }
 }
 
-#[async_trait::async_trait]
 impl HandleResolve for MemcacheResolver {
-    async fn resolve_handle(&self, handle: &str) -> Result<Box<Did>, ResolveError> {
-        if let Some(did) = self.did_cache.get(handle) {
-            tracing::trace!(?handle, ?did, "reusing resolved did from cache");
-            return Ok(did);
-        }
+    fn resolve_handle<'s: 'h, 'h>(
+        &'s self,
+        handle: &'h str,
+    ) -> BoxFuture<'h, Result<Box<Did>, ResolveError>> {
+        async move {
+            if let Some(did) = self.did_cache.get(handle) {
+                tracing::trace!(?handle, ?did, "reusing resolved did from cache");
+                return Ok(did);
+            }
 
-        let did = self.inner.resolve_handle(handle).await?;
-        self.did_cache.insert(handle.into(), did.clone());
-        Ok(did)
+            let did = self.inner.resolve_handle(handle).await?;
+            self.did_cache.insert(handle.into(), did.clone());
+            Ok(did)
+        }
+        .boxed()
     }
 
-    async fn resolve_did(&self, did: &Did) -> Result<DidDocument, ResolveError> {
-        if let Some(doc) = self.doc_cache.get(&did.to_owned()) {
-            tracing::trace!(?did, "reusing resolved did document from cache");
-            return Ok(doc);
-        }
+    fn resolve_did<'s: 'd, 'd>(
+        &'s self,
+        did: &'d Did,
+    ) -> BoxFuture<'d, Result<DidDocument, ResolveError>> {
+        async move {
+            if let Some(doc) = self.doc_cache.get(&did.to_owned()) {
+                tracing::trace!(?did, "reusing resolved did document from cache");
+                return Ok(doc);
+            }
 
-        let doc = self.inner.resolve_did(did).await?;
-        self.doc_cache.insert(did.to_owned(), doc.clone());
-        Ok(doc)
+            let doc = self.inner.resolve_did(did).await?;
+            self.doc_cache.insert(did.to_owned(), doc.clone());
+            Ok(doc)
+        }
+        .boxed()
     }
 
-    async fn invalidate_did(&self, did: &Did) {
+    fn invalidate_did<'s: 'd, 'd>(&'s self, did: &'d Did) -> BoxFuture<'d, ()> {
         if let Some(doc) = self.doc_cache.remove(did) {
             tracing::trace!(?did, "invalidating DID document");
             for handle in doc.also_known_as.iter().filter_map(|uri| uri.domain()) {
···
                 self.did_cache.remove(handle);
             }
         }
+
+        async {}.boxed()
     }
 }