change Resolver type signature

atrium-common/src/resolver.rs

@@ -16,7 +16,7 @@ pub trait Resolver {
     fn resolve(
         &self,
         input: &Self::Input,
-    ) -> impl Future<Output = core::result::Result<Option<Self::Output>, Self::Error>>;
+    ) -> impl Future<Output = core::result::Result<Self::Output, Self::Error>>;
 }
 
 #[cfg(test)]
@@ -52,10 +52,17 @@ mod tests {
         type Output = String;
         type Error = Error;
 
-        async fn resolve(&self, input: &Self::Input) -> Result<Option<Self::Output>> {
+        async fn resolve(
+            &self,
+            input: &Self::Input,
+        ) -> core::result::Result<Self::Output, Self::Error> {
             sleep(Duration::from_millis(10)).await;
             *self.counts.write().await.entry(input.clone()).or_default() += 1;
-            Ok(self.data.get(input).cloned())
+            if let Some(value) = self.data.get(input) {
+                Ok(value.clone())
+            } else {
+                Err(Error::NotFound)
+            }
         }
     }
 
@@ -87,12 +94,8 @@ mod tests {
         ] {
             let result = resolver.resolve(&input.to_string()).await;
             match expected {
-                Some(value) => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), Some(value))
-                }
-                None => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), None)
-                }
+                Some(value) => assert_eq!(result.expect("failed to resolve"), value),
+                None => assert!(result.is_err()),
             }
         }
         assert_eq!(
@@ -119,12 +122,8 @@ mod tests {
         ] {
             let result = resolver.resolve(&input.to_string()).await;
             match expected {
-                Some(value) => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), Some(value))
-                }
-                None => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), None)
-                }
+                Some(value) => assert_eq!(result.expect("failed to resolve"), value),
+                None => assert!(result.is_err()),
             }
         }
         assert_eq!(
@@ -152,12 +151,8 @@ mod tests {
         ] {
             let result = resolver.resolve(&input.to_string()).await;
             match expected {
-                Some(value) => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), Some(value))
-                }
-                None => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), None)
-                }
+                Some(value) => assert_eq!(result.expect("failed to resolve"), value),
+                None => assert!(result.is_err()),
             }
         }
         assert_eq!(
@@ -178,12 +173,12 @@ mod tests {
         }));
         for _ in 0..10 {
             let result = resolver.resolve(&String::from("k1")).await;
-            assert_eq!(result.expect("failed to resolve").as_deref(), Some("v1"));
+            assert_eq!(result.expect("failed to resolve"), "v1");
         }
         sleep(Duration::from_millis(10)).await;
         for _ in 0..10 {
             let result = resolver.resolve(&String::from("k1")).await;
-            assert_eq!(result.expect("failed to resolve").as_deref(), Some("v1"));
+            assert_eq!(result.expect("failed to resolve"), "v1");
         }
         assert_eq!(*counts.read().await, [(String::from("k1"), 2)].into_iter().collect());
     }
