use crate::error::Error;
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::time::Duration;
use url::Url;
#[derive(Debug, Clone)]
pub struct Client {
base_url: Url,
http: reqwest::Client,
api_key: Option<String>,
}
impl Client {
pub fn new(
base_url: impl Into<String>,
api_key: Option<impl Into<String>>,
) -> Result<Self, Error> {
let mut builder = ClientBuilder::new(base_url);
if let Some(k) = api_key {
builder = builder.api_key(k);
}
builder.build()
}
pub fn builder(base_url: impl Into<String>) -> ClientBuilder {
ClientBuilder::new(base_url)
}
pub fn base_url(&self) -> &Url {
&self.base_url
}
pub(crate) fn http(&self) -> &reqwest::Client {
&self.http
}
pub(crate) fn api_key(&self) -> Option<&str> {
self.api_key.as_deref()
}
pub(crate) fn endpoint(&self, path: &str) -> Result<Url, Error> {
Ok(self.base_url.join(path)?)
}
pub(crate) fn endpoint_with_segment(
&self,
base_path: &str,
segment: &str,
) -> Result<Url, Error> {
let mut url = self.base_url.join(base_path.trim_end_matches('/'))?;
url.path_segments_mut()
.map_err(|()| Error::InvalidUrl("base URL cannot have path segments".into()))?
.push(segment);
Ok(url)
}
pub(crate) fn endpoint_with_segments(
&self,
base_path: &str,
segments: &[&str],
) -> Result<Url, Error> {
let mut url = self.base_url.join(base_path.trim_end_matches('/'))?;
{
let mut seg = url
.path_segments_mut()
.map_err(|()| Error::InvalidUrl("base URL cannot have path segments".into()))?;
for s in segments {
seg.push(s);
}
}
Ok(url)
}
pub(crate) async fn get_json<T: DeserializeOwned>(&self, url: Url) -> Result<T, Error> {
let mut req = self.http.get(url);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
let bytes = resp.bytes().await?;
Ok(serde_json::from_slice(&bytes)?)
}
pub(crate) async fn post_json<B: Serialize, T: DeserializeOwned>(
&self,
url: Url,
body: &B,
) -> Result<T, Error> {
let mut req = self.http.post(url).json(body);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
let bytes = resp.bytes().await?;
Ok(serde_json::from_slice(&bytes)?)
}
pub(crate) async fn get_json_with_query<Q: Serialize + ?Sized, T: DeserializeOwned>(
&self,
url: Url,
query: &Q,
) -> Result<T, Error> {
let mut req = self.http.get(url).query(query);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
let bytes = resp.bytes().await?;
Ok(serde_json::from_slice(&bytes)?)
}
pub(crate) async fn get_text(&self, url: Url) -> Result<String, Error> {
let mut req = self.http.get(url);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
Ok(resp.text().await?)
}
pub(crate) async fn patch_no_content<B: Serialize + ?Sized>(
&self,
url: Url,
body: &B,
) -> Result<(), Error> {
let mut req = self.http.patch(url).json(body);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
Ok(())
}
pub(crate) async fn delete_no_content(&self, url: Url) -> Result<(), Error> {
let mut req = self.http.delete(url);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
Ok(())
}
pub(crate) async fn post_multipart<T: DeserializeOwned>(
&self,
url: Url,
form: reqwest::multipart::Form,
) -> Result<T, Error> {
let mut req = self.http.post(url).multipart(form);
if let Some(key) = &self.api_key {
req = req.bearer_auth(key);
}
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let detail = resp.text().await.unwrap_or_default();
return Err(Error::Api { status, detail });
}
let bytes = resp.bytes().await?;
Ok(serde_json::from_slice(&bytes)?)
}
}
#[derive(Debug, Clone)]
pub struct ClientBuilder {
base_url: String,
api_key: Option<String>,
timeout: Option<Duration>,
}
impl ClientBuilder {
pub fn new(base_url: impl Into<String>) -> Self {
Self {
base_url: base_url.into(),
api_key: None,
timeout: None,
}
}
#[must_use]
pub fn api_key(mut self, key: impl Into<String>) -> Self {
self.api_key = Some(key.into());
self
}
#[must_use]
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn build(self) -> Result<Client, Error> {
let base_url = Url::parse(&self.base_url)?;
let mut rb = reqwest::Client::builder();
if let Some(t) = self.timeout {
rb = rb.timeout(t);
}
let http = rb.build()?;
Ok(Client {
base_url,
http,
api_key: self.api_key,
})
}
}