133 lines
3.6 KiB
Rust
133 lines
3.6 KiB
Rust
use crate::email::Email;
|
|
use crate::error::{ApiError, Error, Result};
|
|
use crate::response::SendResponse;
|
|
use crate::util::normalize_non_empty;
|
|
use crate::wire::{WireEmail, WireSendResponse};
|
|
use reqwest::{Client as HttpClient, Url};
|
|
|
|
const DEFAULT_BASE_URL: &str = "https://api.useplunk.com/";
|
|
|
|
/// Async client for Plunk's transactional email API.
|
|
///
|
|
/// ```no_run
|
|
/// use plunk_rs::{Client, Email, EmailAddress};
|
|
///
|
|
/// # async fn demo() -> Result<(), Box<dyn std::error::Error>> {
|
|
/// let client = Client::new("sk_your_secret_key")?;
|
|
///
|
|
/// let email = Email::html("user@example.com", "Welcome", "<h1>Hello</h1>")?
|
|
/// .from(EmailAddress::named("My App", "hello@example.com")?)?
|
|
/// .reply_to("support@example.com")?;
|
|
///
|
|
/// let response = client.send(&email).await?;
|
|
/// assert_eq!(response.deliveries().len(), 1);
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
#[derive(Clone, Debug)]
|
|
pub struct Client {
|
|
http: HttpClient,
|
|
api_key: String,
|
|
base_url: Url,
|
|
}
|
|
|
|
impl Client {
|
|
/// Creates a client that targets Plunk's hosted API.
|
|
pub fn new(api_key: impl Into<String>) -> Result<Self> {
|
|
Self::builder(api_key).build()
|
|
}
|
|
|
|
/// Creates a builder for custom HTTP clients or self-hosted Plunk URLs.
|
|
pub fn builder(api_key: impl Into<String>) -> ClientBuilder {
|
|
ClientBuilder::new(api_key)
|
|
}
|
|
|
|
/// Sends a validated email via `POST /v1/send`.
|
|
pub async fn send(&self, email: &Email) -> Result<SendResponse> {
|
|
let response = self
|
|
.http
|
|
.post(self.base_url.join("v1/send").expect("valid send endpoint"))
|
|
.bearer_auth(&self.api_key)
|
|
.json(&WireEmail::from(email))
|
|
.send()
|
|
.await?;
|
|
|
|
let status = response.status();
|
|
|
|
if !status.is_success() {
|
|
let body = response.text().await?;
|
|
return Err(Error::Api(ApiError::from_response(status, body)));
|
|
}
|
|
|
|
let payload = response.json::<WireSendResponse>().await?;
|
|
if !payload.success {
|
|
return Err(Error::UnexpectedResponse(
|
|
"success=false in a successful API response".to_string(),
|
|
));
|
|
}
|
|
|
|
Ok(SendResponse::from(payload.data))
|
|
}
|
|
|
|
pub fn base_url(&self) -> &Url {
|
|
&self.base_url
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ClientBuilder {
|
|
api_key: String,
|
|
base_url: Url,
|
|
http: HttpClient,
|
|
}
|
|
|
|
impl ClientBuilder {
|
|
pub fn new(api_key: impl Into<String>) -> Self {
|
|
Self {
|
|
api_key: api_key.into(),
|
|
base_url: Url::parse(DEFAULT_BASE_URL).expect("default base URL must be valid"),
|
|
http: HttpClient::new(),
|
|
}
|
|
}
|
|
|
|
pub fn base_url(mut self, base_url: impl AsRef<str>) -> Result<Self> {
|
|
let mut parsed = Url::parse(base_url.as_ref())?;
|
|
if !parsed.path().ends_with('/') {
|
|
parsed.set_path(&format!("{}/", parsed.path()));
|
|
}
|
|
self.base_url = parsed;
|
|
Ok(self)
|
|
}
|
|
|
|
pub fn http_client(mut self, http: HttpClient) -> Self {
|
|
self.http = http;
|
|
self
|
|
}
|
|
|
|
pub fn build(self) -> Result<Client> {
|
|
let api_key = normalize_non_empty(self.api_key, Error::InvalidApiKey)?;
|
|
|
|
Ok(Client {
|
|
http: self.http,
|
|
api_key,
|
|
base_url: self.base_url,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn builder_normalizes_base_url_for_self_hosting() {
|
|
let client = Client::builder("sk_test")
|
|
.base_url("https://plunk.example.com/api")
|
|
.unwrap()
|
|
.build()
|
|
.unwrap();
|
|
|
|
assert_eq!(client.base_url().as_str(), "https://plunk.example.com/api/");
|
|
}
|
|
}
|