@@ -212,9 +207,7 @@ mod tests {
                 Some(value) => {
                     assert_eq!(result.expect("failed to resolve").as_deref(), Some(value))
                 }
-                None => {
-                    assert_eq!(result.expect("failed to resolve").as_deref(), None)
-                }
+                None => assert!(result.is_err()),
             }
         }
         assert_eq!(

atrium-common/src/resolver/cached.rs

@@ -20,17 +20,12 @@ where
     type Output = R::Output;
     type Error = R::Error;
 
-    async fn resolve(&self, input: &Self::Input) -> Result<Option<Self::Output>, Self::Error> {
-        match self.cache.get(input).await {
-            Some(cached) => Ok(Some(cached)),
-            None => {
-                let result = self.inner.resolve(input).await?;
-
-                if let Some(result) = result.as_ref().cloned() {
-                    self.cache.set(input.clone(), result.clone()).await;
-                }
-                Ok(result)
-            }
+    async fn resolve(&self, input: &Self::Input) -> Result<Self::Output, Self::Error> {
+        if let Some(output) = self.cache.get(input).await {
+            return Ok(output);
         }
+        let output = self.inner.resolve(input).await?;
+        self.cache.set(input.clone(), output.clone()).await;
+        Ok(output)
     }
 }

atrium-common/src/resolver/error.rs

@@ -6,6 +6,8 @@ pub type Result<T> = core::result::Result<T, Error>;
 
 #[derive(Error, Debug)]
 pub enum Error {
+    #[error("resource not found")]
+    NotFound,
     #[error("dns resolver error: {0}")]
     DnsResolver(Box<dyn std::error::Error + Send + Sync + 'static>),
     #[error(transparent)]

atrium-common/src/resolver/throttled.rs

@@ -20,10 +20,10 @@ where
     R::Output: Clone + Send + Sync + 'static,
 {
     type Input = R::Input;
-    type Output = R::Output;
+    type Output = Option<R::Output>;
     type Error = R::Error;
 
-    async fn resolve(&self, input: &Self::Input) -> Result<Option<Self::Output>, Self::Error> {
+    async fn resolve(&self, input: &Self::Input) -> Result<Self::Output, Self::Error> {
         match self.pending.entry(input.clone()) {
             Entry::Occupied(occupied) => {
                 let tx = occupied.get().lock().await.clone();
@@ -34,9 +34,9 @@ where
                 let (tx, _) = channel(1);
                 vacant.insert(Arc::new(Mutex::new(tx.clone())));
                 let result = self.inner.resolve(input).await;
-                let _ = tx.send(result.as_ref().cloned().transpose().and_then(Result::ok));
+                tx.send(result.as_ref().ok().cloned()).ok();
                 self.pending.remove(input);
-                result
+                result.map(Some)
             }
         }
     }

atrium-common/src/types/cached/impl/wasm.rs

@@ -75,7 +75,7 @@ where
         };
         Self { inner: Arc::new(Mutex::new(store)), expiration: config.time_to_live }
     }
-    async fn get(&self, key: &Self::Input) -> Option<Self::Output> {
+    async fn get(&self, key: &Self::Input) -> Self::Output {
         let mut cache = self.inner.lock().await;
         if let Some(ValueWithInstant { value, instant }) = cache.get(key) {
             if let Some(expiration) = self.expiration {

atrium-oauth/identity/src/did/common_resolver.rs

@@ -43,7 +43,7 @@ where
     type Output = DidDocument;
     type Error = Error;
 
-    async fn resolve(&self, did: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, did: &Self::Input) -> Result<Self::Output> {
         match did.strip_prefix("did:").and_then(|s| s.split_once(':').map(|(method, _)| method)) {
             Some("plc") => self.plc_resolver.resolve(did).await,
             Some("web") => self.web_resolver.resolve(did).await,

atrium-oauth/identity/src/did/plc_resolver.rs

@@ -35,7 +35,7 @@ where
     type Output = DidDocument;
     type Error = Error;
 
-    async fn resolve(&self, did: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, did: &Self::Input) -> Result<Self::Output> {
         let uri = Builder::from(self.plc_directory_url.parse::<Uri>()?)
             .path_and_query(format!("/{}", did.as_str()))
             .build()?;

atrium-oauth/identity/src/did/web_resolver.rs

@@ -32,7 +32,7 @@ where
     type Output = DidDocument;
     type Error = Error;
 
-    async fn resolve(&self, did: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, did: &Self::Input) -> Result<Self::Output> {
         let document_url = format!(
             "https://{}/.well-known/did.json",
             did.as_str()

atrium-oauth/identity/src/error.rs

@@ -46,6 +46,7 @@ impl From<resolver::Error> for Error {
             resolver::Error::SerdeJson(error) => Error::SerdeJson(error),
             resolver::Error::SerdeHtmlForm(error) => Error::SerdeHtmlForm(error),
             resolver::Error::Uri(error) => Error::Uri(error),
+            resolver::Error::NotFound => Error::NotFound,
         }
     }
 }

atrium-oauth/identity/src/handle/appview_resolver.rs

@@ -33,7 +33,7 @@ where
     type Output = Did;
     type Error = Error;
 
-    async fn resolve(&self, handle: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, handle: &Self::Input) -> Result<Self::Output> {
         let uri = Builder::from(self.service_url.parse::<Uri>()?)
             .path_and_query(format!(
                 "/xrpc/com.atproto.identity.resolveHandle?{}",
@@ -49,7 +49,7 @@ where
             .await
             .map_err(Error::HttpClient)?;
         if res.status().is_success() {
-            Ok(Some(serde_json::from_slice::<resolve_handle::OutputData>(res.body())?.did))
+            Ok(serde_json::from_slice::<resolve_handle::OutputData>(res.body())?.did)
         } else {
             Err(Error::HttpStatus(res.status()))
         }

atrium-oauth/identity/src/handle/atproto_resolver.rs

@@ -41,7 +41,7 @@ where
     type Output = Did;
     type Error = Error;
 
-    async fn resolve(&self, handle: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, handle: &Self::Input) -> Result<Self::Output> {
         let d_fut = self.dns.resolve(handle);
         let h_fut = self.http.resolve(handle);
         if let Ok(did) = d_fut.await {

atrium-oauth/identity/src/handle/dns_resolver.rs

@@ -43,15 +43,15 @@ where
     type Output = Did;
     type Error = Error;
 
-    async fn resolve(&self, handle: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, handle: &Self::Input) -> Result<Self::Output> {
         for result in self
             .dns_txt_resolver
             .resolve(&format!("{SUBDOMAIN}.{}", handle.as_ref()))
             .await
             .map_err(Error::DnsResolver)?
         {
             if let Some(did) = result.strip_prefix(PREFIX) {
-                return Some(did.parse::<Did>().map_err(|e| Error::Did(e.to_string()))).transpose();
+                return did.parse::<Did>().map_err(|e| Error::Did(e.to_string()));
             }
         }
         Err(Error::NotFound)

atrium-oauth/identity/src/handle/well_known_resolver.rs

@@ -31,7 +31,7 @@ where
     type Output = Did;
     type Error = Error;
 
-    async fn resolve(&self, handle: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, handle: &Self::Input) -> Result<Self::Output> {
         let url = format!("https://{}{WELL_KNWON_PATH}", handle.as_str());
         // TODO: no-cache?
         let res = self
@@ -41,7 +41,7 @@ where
             .map_err(Error::HttpClient)?;
         if res.status().is_success() {
             let text = String::from_utf8_lossy(res.body()).to_string();
-            Some(text.parse::<Did>().map_err(|e| Error::Did(e.to_string()))).transpose()
+            text.parse::<Did>().map_err(|e| Error::Did(e.to_string()))
         } else {
             Err(Error::HttpStatus(res.status()))
         }

atrium-oauth/identity/src/identity_resolver.rs

@@ -37,18 +37,13 @@ where
     type Output = ResolvedIdentity;
     type Error = Error;
 
-    async fn resolve(&self, input: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, input: &Self::Input) -> Result<Self::Output> {
         let document =
             match input.parse::<AtIdentifier>().map_err(|e| Error::AtIdentifier(e.to_string()))? {
-                AtIdentifier::Did(did) => {
-                    let result = self.did_resolver.resolve(&did).await?;
-                    result.ok_or_else(|| Error::NotFound)?
-                }
+                AtIdentifier::Did(did) => self.did_resolver.resolve(&did).await?,
                 AtIdentifier::Handle(handle) => {
-                    let result = self.handle_resolver.resolve(&handle).await?;
-                    let did = result.ok_or_else(|| Error::NotFound)?;
-                    let result = self.did_resolver.resolve(&did).await?;
-                    let document = result.ok_or_else(|| Error::NotFound)?;
+                    let did = self.handle_resolver.resolve(&handle).await?;
+                    let document = self.did_resolver.resolve(&did).await?;
                     if let Some(aka) = &document.also_known_as {
                         if !aka.contains(&format!("at://{}", handle.as_str())) {
                             return Err(Error::DidDocument(format!(
@@ -67,6 +62,6 @@ where
                 document.id
             )));
         };
-        Ok(Some(ResolvedIdentity { did: document.id, pds: service }))
+        Ok(ResolvedIdentity { did: document.id, pds: service })
     }
 }

atrium-oauth/oauth-client/src/oauth_client.rs

@@ -146,9 +146,7 @@ where
         } else {
             self.client_metadata.redirect_uris[0].clone()
         };
-        let result = self.resolver.resolve(input.as_ref()).await?;
-        let (metadata, identity) =
-            result.ok_or_else(|| Error::Identity(atrium_identity::Error::NotFound))?;
+        let (metadata, identity) = self.resolver.resolve(input.as_ref()).await?;
         let Some(dpop_key) = Self::generate_dpop_key(&metadata) else {
             return Err(Error::Authorize("none of the algorithms worked".into()));
         };

atrium-oauth/oauth-client/src/resolver.rs

@@ -129,8 +129,7 @@ where
         &self,
         input: &str,
     ) -> Result<(OAuthAuthorizationServerMetadata, ResolvedIdentity)> {
-        let result = self.identity_resolver.resolve(input).await;
-        let identity = result.and_then(|result| result.ok_or_else(|| Error::NotFound))?;
+        let identity = self.identity_resolver.resolve(input).await?;
         let metadata = self.get_resource_server_metadata(&identity.pds).await?;
         Ok((metadata, identity))
     }
@@ -193,15 +192,15 @@ where
     type Output = (OAuthAuthorizationServerMetadata, Option<ResolvedIdentity>);
     type Error = Error;
 
-    async fn resolve(&self, input: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, input: &Self::Input) -> Result<Self::Output> {
         // Allow using an entryway, or PDS url, directly as login input (e.g.
         // when the user forgot their handle, or when the handle does not
         // resolve to a DID)
         Ok(if input.starts_with("https://") {
-            Some((self.resolve_from_service(input.as_ref()).await?, None))
+            (self.resolve_from_service(input.as_ref()).await?, None)
         } else {
             let (metadata, identity) = self.resolve_from_identity(input).await?;
-            Some((metadata, Some(identity)))
+            (metadata, Some(identity))
         })
     }
 }

atrium-oauth/oauth-client/src/resolver/oauth_authorization_server_resolver.rs

@@ -24,7 +24,7 @@ where
     type Output = OAuthAuthorizationServerMetadata;
     type Error = Error;
 
-    async fn resolve(&self, issuer: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, issuer: &Self::Input) -> Result<Self::Output> {
         let uri = Builder::from(issuer.parse::<Uri>()?)
             .path_and_query("/.well-known/oauth-authorization-server")
             .build()?;
@@ -38,7 +38,7 @@ where
             let metadata = serde_json::from_slice::<OAuthAuthorizationServerMetadata>(res.body())?;
             // https://datatracker.ietf.org/doc/html/rfc8414#section-3.3
             if &metadata.issuer == issuer {
-                Ok(Some(metadata))
+                Ok(metadata)
             } else {
                 Err(Error::AuthorizationServerMetadata(format!(
                     "invalid issuer: {}",

atrium-oauth/oauth-client/src/resolver/oauth_protected_resource_resolver.rs

@@ -24,7 +24,7 @@ where
     type Output = OAuthProtectedResourceMetadata;
     type Error = Error;
 
-    async fn resolve(&self, resource: &Self::Input) -> Result<Option<Self::Output>> {
+    async fn resolve(&self, resource: &Self::Input) -> Result<Self::Output> {
         let uri = Builder::from(resource.parse::<Uri>()?)
             .path_and_query("/.well-known/oauth-protected-resource")
             .build()?;
@@ -38,7 +38,7 @@ where
             let metadata = serde_json::from_slice::<OAuthProtectedResourceMetadata>(res.body())?;
             // https://datatracker.ietf.org/doc/html/draft-ietf-oauth-resource-metadata-08#section-3.3
             if &metadata.resource == resource {
-                Ok(Some(metadata))
+                Ok(metadata)
             } else {
                 Err(Error::ProtectedResourceMetadata(format!(
                     "invalid resource: {}",