use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::processor_cost::ProcessorCostScheduleResponse;
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct ProcessorCosts {
inner: Arc<Inner>,
}
impl ProcessorCosts {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn list(&self, merchant_id: &str) -> Result<Vec<ProcessorCostScheduleResponse>> {
self.inner
.request(
HttpMethod::Get,
"/processor-costs",
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn create(
&self,
merchant_id: &str,
params: &CreateProcessorCostScheduleRequest,
) -> Result<ProcessorCostScheduleResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/processor-costs",
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn bulk_create(
&self,
merchant_id: &str,
params: &BulkCreateProcessorCostSchedulesRequest,
) -> Result<Vec<ProcessorCostScheduleResponse>> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/processor-costs/bulk",
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn update(
&self,
merchant_id: &str,
schedule_id: &str,
params: &UpdateProcessorCostScheduleRequest,
) -> Result<ProcessorCostScheduleResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
&schedule_path(schedule_id),
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn replace(
&self,
merchant_id: &str,
schedule_id: &str,
params: &ReplaceProcessorCostScheduleRequest,
) -> Result<ProcessorCostScheduleResponse> {
let body = to_json_vec(params)?;
let path = format!("{}/replace", schedule_path(schedule_id));
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
&path,
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn delete(&self, merchant_id: &str, schedule_id: &str) -> Result<()> {
self.inner
.request_body_keyed_with_query::<serde::de::IgnoredAny>(
HttpMethod::Delete,
&schedule_path(schedule_id),
None,
&merchant_query(merchant_id),
None,
)
.await
.map(|_| ())
}
}
fn schedule_path(schedule_id: &str) -> String {
format!("/processor-costs/{}", encode_segment(schedule_id))
}
fn merchant_query(merchant_id: &str) -> Vec<(&'static str, String)> {
vec![("merchant_id", merchant_id.to_string())]
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateProcessorCostScheduleRequest {
pub connector: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub shop_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_network: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_method_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_fee_percentage: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub min_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_from: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_to: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl CreateProcessorCostScheduleRequest {
pub fn new(connector: impl Into<String>) -> Self {
Self {
connector: connector.into(),
..Default::default()
}
}
#[must_use]
pub fn shop_id(mut self, shop_id: impl Into<String>) -> Self {
self.shop_id = Some(shop_id.into());
self
}
#[must_use]
pub fn payment_method(mut self, payment_method: impl Into<String>) -> Self {
self.payment_method = Some(payment_method.into());
self
}
#[must_use]
pub fn card_network(mut self, card_network: impl Into<String>) -> Self {
self.card_network = Some(card_network.into());
self
}
#[must_use]
pub fn payment_method_type(mut self, payment_method_type: impl Into<String>) -> Self {
self.payment_method_type = Some(payment_method_type.into());
self
}
#[must_use]
pub fn connector_method_code(mut self, connector_method_code: impl Into<String>) -> Self {
self.connector_method_code = Some(connector_method_code.into());
self
}
#[must_use]
pub fn percentage(mut self, percentage: f64) -> Self {
self.percentage = Some(percentage);
self
}
#[must_use]
pub fn provider_fee_percentage(mut self, provider_fee_percentage: f64) -> Self {
self.provider_fee_percentage = Some(provider_fee_percentage);
self
}
#[must_use]
pub fn flat_amount(mut self, flat_amount: i64) -> Self {
self.flat_amount = Some(flat_amount);
self
}
#[must_use]
pub fn flat_currency(mut self, flat_currency: impl Into<String>) -> Self {
self.flat_currency = Some(flat_currency.into());
self
}
#[must_use]
pub fn min_amount(mut self, min_amount: i64) -> Self {
self.min_amount = Some(min_amount);
self
}
#[must_use]
pub fn max_amount(mut self, max_amount: i64) -> Self {
self.max_amount = Some(max_amount);
self
}
#[must_use]
pub fn effective_from(mut self, effective_from: impl Into<String>) -> Self {
self.effective_from = Some(effective_from.into());
self
}
#[must_use]
pub fn effective_to(mut self, effective_to: impl Into<String>) -> Self {
self.effective_to = Some(effective_to.into());
self
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
const CREATE_PROCESSOR_COST_SCHEDULE_REQUEST_NAMED: &[&str] = &[
"connector",
"shop_id",
"payment_method",
"card_network",
"payment_method_type",
"connector_method_code",
"percentage",
"provider_fee_percentage",
"flat_amount",
"flat_currency",
"min_amount",
"max_amount",
"effective_from",
"effective_to",
"description",
];
impl ValidateRequest for CreateProcessorCostScheduleRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CREATE_PROCESSOR_COST_SCHEDULE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on CreateProcessorCostScheduleRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct BulkCreateProcessorCostSchedulesRequest {
pub schedules: Vec<CreateProcessorCostScheduleRequest>,
}
impl BulkCreateProcessorCostSchedulesRequest {
pub fn new(schedules: Vec<CreateProcessorCostScheduleRequest>) -> Self {
Self { schedules }
}
}
impl ValidateRequest for BulkCreateProcessorCostSchedulesRequest {
fn validate(&self) -> Result<()> {
self.schedules
.iter()
.try_for_each(CreateProcessorCostScheduleRequest::validate)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateProcessorCostScheduleRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_to: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
impl UpdateProcessorCostScheduleRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn effective_to(mut self, effective_to: impl Into<String>) -> Self {
self.effective_to = Some(effective_to.into());
self
}
#[must_use]
pub fn is_active(mut self, is_active: bool) -> Self {
self.is_active = Some(is_active);
self
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ReplaceProcessorCostScheduleRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_fee_percentage: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub min_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_from: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
impl ReplaceProcessorCostScheduleRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn percentage(mut self, percentage: f64) -> Self {
self.percentage = Some(percentage);
self
}
#[must_use]
pub fn provider_fee_percentage(mut self, provider_fee_percentage: f64) -> Self {
self.provider_fee_percentage = Some(provider_fee_percentage);
self
}
#[must_use]
pub fn flat_amount(mut self, flat_amount: i64) -> Self {
self.flat_amount = Some(flat_amount);
self
}
#[must_use]
pub fn flat_currency(mut self, flat_currency: impl Into<String>) -> Self {
self.flat_currency = Some(flat_currency.into());
self
}
#[must_use]
pub fn min_amount(mut self, min_amount: i64) -> Self {
self.min_amount = Some(min_amount);
self
}
#[must_use]
pub fn max_amount(mut self, max_amount: i64) -> Self {
self.max_amount = Some(max_amount);
self
}
#[must_use]
pub fn effective_from(mut self, effective_from: impl Into<String>) -> Self {
self.effective_from = Some(effective_from.into());
self
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with, client_with_retries};
use serde_json::json;
const SCHEDULE_JSON: &str = r#"{
"id": "pcs_1",
"merchant_id": "mer_1",
"shop_id": null,
"connector": "stripe",
"payment_method": "card",
"card_network": "Visa",
"percentage": 2.9,
"flat_amount": 30,
"flat_currency": "USD",
"effective_from": "2026-01-01T00:00:00Z",
"is_active": true,
"surprise_field": 1
}"#;
#[tokio::test]
async fn list_gets_the_merchant_schedules() {
let (client, mock) = client_with(vec![Step::ok(&format!("[{SCHEDULE_JSON}]"))]);
let out = client.processor_costs().list("mer_1").await.unwrap();
assert_eq!(out[0].id, "pcs_1");
assert_eq!(out[0].percentage, Some(2.9));
assert!(out[0].shop_id.is_none());
assert_eq!(out[0].extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs?merchant_id=mer_1"
);
}
#[tokio::test]
async fn create_posts_the_schedule_and_omits_unset_scope() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let params = CreateProcessorCostScheduleRequest::new("stripe")
.payment_method("card")
.percentage(2.9)
.flat_amount(30);
let out = client
.processor_costs()
.create("mer_1", ¶ms)
.await
.unwrap();
assert_eq!(out.connector, "stripe");
assert_eq!(out.flat_amount, Some(30));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({"connector":"stripe","payment_method":"card","percentage":2.9,
"flat_amount":30})
);
}
#[tokio::test]
async fn bulk_create_posts_every_schedule_in_order() {
let (client, mock) = client_with(vec![Step::ok(&format!(
"[{SCHEDULE_JSON},{SCHEDULE_JSON}]"
))]);
let params = BulkCreateProcessorCostSchedulesRequest::new(vec![
CreateProcessorCostScheduleRequest::new("stripe").card_network("Visa"),
CreateProcessorCostScheduleRequest::new("stripe").card_network("Amex"),
]);
let out = client
.processor_costs()
.bulk_create("mer_1", ¶ms)
.await
.unwrap();
assert_eq!(out.len(), 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs/bulk?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({"schedules":[
{"connector":"stripe","card_network":"Visa"},
{"connector":"stripe","card_network":"Amex"}]})
);
}
#[tokio::test]
async fn update_puts_the_encoded_schedule_path() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let params = UpdateProcessorCostScheduleRequest::new()
.effective_to("2026-06-01T00:00:00Z")
.is_active(false);
client
.processor_costs()
.update("mer_1", "pcs/1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs/pcs%2F1?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({"effective_to":"2026-06-01T00:00:00Z","is_active":false})
);
}
#[tokio::test]
async fn replace_posts_the_new_rate() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let params = ReplaceProcessorCostScheduleRequest::new()
.percentage(3.1)
.effective_from("2026-07-01T00:00:00Z");
let out = client
.processor_costs()
.replace("mer_1", "pcs/1", ¶ms)
.await
.unwrap();
assert_eq!(out.id, "pcs_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs/pcs%2F1/replace?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({"percentage":3.1,"effective_from":"2026-07-01T00:00:00Z"})
);
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn replace_ignores_a_client_wide_key_and_is_not_replayed() {
let (client, mock) = client_with_retries(
vec![
Step::status(503, r#"{"error":{"message":"down"}}"#),
Step::ok(SCHEDULE_JSON),
],
2,
);
let params = ReplaceProcessorCostScheduleRequest::new().percentage(3.1);
assert!(
client
.with_idempotency_key("client-key")
.processor_costs()
.replace("mer_1", "pcs_1", ¶ms)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
assert!(!mock.seen.lock().unwrap()[0].had_idempotency_key());
}
#[tokio::test]
async fn create_ignores_a_client_wide_key_and_is_not_replayed() {
let (client, mock) = client_with_retries(
vec![
Step::status(503, r#"{"error":{"message":"down"}}"#),
Step::ok(SCHEDULE_JSON),
],
2,
);
let params = CreateProcessorCostScheduleRequest::new("stripe");
assert!(
client
.with_idempotency_key("client-key")
.processor_costs()
.create("mer_1", ¶ms)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
assert!(!mock.seen.lock().unwrap()[0].had_idempotency_key());
}
#[tokio::test]
async fn replace_without_a_key_is_not_replayed_on_a_server_error() {
let (client, mock) = client_with_retries(vec![Step::status(500, "{}")], 2);
let params = ReplaceProcessorCostScheduleRequest::new().percentage(3.1);
assert!(
client
.processor_costs()
.replace("mer_1", "pcs_1", ¶ms)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
assert!(!mock.seen.lock().unwrap()[0].had_idempotency_key());
}
#[tokio::test]
async fn delete_deletes_the_encoded_schedule_and_accepts_the_api_body() {
let (client, mock) = client_with(vec![Step::ok(r#"{"deleted":true,"id":"pcs/1"}"#)]);
client
.processor_costs()
.delete("mer_1", "pcs/1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/processor-costs/pcs%2F1?merchant_id=mer_1"
);
}
#[tokio::test]
async fn delete_accepts_an_empty_body() {
let (client, _mock) = client_with(vec![Step::ok("")]);
client
.processor_costs()
.delete("mer_1", "pcs_1")
.await
.unwrap();
}
#[test]
fn create_processor_cost_schedule_request_named_fields_are_complete() {
let req = CreateProcessorCostScheduleRequest::new("stripe")
.shop_id("pro_1")
.payment_method("card")
.card_network("Visa")
.payment_method_type("credit")
.connector_method_code("code_1")
.percentage(2.9)
.provider_fee_percentage(0.5)
.flat_amount(30)
.flat_currency("USD")
.min_amount(10)
.max_amount(1000)
.effective_from("2026-01-01T00:00:00Z")
.effective_to("2027-01-01T00:00:00Z")
.description("contract A");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
CREATE_PROCESSOR_COST_SCHEDULE_REQUEST_NAMED.contains(&key.as_str()),
"CREATE_PROCESSOR_COST_SCHEDULE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn bulk_validate_rejects_a_colliding_extra_key_in_any_entry() {
let mut second = CreateProcessorCostScheduleRequest::new("stripe");
second.extra.insert("connector".to_string(), json!("adyen"));
let req = BulkCreateProcessorCostSchedulesRequest::new(vec![
CreateProcessorCostScheduleRequest::new("stripe"),
second,
]);
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("connector")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
}