use crate::consts::{query_method, DEFAULT_MAX_REDIRECTS, HEADER_CONTENT_TYPE, MEDIA_TYPE_JSON};
use crate::error::{Error, Result};
use crate::response::Discovery;
use reqwest::redirect::Policy;
use reqwest::{Client as HttpClient, Method, Response, StatusCode, Url};
use serde::de::DeserializeOwned;
use serde::Serialize;
#[derive(Clone, Debug)]
pub struct Client {
http: HttpClient,
base_url: Option<Url>,
max_redirects: usize,
}
impl Client {
pub fn new() -> Self {
let http = HttpClient::builder()
.redirect(Policy::none())
.build()
.expect("building a default reqwest client should not fail");
Client {
http,
base_url: None,
max_redirects: DEFAULT_MAX_REDIRECTS,
}
}
pub fn with_http_client(http: HttpClient) -> Self {
Client {
http,
base_url: None,
max_redirects: DEFAULT_MAX_REDIRECTS,
}
}
pub fn with_base_url(mut self, base: &str) -> Result<Self> {
self.base_url = Some(Url::parse(base).map_err(|e| Error::Invalid(e.to_string()))?);
Ok(self)
}
pub fn with_max_redirects(mut self, max: usize) -> Self {
self.max_redirects = max;
self
}
fn resolve(&self, url: &str) -> Result<Url> {
match &self.base_url {
Some(base) => base.join(url).map_err(|e| Error::Invalid(e.to_string())),
None => Url::parse(url).map_err(|e| Error::Invalid(e.to_string())),
}
}
pub async fn query(
&self,
url: &str,
content_type: &str,
body: impl Into<Vec<u8>>,
) -> Result<Response> {
let mut target = self.resolve(url)?;
let body = body.into();
let mut method = query_method();
let mut send_body = true;
let mut redirects = 0usize;
loop {
let mut builder = self.http.request(method.clone(), target.clone());
if send_body {
builder = builder
.header(HEADER_CONTENT_TYPE, content_type)
.body(body.clone());
}
let resp = builder.send().await?;
if !is_redirect(resp.status()) {
return Ok(resp);
}
let location = resp
.headers()
.get(reqwest::header::LOCATION)
.and_then(|value| value.to_str().ok())
.filter(|value| !value.is_empty())
.map(|value| value.to_string());
let location = match location {
Some(location) => location,
None => return Ok(resp),
};
if redirects >= self.max_redirects {
return Err(Error::TooManyRedirects);
}
redirects += 1;
target = target
.join(&location)
.map_err(|e| Error::Invalid(e.to_string()))?;
if resp.status() == StatusCode::SEE_OTHER {
method = Method::GET;
send_body = false;
}
}
}
pub async fn query_string(
&self,
url: &str,
content_type: &str,
body: impl Into<String>,
) -> Result<Response> {
self.query(url, content_type, body.into()).await
}
pub async fn query_json<T: Serialize + ?Sized>(
&self,
url: &str,
value: &T,
) -> Result<Response> {
let body = serde_json::to_vec(value)?;
self.query(url, MEDIA_TYPE_JSON, body).await
}
pub async fn query_json_into<T, R>(&self, url: &str, value: &T) -> Result<R>
where
T: Serialize + ?Sized,
R: DeserializeOwned,
{
let resp = self.query_json(url, value).await?;
let resp = check_status(resp).await?;
Ok(resp.json::<R>().await?)
}
pub async fn options(&self, url: &str) -> Result<Discovery> {
let target = self.resolve(url)?;
let resp = self.http.request(Method::OPTIONS, target).send().await?;
Ok(Discovery::from_headers(resp.headers()))
}
pub async fn fetch_result(&self, resp: &Response) -> Result<Response> {
self.fetch_relative(
resp,
crate::consts::HEADER_CONTENT_LOCATION,
Error::NoQueryResult,
)
.await
}
pub async fn fetch_equivalent(&self, resp: &Response) -> Result<Response> {
self.fetch_relative(
resp,
crate::consts::HEADER_LOCATION,
Error::NoEquivalentResource,
)
.await
}
async fn fetch_relative(
&self,
resp: &Response,
header: &str,
missing: Error,
) -> Result<Response> {
let reference = resp
.headers()
.get(header)
.and_then(|value| value.to_str().ok())
.filter(|value| !value.is_empty());
let reference = match reference {
Some(reference) => reference,
None => return Err(missing),
};
let target = resp
.url()
.join(reference)
.map_err(|e| Error::Invalid(e.to_string()))?;
Ok(self.http.get(target).send().await?)
}
}
impl Default for Client {
fn default() -> Self {
Self::new()
}
}
fn is_redirect(status: StatusCode) -> bool {
matches!(
status,
StatusCode::MOVED_PERMANENTLY
| StatusCode::FOUND
| StatusCode::SEE_OTHER
| StatusCode::TEMPORARY_REDIRECT
| StatusCode::PERMANENT_REDIRECT
)
}
pub async fn check_status(resp: Response) -> Result<Response> {
if resp.status().is_success() {
Ok(resp)
} else {
let status = resp.status().as_u16();
let body = resp.text().await.unwrap_or_default();
Err(Error::Status { status, body })
}
}