use std::sync::Arc;
use std::time::Duration;
use serde::de::DeserializeOwned;
use crate::core::credentials::SecretKey;
use crate::core::error::{DelopayError, Result};
use crate::http::hyper_backend::HyperTransport;
use crate::http::proxy::ProxyMode;
use crate::http::retry::{backoff, parse_retry_after};
use crate::http::transport::{HttpMethod, RawRequest, Transport, TransportErrorKind};
use crate::resources::api_keys::ApiKeys;
use crate::resources::audit::Audit;
use crate::resources::authentication::Authentication;
use crate::resources::availability_overrides::AvailabilityOverrides;
use crate::resources::billing::Billing;
use crate::resources::buyer_account::BuyerAccount;
use crate::resources::buyer_blocklist::BuyerBlocklist;
use crate::resources::buyer_conversations::BuyerConversations;
use crate::resources::buyer_evidence_reviews::BuyerEvidenceReviews;
use crate::resources::buyer_portal::BuyerPortal;
use crate::resources::chargeback_prevention::ChargebackPrevention;
use crate::resources::checkout_methods::CheckoutMethods;
use crate::resources::checkout_recovery::CheckoutRecovery;
use crate::resources::checkout_templates::CheckoutTemplates;
use crate::resources::connectors::Connectors;
use crate::resources::cost_rules::CostRules;
use crate::resources::customers::Customers;
use crate::resources::deployment_branding::DeploymentBranding;
use crate::resources::disputes::Disputes;
use crate::resources::ephemeral_keys::EphemeralKeys;
use crate::resources::events::Events;
use crate::resources::export::Export;
use crate::resources::external_records::ExternalRecords;
use crate::resources::fees::Fees;
use crate::resources::identity_verifications::IdentityVerifications;
use crate::resources::invoice_settings::InvoiceSettings;
use crate::resources::invoices::Invoices;
use crate::resources::live::Live;
use crate::resources::mandates::Mandates;
use crate::resources::merchant_accounts::MerchantAccounts;
use crate::resources::message_templates::MessageTemplates;
use crate::resources::operation_limits::OperationLimits;
use crate::resources::payment_links::PaymentLinks;
use crate::resources::payment_methods::PaymentMethods;
use crate::resources::payments::Payments;
use crate::resources::payouts::Payouts;
use crate::resources::paypal_disputes::PaypalDisputes;
use crate::resources::poll::Poll;
use crate::resources::processor_costs::ProcessorCosts;
use crate::resources::processor_imports::ProcessorImports;
use crate::resources::products::Products;
use crate::resources::profile_acquirers::ProfileAcquirers;
use crate::resources::profiles::Profiles;
use crate::resources::projects::Projects;
use crate::resources::refunds::Refunds;
use crate::resources::regions::Regions;
use crate::resources::relay::Relay;
use crate::resources::risk::Risk;
use crate::resources::routing::Routing;
use crate::resources::sell_to_restrictions::SellToRestrictions;
use crate::resources::settings::Settings;
use crate::resources::settlement::Settlement;
use crate::resources::shop_labels::ShopLabels;
use crate::resources::shops::Shops;
use crate::resources::stripe_connect::StripeConnect;
use crate::resources::subscriptions::Subscriptions;
use crate::resources::three_ds_rules::ThreeDsRules;
use crate::resources::users::Users;
use crate::resources::verification::Verification;
use crate::resources::whop_resolution_cases::WhopResolutionCases;
use crate::{PRODUCTION_URL, SANDBOX_URL};
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_MAX_RETRIES: u32 = 2;
#[derive(Debug, Clone)]
pub struct Delopay {
pub(crate) inner: Arc<Inner>,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum LogEvent<'a> {
Request {
method: &'a str,
url: &'a str,
query_keys: &'a [&'a str],
},
Response {
method: &'a str,
url: &'a str,
status: u16,
request_id: Option<&'a str>,
},
Retry {
method: &'a str,
url: &'a str,
attempt: u32,
max_retries: u32,
delay_ms: u64,
},
}
pub type DelopayLogger = Arc<dyn Fn(LogEvent<'_>) + Send + Sync>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum KeyPolicy {
ClientDefaultApplies,
BodyKeyOnly,
}
pub(crate) struct Inner {
transport: Arc<dyn Transport>,
base_url: String,
checkout_base_url: String,
api_key: String,
jwt: Option<String>,
max_retries: u32,
logger: Option<DelopayLogger>,
default_idempotency_key: Option<String>,
}
impl std::fmt::Debug for Inner {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Inner")
.field("base_url", &self.base_url)
.field("checkout_base_url", &self.checkout_base_url)
.field("max_retries", &self.max_retries)
.field("logger", &self.logger.is_some())
.finish_non_exhaustive()
}
}
impl Delopay {
pub fn new(api_key: impl Into<SecretKey>) -> Self {
Self::builder(api_key).build()
}
pub fn sandbox(api_key: impl Into<SecretKey>) -> Self {
Self::builder(api_key).sandbox(true).build()
}
pub fn builder(api_key: impl Into<SecretKey>) -> DelopayBuilder {
DelopayBuilder::new(api_key)
}
pub fn with_jwt(&self, token: impl Into<String>) -> Self {
Self {
inner: Arc::new(self.inner.clone_with_jwt(Some(token.into()))),
}
}
pub fn base_url(&self) -> &str {
&self.inner.base_url
}
pub fn with_idempotency_key(&self, key: impl Into<String>) -> Self {
Self {
inner: Arc::new(self.inner.clone_with_idempotency_key(Some(key.into()))),
}
}
pub fn payments(&self) -> Payments {
Payments::new(self.inner.clone())
}
pub fn refunds(&self) -> Refunds {
Refunds::new(self.inner.clone())
}
pub fn customers(&self) -> Customers {
Customers::new(self.inner.clone())
}
pub fn payment_methods(&self) -> PaymentMethods {
PaymentMethods::new(self.inner.clone())
}
pub fn payouts(&self) -> Payouts {
Payouts::new(self.inner.clone())
}
pub fn disputes(&self) -> Disputes {
Disputes::new(self.inner.clone())
}
pub fn paypal_disputes(&self) -> PaypalDisputes {
PaypalDisputes::new(self.inner.clone())
}
pub fn mandates(&self) -> Mandates {
Mandates::new(self.inner.clone())
}
pub fn events(&self) -> Events {
Events::new(self.inner.clone())
}
pub fn payment_links(&self) -> PaymentLinks {
PaymentLinks::new(self.inner.clone())
}
pub fn ephemeral_keys(&self) -> EphemeralKeys {
EphemeralKeys::new(self.inner.clone())
}
pub fn poll(&self) -> Poll {
Poll::new(self.inner.clone())
}
pub fn subscriptions(&self) -> Subscriptions {
Subscriptions::new(self.inner.clone())
}
pub fn export(&self) -> Export {
Export::new(self.inner.clone())
}
pub fn connectors(&self) -> Connectors {
Connectors::new(self.inner.clone())
}
pub fn merchant_accounts(&self) -> MerchantAccounts {
MerchantAccounts::new(self.inner.clone())
}
pub fn profiles(&self) -> Profiles {
Profiles::new(self.inner.clone())
}
pub fn profile_acquirers(&self) -> ProfileAcquirers {
ProfileAcquirers::new(self.inner.clone())
}
pub fn routing(&self) -> Routing {
Routing::new(self.inner.clone())
}
pub fn three_ds_rules(&self) -> ThreeDsRules {
ThreeDsRules::new(self.inner.clone())
}
pub fn api_keys(&self) -> ApiKeys {
ApiKeys::new(self.inner.clone())
}
pub fn authentication(&self) -> Authentication {
Authentication::new(self.inner.clone())
}
pub fn billing(&self) -> Billing {
Billing::new(self.inner.clone())
}
pub fn fees(&self) -> Fees {
Fees::new(self.inner.clone())
}
pub fn shops(&self) -> Shops {
Shops::new(self.inner.clone())
}
pub fn shop_labels(&self) -> ShopLabels {
ShopLabels::new(self.inner.clone())
}
pub fn projects(&self) -> Projects {
Projects::new(self.inner.clone())
}
pub fn regions(&self) -> Regions {
Regions::new(self.inner.clone())
}
pub fn users(&self) -> Users {
Users::new(self.inner.clone())
}
pub fn relay(&self) -> Relay {
Relay::new(self.inner.clone())
}
pub fn verification(&self) -> Verification {
Verification::new(self.inner.clone())
}
pub fn stripe_connect(&self) -> StripeConnect {
StripeConnect::new(self.inner.clone())
}
pub fn settlement(&self) -> Settlement {
Settlement::new(self.inner.clone())
}
pub fn operation_limits(&self) -> OperationLimits {
OperationLimits::new(self.inner.clone())
}
pub fn settings(&self) -> Settings {
Settings::new(self.inner.clone())
}
pub fn live(&self) -> Live {
Live::new(self.inner.clone())
}
pub fn deployment_branding(&self) -> DeploymentBranding {
DeploymentBranding::new(self.inner.clone())
}
pub fn checkout_methods(&self) -> CheckoutMethods {
CheckoutMethods::new(self.inner.clone())
}
pub fn checkout_recovery(&self) -> CheckoutRecovery {
CheckoutRecovery::new(self.inner.clone())
}
pub fn checkout_templates(&self) -> CheckoutTemplates {
CheckoutTemplates::new(self.inner.clone())
}
pub fn availability_overrides(&self) -> AvailabilityOverrides {
AvailabilityOverrides::new(self.inner.clone())
}
pub fn products(&self) -> Products {
Products::new(self.inner.clone())
}
pub fn invoices(&self) -> Invoices {
Invoices::new(self.inner.clone())
}
pub fn invoice_settings(&self) -> InvoiceSettings {
InvoiceSettings::new(self.inner.clone())
}
pub fn processor_costs(&self) -> ProcessorCosts {
ProcessorCosts::new(self.inner.clone())
}
pub fn cost_rules(&self) -> CostRules {
CostRules::new(self.inner.clone())
}
pub fn audit(&self) -> Audit {
Audit::new(self.inner.clone())
}
pub fn buyer_portal(&self) -> BuyerPortal {
BuyerPortal::new(self.inner.clone())
}
pub fn buyer_account(&self) -> BuyerAccount {
BuyerAccount::new(self.inner.clone())
}
pub fn buyer_conversations(&self) -> BuyerConversations {
BuyerConversations::new(self.inner.clone())
}
pub fn message_templates(&self) -> MessageTemplates {
MessageTemplates::new(self.inner.clone())
}
pub fn buyer_blocklist(&self) -> BuyerBlocklist {
BuyerBlocklist::new(self.inner.clone())
}
pub fn buyer_evidence_reviews(&self) -> BuyerEvidenceReviews {
BuyerEvidenceReviews::new(self.inner.clone())
}
pub fn external_records(&self) -> ExternalRecords {
ExternalRecords::new(self.inner.clone())
}
pub fn identity_verifications(&self) -> IdentityVerifications {
IdentityVerifications::new(self.inner.clone())
}
pub fn chargeback_prevention(&self) -> ChargebackPrevention {
ChargebackPrevention::new(self.inner.clone())
}
pub fn processor_imports(&self) -> ProcessorImports {
ProcessorImports::new(self.inner.clone())
}
pub fn risk(&self) -> Risk {
Risk::new(self.inner.clone())
}
pub fn sell_to_restrictions(&self) -> SellToRestrictions {
SellToRestrictions::new(self.inner.clone())
}
pub fn whop_resolution_cases(&self) -> WhopResolutionCases {
WhopResolutionCases::new(self.inner.clone())
}
pub fn hosted_checkout_url(&self, merchant_id: &str, payment_id: &str) -> String {
format!(
"{}/pay/{}/{}",
self.inner.checkout_base_url.trim_end_matches('/'),
merchant_id,
payment_id
)
}
}
impl Inner {
pub(crate) fn api_base_url(&self) -> &str {
&self.base_url
}
pub(crate) fn with_transport(
transport: Arc<dyn Transport>,
base_url: String,
checkout_base_url: String,
api_key: String,
max_retries: u32,
) -> Self {
Self {
transport,
base_url,
checkout_base_url,
api_key,
jwt: None,
max_retries,
logger: None,
default_idempotency_key: None,
}
}
pub(crate) fn with_jwt(mut self, jwt: Option<String>) -> Self {
self.jwt = jwt;
self
}
pub(crate) fn with_logger(mut self, logger: Option<DelopayLogger>) -> Self {
self.logger = logger;
self
}
pub(crate) fn clone_with_idempotency_key(&self, key: Option<String>) -> Self {
Self {
transport: self.transport.clone(),
base_url: self.base_url.clone(),
checkout_base_url: self.checkout_base_url.clone(),
api_key: self.api_key.clone(),
jwt: self.jwt.clone(),
max_retries: self.max_retries,
logger: self.logger.clone(),
default_idempotency_key: self.default_idempotency_key.clone(),
}
.with_idempotency_key_field(key)
}
fn with_idempotency_key_field(mut self, key: Option<String>) -> Self {
self.default_idempotency_key = key;
self
}
pub(crate) fn clone_with_jwt(&self, jwt: Option<String>) -> Self {
Self {
transport: self.transport.clone(),
base_url: self.base_url.clone(),
checkout_base_url: self.checkout_base_url.clone(),
api_key: self.api_key.clone(),
jwt,
max_retries: self.max_retries,
logger: self.logger.clone(),
default_idempotency_key: self.default_idempotency_key.clone(),
}
}
fn log(&self, event: LogEvent<'_>) {
if let Some(logger) = &self.logger {
logger(event);
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn send_raw(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
idempotency_key: Option<&str>,
extra_headers: &[(&str, &str)],
content_type: Option<&str>,
) -> Result<Vec<u8>> {
self.send_raw_keyed(
method,
path,
body,
query,
idempotency_key,
KeyPolicy::ClientDefaultApplies,
extra_headers,
content_type,
)
.await
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn send_raw_keyed(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
idempotency_key: Option<&str>,
key_policy: KeyPolicy,
extra_headers: &[(&str, &str)],
content_type: Option<&str>,
) -> Result<Vec<u8>> {
let url = format!("{}{}", self.base_url, path);
let idempotency_key = match idempotency_key {
Some(key) => Some(key),
None if method.is_inherently_idempotent() => None,
None if key_policy == KeyPolicy::BodyKeyOnly => None,
None => self.default_idempotency_key.as_deref(),
};
let is_idempotent = method.is_inherently_idempotent() || idempotency_key.is_some();
let method_str = method.as_str();
let mut attempt: u32 = 0;
let overrides_accept = extra_headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("accept"));
let bearer = self.jwt.as_deref().map(|token| format!("Bearer {token}"));
let sends_api_key = bearer.is_none() && !self.api_key.is_empty();
loop {
let mut headers: Vec<(&str, &str)> = Vec::with_capacity(4 + extra_headers.len());
if sends_api_key {
headers.push(("api-key", &self.api_key));
}
if let Some(bearer) = bearer.as_deref() {
headers.push(("authorization", bearer));
}
if !overrides_accept {
headers.push(("accept", "application/json"));
}
if let Some(key) = idempotency_key {
headers.push(("idempotency-key", key));
}
headers.extend_from_slice(extra_headers);
let req = RawRequest {
method,
url: &url,
headers: &headers,
query,
body,
content_type,
};
if self.logger.is_some() {
let query_keys: Vec<&str> = query.iter().map(|(k, _)| *k).collect();
self.log(LogEvent::Request {
method: method_str,
url: &url,
query_keys: &query_keys,
});
}
match self.transport.execute(req).await {
Ok(resp) => {
self.log(LogEvent::Response {
method: method_str,
url: &url,
status: resp.status,
request_id: resp.header("x-request-id"),
});
if resp.is_success() {
return Ok(resp.body);
}
let too_many = resp.status == 429;
let retriable = too_many || resp.is_server_error();
let may_retry =
attempt < self.max_retries && retriable && (too_many || is_idempotent);
if may_retry {
attempt += 1;
let delay = parse_retry_after(resp.header("retry-after"))
.unwrap_or_else(|| backoff(attempt));
self.log(LogEvent::Retry {
method: method_str,
url: &url,
attempt,
max_retries: self.max_retries,
delay_ms: delay.as_millis() as u64,
});
tokio::time::sleep(delay).await;
continue;
}
let request_id = resp.header("x-request-id").map(str::to_owned);
return Err(DelopayError::from_response(
resp.status,
request_id,
&resp.body,
));
}
Err(err) => {
if err.is_retriable() && is_idempotent && attempt < self.max_retries {
attempt += 1;
let delay = backoff(attempt);
self.log(LogEvent::Retry {
method: method_str,
url: &url,
attempt,
max_retries: self.max_retries,
delay_ms: delay.as_millis() as u64,
});
tokio::time::sleep(delay).await;
continue;
}
if err.kind == TransportErrorKind::Timeout {
return Err(DelopayError::Timeout);
}
return Err(DelopayError::Transport(err.source));
}
}
}
}
pub(crate) async fn request<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
idempotency_key: Option<&str>,
) -> Result<T> {
let bytes = self
.send_raw(method, path, body, query, idempotency_key, &[], None)
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_with_content_type<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: &[u8],
content_type: &str,
) -> Result<T> {
let bytes = self
.send_raw(method, path, Some(body), &[], None, &[], Some(content_type))
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_with_content_type_and_query<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
query: &[(&str, String)],
body: &[u8],
content_type: &str,
) -> Result<T> {
let bytes = self
.send_raw_keyed(
method,
path,
Some(body),
query,
None,
KeyPolicy::BodyKeyOnly,
&[],
Some(content_type),
)
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_bytes(
&self,
method: HttpMethod,
path: &str,
query: &[(&str, String)],
accept: &str,
) -> Result<Vec<u8>> {
self.send_raw(method, path, None, query, None, &[("accept", accept)], None)
.await
}
pub(crate) async fn request_body_keyed<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
body_key: Option<&str>,
) -> Result<T> {
let bytes = self
.send_raw_keyed(
method,
path,
body,
&[],
body_key,
KeyPolicy::BodyKeyOnly,
&[],
None,
)
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_body_keyed_with_query<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
body_key: Option<&str>,
) -> Result<T> {
let bytes = self
.send_raw_keyed(
method,
path,
body,
query,
body_key,
KeyPolicy::BodyKeyOnly,
&[],
None,
)
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_body_keyed_with_query_and_headers<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
extra_headers: &[(&str, &str)],
body_key: Option<&str>,
) -> Result<T> {
let bytes = self
.send_raw_keyed(
method,
path,
body,
query,
body_key,
KeyPolicy::BodyKeyOnly,
extra_headers,
None,
)
.await?;
decode_success(&bytes)
}
pub(crate) async fn request_with_headers<T: DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
idempotency_key: Option<&str>,
extra_headers: &[(&str, &str)],
) -> Result<T> {
let bytes = self
.send_raw(
method,
path,
body,
query,
idempotency_key,
extra_headers,
None,
)
.await?;
decode_success(&bytes)
}
}
fn decode_success<T: DeserializeOwned>(bytes: &[u8]) -> Result<T> {
let slice: &[u8] = if bytes.is_empty() { b"null" } else { bytes };
serde_json::from_slice(slice).map_err(|e| DelopayError::Decode(e.to_string()))
}
#[derive(Clone)]
pub struct DelopayBuilder {
api_key: String,
jwt: Option<String>,
base_url: Option<String>,
checkout_base_url: Option<String>,
sandbox: bool,
timeout: Duration,
max_retries: u32,
proxy: ProxyMode,
logger: Option<DelopayLogger>,
}
impl std::fmt::Debug for DelopayBuilder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DelopayBuilder")
.field("base_url", &self.base_url)
.field("checkout_base_url", &self.checkout_base_url)
.field("sandbox", &self.sandbox)
.field("timeout", &self.timeout)
.field("max_retries", &self.max_retries)
.field("proxy", &self.proxy)
.field("logger", &self.logger.is_some())
.finish_non_exhaustive()
}
}
impl DelopayBuilder {
fn new(api_key: impl Into<SecretKey>) -> Self {
Self {
api_key: api_key.into().into_string(),
jwt: None,
base_url: None,
checkout_base_url: None,
sandbox: false,
timeout: DEFAULT_TIMEOUT,
max_retries: DEFAULT_MAX_RETRIES,
proxy: ProxyMode::Env,
logger: None,
}
}
#[must_use]
pub fn jwt(mut self, token: impl Into<String>) -> Self {
self.jwt = Some(token.into());
self
}
pub(crate) fn for_checkout_session() -> Self {
Self::new(SecretKey::new(String::new()))
}
pub fn logger<F>(mut self, logger: F) -> Self
where
F: Fn(LogEvent<'_>) + Send + Sync + 'static,
{
self.logger = Some(Arc::new(logger));
self
}
pub fn debug(self, debug: bool) -> Self {
if !debug {
return self;
}
self.logger(|event| eprintln!("delopay: {event:?}"))
}
pub fn sandbox(mut self, sandbox: bool) -> Self {
self.sandbox = sandbox;
self
}
pub fn base_url(mut self, url: impl Into<String>) -> Self {
self.base_url = Some(url.into());
self
}
pub fn checkout_base_url(mut self, url: impl Into<String>) -> Self {
self.checkout_base_url = Some(url.into());
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn max_retries(mut self, max_retries: u32) -> Self {
self.max_retries = max_retries;
self
}
pub fn proxy(mut self, url: impl Into<String>) -> Self {
self.proxy = ProxyMode::Explicit(url.into());
self
}
pub fn no_proxy(mut self) -> Self {
self.proxy = ProxyMode::Disabled;
self
}
pub fn build(self) -> Delopay {
let api_key = self.api_key.clone();
let jwt = self.jwt.clone();
let parts = self.into_parts();
Delopay {
inner: Arc::new(parts.inner_with_key(api_key).with_jwt(jwt)),
}
}
pub(crate) fn into_parts(self) -> ClientParts {
let base_url = self.base_url.unwrap_or_else(|| {
if self.sandbox {
SANDBOX_URL
} else {
PRODUCTION_URL
}
.to_string()
});
let checkout_base_url = self
.checkout_base_url
.unwrap_or_else(|| crate::CHECKOUT_URL.to_string());
let proxy = crate::http::proxy::resolve(&self.proxy, &base_url);
let transport = Arc::new(HyperTransport::new(
self.timeout,
concat!("delopay-rust/", env!("CARGO_PKG_VERSION")),
proxy,
));
ClientParts {
transport,
base_url,
checkout_base_url,
max_retries: self.max_retries,
logger: self.logger,
}
}
}
pub(crate) struct ClientParts {
transport: Arc<dyn Transport>,
base_url: String,
checkout_base_url: String,
max_retries: u32,
logger: Option<DelopayLogger>,
}
impl ClientParts {
pub(crate) fn inner_with_key(&self, api_key: String) -> Inner {
Inner::with_transport(
self.transport.clone(),
self.base_url.clone(),
self.checkout_base_url.clone(),
api_key,
self.max_retries,
)
.with_logger(self.logger.clone())
}
#[cfg(test)]
pub(crate) fn for_test(transport: Arc<dyn Transport>, base_url: &str) -> Self {
Self {
transport,
base_url: base_url.to_string(),
checkout_base_url: "https://checkout.test".to_string(),
max_retries: 0,
logger: None,
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{Arc, Mutex};
use super::*;
use crate::http::mock::{MockTransport, SeenRequest, Step};
use crate::http::transport::TransportErrorKind;
const PAYMENT_JSON: &str = r#"{
"payment_id": "pay_1", "merchant_id": "mer_1", "status": "succeeded",
"amount": 100, "currency": "EUR"
}"#;
const REFUND_JSON: &str = r#"{
"refund_id": "ref_1", "payment_id": "pay_1", "amount": 500,
"currency": "EUR", "status": "succeeded"
}"#;
fn client_with(steps: Vec<Step>, max_retries: u32) -> (Delopay, Arc<MockTransport>) {
let mock = Arc::new(MockTransport::new(steps));
let inner = Inner::with_transport(
mock.clone(),
"https://api.test".to_string(),
"https://checkout.test".to_string(),
"prd_test".to_string(),
max_retries,
);
(
Delopay {
inner: Arc::new(inner),
},
mock,
)
}
#[test]
fn debug_never_renders_the_dashboard_token() {
const TOKEN: &str = "eyJhbGciOiJIUzI1NiJ9.dashboard-token-sentinel";
let builder = Delopay::builder("prd_secret_sentinel").jwt(TOKEN);
let rendered = format!("{builder:?}");
assert!(!rendered.contains(TOKEN), "builder leaked the token");
assert!(
!rendered.contains("prd_secret_sentinel"),
"builder leaked the api key"
);
let (client, _mock) = client_with(vec![], 0);
let with_token = client.with_jwt(TOKEN);
let rendered = format!("{with_token:?}");
assert!(!rendered.contains(TOKEN), "client leaked the token");
assert!(!rendered.contains("prd_test"), "client leaked the api key");
}
#[tokio::test]
async fn retries_429_even_for_non_idempotent_post() {
let (client, mock) =
client_with(vec![Step::status(429, ""), Step::ok(r#"{"ok":true}"#)], 2);
let out: serde_json::Value = client
.inner
.request(HttpMethod::Post, "/x", None, &[], None)
.await
.unwrap();
assert_eq!(out["ok"], true);
assert_eq!(mock.call_count(), 2);
}
#[tokio::test]
async fn does_not_retry_5xx_for_post_without_idempotency_key() {
let (client, mock) = client_with(vec![Step::status(500, "")], 2);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Post, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Api(_)));
assert_eq!(mock.call_count(), 1, "a bare POST must never be replayed");
}
#[tokio::test]
async fn retries_5xx_for_post_with_idempotency_key() {
let (client, mock) =
client_with(vec![Step::status(500, ""), Step::ok(r#"{"ok":true}"#)], 2);
let out: serde_json::Value = client
.inner
.request(HttpMethod::Post, "/x", None, &[], Some("key-1"))
.await
.unwrap();
assert_eq!(out["ok"], true);
assert_eq!(mock.call_count(), 2);
assert!(
mock.seen
.lock()
.unwrap()
.iter()
.all(SeenRequest::had_idempotency_key)
);
}
#[tokio::test]
async fn retries_5xx_for_get() {
let (client, mock) =
client_with(vec![Step::status(503, ""), Step::ok(r#"{"ok":true}"#)], 2);
let _: serde_json::Value = client
.inner
.request(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap();
assert_eq!(mock.call_count(), 2);
let seen = mock.seen.lock().unwrap();
for req in seen.iter() {
assert_eq!(req.method, "GET");
assert_eq!(req.url, "https://api.test/x");
}
}
#[tokio::test]
async fn stops_after_max_retries() {
let (client, mock) = client_with(
vec![
Step::status(500, ""),
Step::status(500, ""),
Step::status(500, ""),
],
2,
);
let _ = client
.inner
.request::<serde_json::Value>(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap_err();
assert_eq!(mock.call_count(), 3, "initial attempt + 2 retries");
}
#[tokio::test]
async fn timeout_maps_to_timeout_variant() {
let (client, _) = client_with(vec![Step::Fail(TransportErrorKind::Timeout)], 0);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Timeout));
}
#[tokio::test]
async fn connect_failure_maps_to_transport_variant() {
let (client, _) = client_with(vec![Step::Fail(TransportErrorKind::Connect)], 0);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Transport(_)));
}
#[tokio::test]
async fn maps_401_to_authentication_error() {
let (client, _) = client_with(
vec![Step::status(
401,
r#"{"error":{"code":"AUTH_01","type":"authentication_error","message":"bad key"}}"#,
)],
0,
);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap_err();
match err {
DelopayError::Authentication(api) => assert_eq!(api.code, "AUTH_01"),
other => panic!("expected Authentication, got {other:?}"),
}
}
#[tokio::test(start_paused = true)]
async fn honors_retry_after_header() {
let (client, mock) = client_with(
vec![
Step::status_with_header(429, "retry-after", "5"),
Step::ok(r#"{"ok":true}"#),
],
2,
);
let started = tokio::time::Instant::now();
let _: serde_json::Value = client
.inner
.request(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap();
let waited = started.elapsed();
assert_eq!(mock.call_count(), 2);
assert_eq!(
waited,
Duration::from_secs(5),
"must wait exactly the Retry-After value, not the {:?} backoff",
backoff(1)
);
}
#[tokio::test(start_paused = true)]
async fn falls_back_to_backoff_when_retry_after_absent() {
let (client, mock) =
client_with(vec![Step::status(429, ""), Step::ok(r#"{"ok":true}"#)], 2);
let started = tokio::time::Instant::now();
let _: serde_json::Value = client
.inner
.request(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap();
assert_eq!(mock.call_count(), 2);
assert_eq!(started.elapsed(), backoff(1));
}
#[tokio::test]
async fn post_without_idempotency_key_is_never_replayed_on_network_failure() {
let (client, mock) = client_with(vec![Step::Fail(TransportErrorKind::Timeout)], 2);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Post, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Timeout));
assert_eq!(
mock.call_count(),
1,
"a bare POST must never be replayed after a network failure — the \
original attempt may already have taken effect server-side"
);
}
#[tokio::test]
async fn post_with_idempotency_key_is_retried_on_network_failure() {
let (client, mock) = client_with(
vec![
Step::Fail(TransportErrorKind::Timeout),
Step::ok(r#"{"ok":true}"#),
],
2,
);
let out: serde_json::Value = client
.inner
.request(HttpMethod::Post, "/x", None, &[], Some("key-1"))
.await
.unwrap();
assert_eq!(out["ok"], true);
assert_eq!(mock.call_count(), 2);
}
#[tokio::test]
async fn extra_headers_reach_the_transport() {
let (client, mock) = client_with(vec![Step::ok(r#"{"ok":true}"#)], 0);
let _: serde_json::Value = client
.inner
.request_with_headers(
HttpMethod::Post,
"/x",
None,
&[],
None,
&[("x-profile-id", "pro_1")],
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("x-profile-id"), Some("pro_1"));
assert_eq!(
seen[0].header("api-key"),
Some("prd_test"),
"extra headers must be appended, not replace the built-in set"
);
}
#[tokio::test]
async fn put_without_idempotency_key_is_not_retried_on_5xx() {
let (client, mock) = client_with(vec![Step::status(500, "")], 2);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Put, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Api(_)));
assert_eq!(
mock.call_count(),
1,
"a bare PUT must never be replayed — this API uses PUT for \
state transitions, where a blind replay is not provably safe"
);
}
#[test]
fn delopay_builder_debug_redacts_api_key() {
let builder = Delopay::builder("prd_super_secret_key_for_debug_test");
let formatted = format!("{builder:?}");
assert!(
!formatted.contains("prd_super_secret_key_for_debug_test"),
"DelopayBuilder's Debug output must not contain the secret api key: {formatted}"
);
}
#[test]
fn delopay_builder_debug_redacts_proxy_credentials() {
let builder =
Delopay::builder("prd_x").proxy("http://alice:hunter2@corp-egress.internal:3128");
let formatted = format!("{builder:?}");
assert!(
!formatted.contains("hunter2") && !formatted.contains("alice"),
"DelopayBuilder's Debug output must not contain proxy credentials: {formatted}"
);
}
#[test]
fn inner_debug_redacts_api_key() {
let mock = Arc::new(MockTransport::new(vec![]));
let inner = Inner::with_transport(
mock,
"https://api.test".to_string(),
"https://checkout.test".to_string(),
"prd_super_secret_key_for_inner_debug_test".to_string(),
2,
);
let formatted = format!("{inner:?}");
assert!(
!formatted.contains("prd_super_secret_key_for_inner_debug_test"),
"Inner's Debug output must not contain the secret api key: {formatted}"
);
}
#[tokio::test]
async fn body_read_failure_is_not_retried_through_send_raw() {
let (client, mock) = client_with(vec![Step::Fail(TransportErrorKind::Body)], 2);
let err = client
.inner
.request::<serde_json::Value>(HttpMethod::Get, "/x", None, &[], None)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::Transport(_)));
assert_eq!(
mock.call_count(),
1,
"a Body read failure must never be retried"
);
}
fn capturing_logger() -> (DelopayLogger, Arc<Mutex<Vec<String>>>) {
let seen: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let sink = seen.clone();
let logger: DelopayLogger = Arc::new(move |event: LogEvent<'_>| {
sink.lock().unwrap().push(format!("{event:?}"));
});
(logger, seen)
}
fn client_with_logger(
steps: Vec<Step>,
max_retries: u32,
) -> (Delopay, Arc<MockTransport>, Arc<Mutex<Vec<String>>>) {
let mock = Arc::new(MockTransport::new(steps));
let (logger, seen) = capturing_logger();
let inner = Inner::with_transport(
mock.clone(),
"https://api.test".to_string(),
"https://checkout.test".to_string(),
"prd_test".to_string(),
max_retries,
)
.with_logger(Some(logger));
(
Delopay {
inner: Arc::new(inner),
},
mock,
seen,
)
}
#[tokio::test]
async fn logger_sees_request_and_response_but_never_secrets() {
let (client, _mock, seen) = client_with_logger(vec![Step::ok("[]")], 0);
let params = crate::CustomerListParams {
search: Some("ada@example.com".to_string()),
..Default::default()
};
client.customers().list(Some(¶ms)).await.unwrap();
let events = seen.lock().unwrap();
assert_eq!(events.len(), 2, "one request event, one response event");
assert!(events[0].starts_with("Request"));
assert!(events[0].contains("https://api.test/customers/list"));
assert!(events[1].starts_with("Response"));
assert!(events[1].contains("status: 200"));
let all = events.join("\n");
assert!(all.contains("search"));
assert!(!all.contains("ada@example.com"));
assert!(!all.contains("prd_test"));
}
#[tokio::test]
async fn logger_reports_each_retry_with_its_attempt_number() {
let (client, mock, seen) = client_with_logger(
vec![
Step::status(429, r#"{"error":{"message":"slow down"}}"#),
Step::ok(PAYMENT_JSON),
],
2,
);
client
.payments()
.create(&crate::PaymentCreateRequest::new(100, "EUR"))
.await
.unwrap();
assert_eq!(mock.call_count(), 2);
let events = seen.lock().unwrap();
let retries: Vec<&String> = events.iter().filter(|e| e.starts_with("Retry")).collect();
assert_eq!(retries.len(), 1);
assert!(retries[0].contains("attempt: 1"));
assert!(retries[0].contains("max_retries: 2"));
}
#[tokio::test]
async fn no_logger_installed_means_no_work_and_no_panic() {
let (client, mock) = client_with(vec![Step::ok("[]")], 0);
client.customers().list(None).await.unwrap();
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn with_idempotency_key_sets_the_header_on_a_post() {
let (client, mock) = client_with(vec![Step::ok(REFUND_JSON)], 0);
client
.with_idempotency_key("order-42")
.refunds()
.create(&crate::RefundCreateRequest::new("pay_1"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("idempotency-key"), Some("order-42"));
}
#[tokio::test]
async fn with_idempotency_key_leaves_get_requests_alone() {
let (client, mock) = client_with(vec![Step::ok("[]")], 0);
client
.with_idempotency_key("order-42")
.customers()
.list(None)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert!(
!seen[0].had_idempotency_key(),
"a GET is already replayable; the header would be noise"
);
}
#[tokio::test]
async fn a_per_call_idempotency_key_wins_over_the_client_default() {
let (client, mock) = client_with(vec![Step::ok(REFUND_JSON)], 0);
client
.with_idempotency_key("client-default")
.refunds()
.create_idempotent(&crate::RefundCreateRequest::new("pay_1"), "per-call")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("idempotency-key"), Some("per-call"));
}
#[tokio::test]
async fn client_default_idempotency_key_makes_a_post_retriable() {
let (client, mock) = client_with(
vec![
Step::status(500, r#"{"error":{"message":"boom"}}"#),
Step::ok(REFUND_JSON),
],
2,
);
client
.with_idempotency_key("order-42")
.refunds()
.create(&crate::RefundCreateRequest::new("pay_1"))
.await
.unwrap();
assert_eq!(mock.call_count(), 2);
}
#[tokio::test]
async fn the_original_client_is_unaffected_by_with_idempotency_key() {
let (client, mock) = client_with(vec![Step::ok(REFUND_JSON), Step::ok(REFUND_JSON)], 0);
let keyed = client.with_idempotency_key("order-42");
keyed
.refunds()
.create(&crate::RefundCreateRequest::new("pay_1"))
.await
.unwrap();
client
.refunds()
.create(&crate::RefundCreateRequest::new("pay_1"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert!(seen[0].had_idempotency_key());
assert!(!seen[1].had_idempotency_key());
}
#[test]
fn debug_output_never_reveals_whether_a_logger_holds_state() {
let builder = Delopay::builder("prd_secret").logger(|_| {});
let rendered = format!("{builder:?}");
assert!(rendered.contains("logger: true"));
assert!(!rendered.contains("prd_secret"));
}
}