use std::fmt;
use std::marker::PhantomData;
use serde::{de::DeserializeOwned, Serialize};
use crate::client::Client;
use crate::error::Result;
use crate::header::{HeaderMap, HeaderName, HeaderValue};
use crate::headers::HeaderBag;
#[must_use = "request builders do nothing until `.send().await` is called"]
#[cfg_attr(docsrs, doc(cfg(any(feature = "export", feature = "messaging"))))]
pub struct RequestBuilder<'a, 'r, Req, Resp> {
client: &'a Client,
segments: Vec<&'r str>,
body: &'r Req,
headers: HeaderBag,
response: PhantomData<fn() -> Resp>,
}
#[cfg_attr(docsrs, doc(cfg(any(feature = "export", feature = "messaging"))))]
impl<Req: fmt::Debug, Resp> fmt::Debug for RequestBuilder<'_, '_, Req, Resp> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RequestBuilder")
.field("client", self.client)
.field("segments", &self.segments)
.field("body", self.body)
.field("headers", &self.headers)
.finish()
}
}
#[cfg_attr(docsrs, doc(cfg(any(feature = "export", feature = "messaging"))))]
impl<'a, 'r, Req, Resp> RequestBuilder<'a, 'r, Req, Resp> {
pub(crate) fn new(client: &'a Client, segments: Vec<&'r str>, body: &'r Req) -> Self {
Self {
client,
segments,
body,
headers: HeaderBag::default(),
response: PhantomData,
}
}
pub fn header<N, V>(mut self, name: N, value: V) -> Self
where
N: TryInto<HeaderName> + AsRef<str>,
V: TryInto<HeaderValue>,
{
self.headers.add(name, value);
self
}
pub fn headers(mut self, headers: HeaderMap) -> Self {
self.headers.merge(headers);
self
}
}
#[cfg_attr(docsrs, doc(cfg(any(feature = "export", feature = "messaging"))))]
impl<Req, Resp> RequestBuilder<'_, '_, Req, Resp>
where
Req: Serialize,
Resp: DeserializeOwned,
{
#[cfg_attr(feature = "trace", tracing::instrument(skip_all))]
pub async fn send(self) -> Result<Resp> {
crate::http::post_json(
self.client,
&self.segments,
self.headers.finish()?,
self.body,
)
.await
}
}