use std::future::Future;
use std::time::Duration;
use crate::error::TransportError;
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct HttpRequest<'a> {
pub url: &'a str,
pub body: String,
pub content_type: &'static str,
pub user_agent: &'a str,
pub timeout: Duration,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct HttpResponse {
pub status: u16,
pub body: Vec<u8>,
}
impl HttpResponse {
pub fn new(status: u16, body: Vec<u8>) -> Self {
Self { status, body }
}
}
#[cfg(not(target_arch = "wasm32"))]
pub trait Transport: Send + Sync {
fn send(
&self,
request: HttpRequest<'_>,
) -> impl Future<Output = Result<HttpResponse, TransportError>> + Send;
}
#[cfg(target_arch = "wasm32")]
pub trait Transport {
fn send(
&self,
request: HttpRequest<'_>,
) -> impl Future<Output = Result<HttpResponse, TransportError>>;
}
#[cfg(feature = "reqwest")]
#[derive(Debug, Clone)]
pub struct ReqwestTransport {
client: reqwest::Client,
}
#[cfg(feature = "reqwest")]
impl Default for ReqwestTransport {
fn default() -> Self {
Self {
client: reqwest::Client::new(),
}
}
}
#[cfg(feature = "reqwest")]
impl From<reqwest::Client> for ReqwestTransport {
fn from(client: reqwest::Client) -> Self {
Self { client }
}
}
#[cfg(feature = "reqwest")]
impl Transport for ReqwestTransport {
async fn send(&self, request: HttpRequest<'_>) -> Result<HttpResponse, TransportError> {
let error = |err: reqwest::Error| {
if err.is_timeout() {
TransportError::timeout(err)
} else {
TransportError::new(err)
}
};
let response = self
.client
.post(request.url)
.header(reqwest::header::CONTENT_TYPE, request.content_type)
.header(reqwest::header::USER_AGENT, request.user_agent)
.timeout(request.timeout)
.body(request.body)
.send()
.await
.map_err(error)?;
let status = response.status().as_u16();
let body = response.bytes().await.map_err(error)?;
Ok(HttpResponse::new(status, body.to_vec()))
}
}