[PM-36839] Merge API errors

bitwarden_license/bitwarden-sm/src/error.rs

@@ -1,4 +1,3 @@
-use bitwarden_api_api::apis::Error as ApiApisError;
 use thiserror::Error;
 use tracing::debug;
 use validator::ValidationErrors;
@@ -81,9 +80,3 @@ impl From<ValidationErrors> for SecretsManagerError {
         SecretsManagerError::Validation(e.into())
     }
 }
-
-impl<T> From<ApiApisError<T>> for SecretsManagerError {
-    fn from(e: bitwarden_api_api::apis::Error<T>) -> Self {
-        SecretsManagerError::Api(e.into())
-    }
-}

crates/bitwarden-api-base/src/error.rs

@@ -1,6 +1,6 @@
 //! Error types for API operations.
 
-use std::{convert::Infallible, error, fmt, marker::PhantomData};
+use std::{error, fmt};
 
 use serde::{Deserialize, Serialize};
 
@@ -18,7 +18,7 @@ pub struct ResponseContent {
 /// Errors that can occur during API operations.
 #[derive(Debug)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Error), uniffi(flat_error))]
-pub enum Error<T = ()> {
+pub enum Error {
     /// Error from the reqwest HTTP client.
     Reqwest(reqwest::Error),
     /// Error from the reqwest middleware.
@@ -29,64 +29,58 @@ pub enum Error<T = ()> {
     Io(std::io::Error),
     /// API returned an error response.
     Response(ResponseContent),
-
-    /// Phantom variant to keep the unused `T` parameter alive without affecting downstream
-    /// `impl<T> From<Error<T>> for FooError` impls. Uninhabited via [`Infallible`].
-    #[doc(hidden)]
-    _Phantom(PhantomData<T>, Infallible),
 }
 
-impl<T> fmt::Display for Error<T> {
+impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let (module, e) = match self {
             Error::Reqwest(e) => ("reqwest", e.to_string()),
             Error::ReqwestMiddleware(e) => ("reqwest-middleware", e.to_string()),
             Error::Serde(e) => ("serde", e.to_string()),
             Error::Io(e) => ("IO", e.to_string()),
             Error::Response(e) => ("response", format!("status code {}", e.status)),
-            Error::_Phantom(_, _) => unreachable!(),
         };
         write!(f, "error in {}: {}", module, e)
     }
 }
 
-impl<T: fmt::Debug> error::Error for Error<T> {
+impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         Some(match self {
             Error::Reqwest(e) => e,
             Error::ReqwestMiddleware(e) => e,
             Error::Serde(e) => e,
             Error::Io(e) => e,
-            Error::Response(_) | Error::_Phantom(_, _) => return None,
+            Error::Response(_) => return None,
         })
     }
 }
 
-impl<T> From<reqwest::Error> for Error<T> {
+impl From<reqwest::Error> for Error {
     fn from(e: reqwest::Error) -> Self {
         Error::Reqwest(e)
     }
 }
 
-impl<T> From<reqwest_middleware::Error> for Error<T> {
+impl From<reqwest_middleware::Error> for Error {
     fn from(e: reqwest_middleware::Error) -> Self {
         Error::ReqwestMiddleware(e)
     }
 }
 
-impl<T> From<serde_json::Error> for Error<T> {
+impl From<serde_json::Error> for Error {
     fn from(e: serde_json::Error) -> Self {
         Error::Serde(e)
     }
 }
 
-impl<T> From<std::io::Error> for Error<T> {
+impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
         Error::Io(e)
     }
 }
 
-impl<T> From<ResponseContent> for Error<T> {
+impl From<ResponseContent> for Error {
     fn from(value: ResponseContent) -> Self {
         Self::Response(value)
     }

crates/bitwarden-api-base/src/request.rs

@@ -16,9 +16,9 @@ fn content_type(response: &reqwest::Response) -> ContentType {
 /// used with. This function contains the non-generic logic for processing the response so that it
 /// doesn't get duplicated.
 #[inline(never)]
-async fn process_with_json_response_internal<E>(
+async fn process_with_json_response_internal(
     request: reqwest_middleware::RequestBuilder,
-) -> Result<String, crate::Error<E>> {
+) -> Result<String, crate::Error> {
     let response = request.send().await?;
     let status = response.status();
     let content_type = content_type(&response);
@@ -41,19 +41,19 @@ async fn process_with_json_response_internal<E>(
 }
 
 /// Sends and processes a request expecting a JSON response, deserializing it into the type `T`.
-pub async fn process_with_json_response<T: DeserializeOwned, E>(
+pub async fn process_with_json_response<T: DeserializeOwned>(
     request: reqwest_middleware::RequestBuilder,
-) -> Result<T, crate::Error<E>> {
+) -> Result<T, crate::Error> {
     process_with_json_response_internal(request)
         .await
         .and_then(|content| serde_json::from_str(&content).map_err(Into::into))
 }
 
 /// Sends and processes a request expecting an empty response, returning `Ok(())` when successful.
 #[inline(never)]
-pub async fn process_with_empty_response<E>(
+pub async fn process_with_empty_response(
     request: reqwest_middleware::RequestBuilder,
-) -> Result<(), crate::Error<E>> {
+) -> Result<(), crate::Error> {
     let response = request.send().await?;
     let status = response.status();
 

crates/bitwarden-auth/src/login/login_via_password/password_prelogin.rs

@@ -45,8 +45,7 @@ impl LoginClient {
             .identity_client
             .accounts_api()
             .post_password_prelogin(Some(request_model))
-            .await
-            .map_err(ApiError::from)?;
+            .await?;
 
         Ok(PasswordPreloginResponse::try_from(response)?)
     }

crates/bitwarden-core/src/auth/login/auth_request.rs

@@ -5,7 +5,7 @@ use uuid::Uuid;
 
 use super::LoginError;
 use crate::{
-    ApiError, Client,
+    Client,
     auth::{
         api::{request::AuthRequestTokenRequest, response::IdentityTokenResponse},
         auth_request::new_auth_request,
@@ -49,8 +49,7 @@ pub(crate) async fn send_new_auth_request(
         .api_client
         .auth_requests_api()
         .post(Some(req))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
 
     Ok(NewAuthRequestResponse {
         fingerprint: auth.fingerprint,
@@ -71,8 +70,7 @@ pub(crate) async fn complete_auth_request(
         .api_client
         .auth_requests_api()
         .get_response(auth_req.auth_request_id, Some(&auth_req.access_code))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
 
     let approved = res.request_approved.unwrap_or(false);
 

crates/bitwarden-core/src/auth/login/prelogin.rs

@@ -20,8 +20,7 @@ pub(crate) async fn prelogin(client: &Client, email: String) -> Result<Kdf, Prel
         .identity_client
         .accounts_api()
         .post_password_prelogin(Some(request_model))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
 
     Ok(parse_prelogin(result)?)
 }

crates/bitwarden-core/src/auth/login/two_factor.rs

@@ -58,8 +58,7 @@ pub(crate) async fn send_two_factor_email(
             auth_request_id: None,
             sso_email2_fa_session_token: None,
         }))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
 
     Ok(())
 }

crates/bitwarden-core/src/error.rs

@@ -1,49 +1,10 @@
 //! Errors that can occur when using this SDK
 
-use std::fmt::Debug;
-
-use bitwarden_api_base::{Error as BaseApiError, ResponseContent};
+pub use bitwarden_api_base::Error as ApiError;
 #[cfg(feature = "internal")]
 use bitwarden_error::bitwarden_error;
 use thiserror::Error;
 
-/// Errors from performing network requests.
-#[allow(missing_docs)]
-#[derive(Debug, Error)]
-#[cfg_attr(feature = "uniffi", derive(uniffi::Error), uniffi(flat_error))]
-pub enum ApiError {
-    #[error(transparent)]
-    Reqwest(#[from] reqwest::Error),
-    #[error(transparent)]
-    ReqwestMiddleware(#[from] reqwest_middleware::Error),
-    #[error(transparent)]
-    Serde(#[from] serde_json::Error),
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-
-    #[error("Received error message from server: [{}] {}", _0.status, _0.message)]
-    Response(ResponseContent),
-}
-
-impl<T> From<BaseApiError<T>> for ApiError {
-    fn from(e: BaseApiError<T>) -> Self {
-        match e {
-            BaseApiError::Reqwest(e) => Self::Reqwest(e),
-            BaseApiError::ReqwestMiddleware(e) => Self::ReqwestMiddleware(e),
-            BaseApiError::Response(e) => Self::Response(e),
-            BaseApiError::Serde(e) => Self::Serde(e),
-            BaseApiError::Io(e) => Self::Io(e),
-            BaseApiError::_Phantom(_, _) => unreachable!(),
-        }
-    }
-}
-
-impl From<ResponseContent> for ApiError {
-    fn from(value: ResponseContent) -> Self {
-        Self::Response(value)
-    }
-}
-
 /// Client is not authenticated or the session has expired.
 #[derive(Debug, Error)]
 #[error("The client is not authenticated or the session has expired")]

crates/bitwarden-core/src/platform/get_user_api_key.rs

@@ -54,8 +54,7 @@ pub(crate) async fn get_user_api_key(
         .api_client
         .accounts_api()
         .api_key(Some(request))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
     UserApiKeyResponse::process_response(response)
 }
 

crates/bitwarden-send/src/access.rs

@@ -109,8 +109,7 @@ async fn access_send_v1(
     let resp = api_client
         .sends_api()
         .access(send_id, Some(models::SendAccessRequestModel { password }))
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
     Ok(resp.try_into()?)
 }
 
@@ -121,8 +120,7 @@ async fn access_send(
     let resp = api_client
         .sends_api()
         .access_using_auth(access_token)
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
     Ok(resp.try_into()?)
 }
 
@@ -139,8 +137,7 @@ async fn get_file_download_data_v1(
             file_id,
             Some(models::SendAccessRequestModel { password }),
         )
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
     Ok(resp.into())
 }
 
@@ -152,8 +149,7 @@ async fn get_file_download_data(
     let resp = api_client
         .sends_api()
         .get_send_file_download_data_using_auth(file_id, access_token)
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
     Ok(resp.into())
 }
 

crates/bitwarden-send/src/create.rs

@@ -133,11 +133,7 @@ async fn create_send<R: Repository<Send> + ?Sized>(
 
     let send_request = key_store.encrypt(request)?;
 
-    let resp = api_client
-        .sends_api()
-        .post(Some(send_request))
-        .await
-        .map_err(ApiError::from)?;
+    let resp = api_client.sends_api().post(Some(send_request)).await?;
 
     let send: Send = resp.try_into()?;
 

crates/bitwarden-send/src/create_file_send.rs

@@ -131,8 +131,7 @@ impl SendClient {
             .api_client
             .sends_api()
             .post_file(Some(send_request))
-            .await
-            .map_err(ApiError::from)?;
+            .await?;
 
         let url = require!(resp.url);
         let file_upload_type: FileUploadType = require!(resp.file_upload_type).try_into()?;
@@ -200,9 +199,7 @@ impl SendClient {
             .with_extension(AuthRequired::Bearer)
             .multipart(form);
 
-        bitwarden_api_base::process_with_empty_response(req_builder)
-            .await
-            .map_err(|e: bitwarden_api_api::apis::Error<()>| ApiError::from(e))?;
+        bitwarden_api_base::process_with_empty_response(req_builder).await?;
 
         Ok(())
     }
@@ -221,8 +218,7 @@ impl SendClient {
             .api_client
             .sends_api()
             .renew_file_upload(&send_id.to_string(), &file_id)
-            .await
-            .map_err(ApiError::from)?;
+            .await?;
 
         Ok(require!(resp.url))
     }

crates/bitwarden-send/src/delete.rs

@@ -22,11 +22,7 @@ async fn delete_send<R: Repository<Send> + ?Sized>(
     repository: &R,
     send_id: SendId,
 ) -> Result<(), DeleteSendError> {
-    api_client
-        .sends_api()
-        .delete(&send_id.to_string())
-        .await
-        .map_err(ApiError::from)?;
+    api_client.sends_api().delete(&send_id.to_string()).await?;
 
     repository.remove(send_id).await?;
 

crates/bitwarden-send/src/edit.rs

@@ -172,11 +172,7 @@ async fn edit_send<R: Repository<Send> + ?Sized>(
 
     let send_request = key_store.encrypt(request_with_key)?;
 
-    let resp = api_client
-        .sends_api()
-        .put(&id, Some(send_request))
-        .await
-        .map_err(ApiError::from)?;
+    let resp = api_client.sends_api().put(&id, Some(send_request)).await?;
 
     let send: Send = resp.try_into()?;
 

crates/bitwarden-send/src/remove_password.rs

@@ -33,8 +33,7 @@ async fn remove_send_password<R: Repository<Send> + ?Sized>(
     let resp = api_client
         .sends_api()
         .put_remove_password(&send_id.to_string())
-        .await
-        .map_err(ApiError::from)?;
+        .await?;
 
     let send: Send = resp.try_into()?;
 

crates/bitwarden-sync/src/sync_client.rs

@@ -162,8 +162,7 @@ impl SyncClient {
             .api_client
             .sync_api()
             .get(input.exclude_subdomains)
-            .await
-            .map_err(|e| SyncError::Api(e.into()))?;
+            .await?;
 
         Ok(sync)
     }