fix: fmt

crates/cdk-http-client/src/backends/bitreq_backend.rs

@@ -17,10 +17,7 @@ pub struct BitreqRequestBuilder {
 impl BitreqRequestBuilder {
     /// Create a new BitreqRequestBuilder from a bitreq::Request
     pub(crate) fn new(inner: bitreq::Request) -> Self {
-        Self {
-            inner,
-            error: None,
-        }
+        Self { inner, error: None }
     }
 }
 

crates/cdk-http-client/src/backends/mod.rs

@@ -8,6 +8,5 @@ pub mod reqwest_backend;
 
 #[cfg(feature = "bitreq")]
 pub use bitreq_backend::BitreqRequestBuilder;
-
 #[cfg(feature = "reqwest")]
 pub use reqwest_backend::ReqwestRequestBuilder;

crates/cdk-http-client/src/client.rs

@@ -1,10 +1,9 @@
 //! HTTP client wrapper
 
-use serde::de::DeserializeOwned;
-use serde::Serialize;
-
 #[cfg(feature = "bitreq")]
 use bitreq::RequestExt;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
 
 use crate::error::HttpError;
 use crate::request::RequestBuilder;
@@ -68,7 +67,13 @@ impl HttpClient {
         url: &str,
         body: &B,
     ) -> Response<R> {
-        let response = self.inner.post(url).json(body).send().await.map_err(HttpError::from)?;
+        let response = self
+            .inner
+            .post(url)
+            .json(body)
+            .send()
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status();
 
         if !status.is_success() {
@@ -88,7 +93,13 @@ impl HttpClient {
         url: &str,
         form: &F,
     ) -> Response<R> {
-        let response = self.inner.post(url).form(form).send().await.map_err(HttpError::from)?;
+        let response = self
+            .inner
+            .post(url)
+            .form(form)
+            .send()
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status();
 
         if !status.is_success() {
@@ -108,7 +119,13 @@ impl HttpClient {
         url: &str,
         body: &B,
     ) -> Response<R> {
-        let response = self.inner.patch(url).json(body).send().await.map_err(HttpError::from)?;
+        let response = self
+            .inner
+            .patch(url)
+            .json(body)
+            .send()
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status();
 
         if !status.is_success() {
@@ -160,7 +177,11 @@ impl HttpClient {
     }
 
     /// Helper method to apply proxy if URL matches the configured proxy rules
-    fn apply_proxy_if_needed(&self, request: bitreq::Request, url: &str) -> Response<bitreq::Request> {
+    fn apply_proxy_if_needed(
+        &self,
+        request: bitreq::Request,
+        url: &str,
+    ) -> Response<bitreq::Request> {
         if let Some(ref config) = self.proxy_config {
             if let Some(ref matcher) = config.matcher {
                 // Check if URL host matches the regex pattern
@@ -187,7 +208,10 @@ impl HttpClient {
     pub async fn fetch<R: DeserializeOwned>(&self, url: &str) -> Response<R> {
         let request = bitreq::get(url);
         let request = self.apply_proxy_if_needed(request, url)?;
-        let response = request.send_async_with_client(&self.inner).await.map_err(HttpError::from)?;
+        let response = request
+            .send_async_with_client(&self.inner)
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status_code;
 
         if !(200..300).contains(&status) {
@@ -207,11 +231,12 @@ impl HttpClient {
         url: &str,
         body: &B,
     ) -> Response<R> {
-        let request = bitreq::post(url)
-            .with_json(body)
-            .map_err(HttpError::from)?;
+        let request = bitreq::post(url).with_json(body).map_err(HttpError::from)?;
         let request = self.apply_proxy_if_needed(request, url)?;
-        let response: bitreq::Response = request.send_async_with_client(&self.inner).await.map_err(HttpError::from)?;
+        let response: bitreq::Response = request
+            .send_async_with_client(&self.inner)
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status_code;
 
         if !(200..300).contains(&status) {
@@ -235,7 +260,10 @@ impl HttpClient {
             .map_err(|e| HttpError::Serialization(e.to_string()))?;
         let request = bitreq::post(url).with_body(form_str.into_bytes());
         let request = self.apply_proxy_if_needed(request, url)?;
-        let response: bitreq::Response = request.send_async_with_client(&self.inner).await.map_err(HttpError::from)?;
+        let response: bitreq::Response = request
+            .send_async_with_client(&self.inner)
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status_code;
 
         if !(200..300).contains(&status) {
@@ -259,7 +287,10 @@ impl HttpClient {
             .with_json(body)
             .map_err(HttpError::from)?;
         let request = self.apply_proxy_if_needed(request, url)?;
-        let response: bitreq::Response = request.send_async_with_client(&self.inner).await.map_err(HttpError::from)?;
+        let response: bitreq::Response = request
+            .send_async_with_client(&self.inner)
+            .await
+            .map_err(HttpError::from)?;
         let status = response.status_code;
 
         if !(200..300).contains(&status) {
@@ -277,7 +308,10 @@ impl HttpClient {
     pub async fn get_raw(&self, url: &str) -> Response<RawResponse> {
         let request = bitreq::get(url);
         let request = self.apply_proxy_if_needed(request, url)?;
-        let response = request.send_async_with_client(&self.inner).await.map_err(HttpError::from)?;
+        let response = request
+            .send_async_with_client(&self.inner)
+            .await
+            .map_err(HttpError::from)?;
         Ok(RawResponse::new(response))
     }
 

crates/cdk-http-client/src/error.rs

@@ -54,9 +54,10 @@ impl From<reqwest::Error> for HttpError {
 #[cfg(feature = "bitreq")]
 impl From<bitreq::Error> for HttpError {
     fn from(err: bitreq::Error) -> Self {
-        use bitreq::Error;
         use std::io;
 
+        use bitreq::Error;
+
         match err {
             Error::InvalidUtf8InBody(_) => HttpError::Serialization(err.to_string()),
             Error::InvalidUtf8InResponse => HttpError::Serialization(err.to_string()),

crates/cdk-http-client/src/lib.rs

@@ -29,10 +29,8 @@ mod response;
 
 #[cfg(feature = "bitreq")]
 pub use backends::BitreqRequestBuilder;
-
 #[cfg(feature = "reqwest")]
 pub use backends::ReqwestRequestBuilder;
-
 pub use client::{fetch, HttpClient, HttpClientBuilder};
 pub use error::HttpError;
 pub use request::{RequestBuilder, RequestBuilderExt};

crates/cdk-http-client/src/request.rs

@@ -1,13 +1,11 @@
 //! HTTP request builder
 
-pub use crate::request_builder_ext::RequestBuilderExt;
-
 /// HTTP request builder for complex requests
 ///
 /// This is a type alias that resolves to either `BitreqRequestBuilder` or
 /// `ReqwestRequestBuilder` depending on the enabled feature.
 #[cfg(feature = "bitreq")]
 pub use crate::backends::BitreqRequestBuilder as RequestBuilder;
-
 #[cfg(feature = "reqwest")]
 pub use crate::backends::ReqwestRequestBuilder as RequestBuilder;
+pub use crate::request_builder_ext::RequestBuilderExt;

crates/cdk-npubcash/src/client.rs

@@ -2,8 +2,7 @@
 
 use std::sync::Arc;
 
-use cdk_http_client::{HttpClient, RawResponse};
-use cdk_http_client::RequestBuilderExt;
+use cdk_http_client::{HttpClient, RawResponse, RequestBuilderExt};
 use tracing::instrument;
 
 use crate::auth::JwtAuthProvider;