use stk::packages::bytes::Bytes;
#[derive(Debug)]
struct Client {
client: reqwest::Client,
}
#[derive(Debug)]
pub struct Response {
response: reqwest::Response,
}
impl Response {
async fn text(self) -> stk::Result<String> {
let text = self.response.text().await?;
Ok(text)
}
}
#[derive(Debug)]
pub struct RequestBuilder {
request: reqwest::RequestBuilder,
}
impl RequestBuilder {
async fn send(self) -> stk::Result<Response> {
let response = self.request.send().await?;
Ok(Response { response })
}
async fn body_bytes(self, bytes: Bytes) -> stk::Result<Self> {
let bytes = bytes.into_inner();
Ok(Self {
request: self.request.body(bytes),
})
}
}
impl Client {
fn new() -> Self {
Self {
client: reqwest::Client::new(),
}
}
async fn get(&self, url: &str) -> stk::Result<RequestBuilder> {
let request = self.client.get(url);
Ok(RequestBuilder { request })
}
async fn post(&self, url: &str) -> stk::Result<RequestBuilder> {
let request = self.client.post(url);
Ok(RequestBuilder { request })
}
}
async fn get(url: &str) -> stk::Result<Response> {
Ok(Response {
response: reqwest::get(url).await?,
})
}
stk::decl_external!(Client);
stk::decl_external!(Response);
stk::decl_external!(RequestBuilder);
pub fn module() -> Result<stk::Module, stk::ContextError> {
let mut module = stk::Module::new(&["http"]);
module.ty(&["Client"]).build::<Client>()?;
module.ty(&["Response"]).build::<Response>()?;
module.ty(&["RequestBuilder"]).build::<RequestBuilder>()?;
module.function(&["Client", "new"], Client::new)?;
module.async_function(&["get"], get)?;
module.async_inst_fn("get", Client::get)?;
module.async_inst_fn("post", Client::post)?;
module.async_inst_fn("text", Response::text)?;
module.async_inst_fn("send", RequestBuilder::send)?;
module.async_inst_fn("body_bytes", RequestBuilder::body_bytes)?;
Ok(module)
}