Make an io::Error variant public

So that they can be matched on in downstream logic. Keep Internal
variants private.

Author: DanGould

payjoin/src/io.rs

@@ -54,35 +54,50 @@ pub async fn fetch_ohttp_keys_with_cert(
 
 async fn parse_ohttp_keys_response(res: reqwest::Response) -> Result<OhttpKeys, Error> {
     if !res.status().is_success() {
-        return Err(Error(InternalError::UnexpectedStatusCode(res.status())));
+        return Err(Error::UnexpectedStatusCode(res.status()));
     }
 
     let body = res.bytes().await?.to_vec();
-    OhttpKeys::decode(&body).map_err(|e| Error(InternalError::InvalidOhttpKeys(e.to_string())))
+    OhttpKeys::decode(&body).map_err(|e| {
+        Error::Internal(InternalError(InternalErrorInner::InvalidOhttpKeys(e.to_string())))
+    })
 }
 
 #[derive(Debug)]
-pub struct Error(InternalError);
+#[non_exhaustive]
+pub enum Error {
+    /// When the payjoin directory returns an unexpected status code
+    UnexpectedStatusCode(http::StatusCode),
+    /// Internal errors that should not be pattern matched by users
+    #[doc(hidden)]
+    Internal(InternalError),
+}
+
+#[derive(Debug)]
+pub struct InternalError(InternalErrorInner);
 
 #[derive(Debug)]
-enum InternalError {
+enum InternalErrorInner {
     ParseUrl(crate::into_url::Error),
     Reqwest(reqwest::Error),
     Io(std::io::Error),
     #[cfg(feature = "_danger-local-https")]
     Rustls(rustls::Error),
     InvalidOhttpKeys(String),
-    UnexpectedStatusCode(http::StatusCode),
 }
 
 impl From<url::ParseError> for Error {
-    fn from(value: url::ParseError) -> Self { Self(InternalError::ParseUrl(value.into())) }
+    fn from(value: url::ParseError) -> Self {
+        Self::Internal(InternalError(InternalErrorInner::ParseUrl(value.into())))
+    }
 }
 
 macro_rules! impl_from_error {
     ($from:ty, $to:ident) => {
         impl From<$from> for Error {
-            fn from(value: $from) -> Self { Self(InternalError::$to(value)) }
+            fn from(value: $from) -> Self {
+                Self::Internal(InternalError(InternalErrorInner::$to(value)))
+            }
         }
     };
 }
@@ -95,18 +110,26 @@ impl_from_error!(rustls::Error, Rustls);
 
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        use InternalError::*;
+        match self {
+            Self::UnexpectedStatusCode(code) => {
+                write!(f, "Unexpected status code from payjoin directory: {code}")
+            }
+            Self::Internal(InternalError(e)) => e.fmt(f),
+        }
+    }
+}
 
-        match &self.0 {
+impl std::fmt::Display for InternalErrorInner {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        use InternalErrorInner::*;
+
+        match &self {
             Reqwest(e) => e.fmt(f),
             ParseUrl(e) => e.fmt(f),
             Io(e) => e.fmt(f),
             InvalidOhttpKeys(e) => {
                 write!(f, "Invalid ohttp keys returned from payjoin directory: {e}")
             }
-            UnexpectedStatusCode(code) => {
-                write!(f, "Unexpected status code from payjoin directory: {code}")
-            }
             #[cfg(feature = "_danger-local-https")]
             Rustls(e) => e.fmt(f),
         }
@@ -115,22 +138,34 @@ impl std::fmt::Display for Error {
 
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use InternalError::*;
+        match self {
+            Self::Internal(InternalError(e)) => e.source(),
+            Self::UnexpectedStatusCode(_) => None,
+        }
+    }
+}
+
+impl std::error::Error for InternalErrorInner {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use InternalErrorInner::*;
 
-        match &self.0 {
+        match self {
             Reqwest(e) => Some(e),
             ParseUrl(e) => Some(e),
             Io(e) => Some(e),
             InvalidOhttpKeys(_) => None,
-            UnexpectedStatusCode(_) => None,
             #[cfg(feature = "_danger-local-https")]
             Rustls(e) => Some(e),
         }
     }
 }
 
 impl From<InternalError> for Error {
-    fn from(value: InternalError) -> Self { Self(value) }
+    fn from(value: InternalError) -> Self { Self::Internal(value) }
+}
+
+impl From<InternalErrorInner> for Error {
+    fn from(value: InternalErrorInner) -> Self { Self::Internal(InternalError(value)) }
 }
 
 #[cfg(test)]
@@ -170,7 +205,7 @@ mod tests {
         for status in error_codes {
             let response = mock_response(status, vec![]);
             match parse_ohttp_keys_response(response).await {
-                Err(Error(InternalError::UnexpectedStatusCode(code))) => assert_eq!(code, status),
+                Err(Error::UnexpectedStatusCode(code)) => assert_eq!(code, status),
                 result => panic!(
                     "Expected UnexpectedStatusCode error for status code: {status}, got: {result:?}"
                 ),
@@ -188,7 +223,7 @@ mod tests {
         assert!(
             matches!(
                 parse_ohttp_keys_response(response).await,
-                Err(Error(InternalError::InvalidOhttpKeys(_)))
+                Err(Error::Internal(InternalError(InternalErrorInner::InvalidOhttpKeys(_))))
             ),
             "expected InvalidOhttpKeys error"
         );