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::fee::{
FeeRulePreviewResponse, FeeScheduleResponse, PlatformFeeRuleRecord,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
use crate::resources::fee_program::PlatformFeeProgram;
pub use crate::core::models::fee::FeeType;
#[derive(Debug, Clone)]
pub struct Fees {
inner: Arc<Inner>,
}
impl Fees {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub fn rules(&self) -> FeeRules {
FeeRules::new(self.inner.clone())
}
pub async fn create(
&self,
params: &FeeScheduleCreateRequest,
merchant_id: &str,
) -> Result<FeeScheduleResponse> {
params.validate()?;
let body = to_json_vec(params)?;
let query = [("merchant_id", merchant_id.to_string())];
self.inner
.request(
HttpMethod::Post,
"/merchant-fees",
Some(&body),
&query,
None,
)
.await
}
pub async fn list(&self, merchant_id: &str) -> Result<Vec<FeeScheduleResponse>> {
let query = [("merchant_id", merchant_id.to_string())];
self.inner
.request(HttpMethod::Get, "/merchant-fees/list", None, &query, None)
.await
}
pub async fn update(
&self,
fee_id: &str,
params: &FeeScheduleUpdateRequest,
) -> Result<FeeScheduleResponse> {
params.validate()?;
let body = to_json_vec(params)?;
let path = format!("/merchant-fees/{}", encode_segment(fee_id));
self.inner
.request(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn delete(&self, fee_id: &str) -> Result<FeeScheduleResponse> {
let path = format!("/merchant-fees/{}", encode_segment(fee_id));
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
}
#[derive(Debug, Clone)]
pub struct FeeRules {
inner: Arc<Inner>,
}
const MERCHANT_FEE_OWNER: &str = "merchant";
impl FeeRules {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn upsert(&self, params: &Value, merchant_id: &str) -> Result<PlatformFeeRuleRecord> {
let body = to_json_vec(&with_merchant_fee_owner(params)?)?;
let query = [("merchant_id", merchant_id.to_string())];
self.inner
.request(
HttpMethod::Put,
"/merchant-fees/rules",
Some(&body),
&query,
None,
)
.await
}
pub async fn upsert_program(
&self,
program: &PlatformFeeProgram,
profile_id: Option<&str>,
merchant_id: &str,
) -> Result<PlatformFeeRuleRecord> {
let mut body = serde_json::Map::new();
let algorithm =
serde_json::to_value(program).map_err(|e| DelopayError::Decode(e.to_string()))?;
body.insert("algorithm".to_string(), algorithm);
if let Some(id) = profile_id {
body.insert("profile_id".to_string(), Value::String(id.to_string()));
}
self.upsert(&Value::Object(body), merchant_id).await
}
pub async fn retrieve(
&self,
merchant_id: &str,
profile_id: Option<&str>,
) -> Result<Option<PlatformFeeRuleRecord>> {
let query = rules_query(merchant_id, profile_id);
self.inner
.request(HttpMethod::Get, "/merchant-fees/rules", None, &query, None)
.await
}
pub async fn delete(&self, merchant_id: &str, profile_id: Option<&str>) -> Result<()> {
let query = rules_query(merchant_id, profile_id);
self.inner
.request(
HttpMethod::Delete,
"/merchant-fees/rules",
None,
&query,
None,
)
.await
}
pub async fn preview(
&self,
input: &Value,
merchant_id: &str,
) -> Result<FeeRulePreviewResponse> {
let body = to_json_vec(input)?;
let query = [("merchant_id", merchant_id.to_string())];
self.inner
.request(
HttpMethod::Post,
"/merchant-fees/rules/preview",
Some(&body),
&query,
None,
)
.await
}
}
fn rules_query(merchant_id: &str, profile_id: Option<&str>) -> Vec<(&'static str, String)> {
let mut q = vec![("merchant_id", merchant_id.to_string())];
if let Some(id) = profile_id {
q.push(("profile_id", id.to_string()));
}
q
}
fn with_merchant_fee_owner(params: &Value) -> Result<Value> {
let mut obj = match params {
Value::Object(map) => map.clone(),
other => {
return Err(DelopayError::InvalidRequest(format!(
"fee-rule program body must be a JSON object, got {}",
json_kind(other)
)));
}
};
obj.insert(
"fee_owner".to_string(),
Value::String(MERCHANT_FEE_OWNER.to_string()),
);
Ok(Value::Object(obj))
}
fn json_kind(value: &Value) -> &'static str {
match value {
Value::Null => "null",
Value::Bool(_) => "a boolean",
Value::Number(_) => "a number",
Value::String(_) => "a string",
Value::Array(_) => "an array",
Value::Object(_) => "an object",
}
}
#[derive(Debug, Clone, Serialize)]
pub struct FeeScheduleCreateRequest {
pub fee_type: FeeType,
#[serde(skip_serializing_if = "Option::is_none")]
pub shop_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage_fee: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_fee_currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub min_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_fee_amount: Option<i64>,
#[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>,
}
const FEE_SCHEDULE_CREATE_REQUEST_NAMED: &[&str] = &[
"fee_type",
"shop_id",
"percentage_fee",
"flat_fee_amount",
"flat_fee_currency",
"min_fee_amount",
"max_fee_amount",
"description",
];
impl ValidateRequest for FeeScheduleCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if FEE_SCHEDULE_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on FeeScheduleCreateRequest"
)));
}
}
Ok(())
}
}
impl FeeScheduleCreateRequest {
pub fn new(fee_type: FeeType) -> Self {
Self {
fee_type,
shop_id: None,
percentage_fee: None,
flat_fee_amount: None,
flat_fee_currency: None,
min_fee_amount: None,
max_fee_amount: None,
description: None,
extra: serde_json::Map::new(),
}
}
pub fn shop_id(mut self, shop_id: impl Into<String>) -> Self {
self.shop_id = Some(shop_id.into());
self
}
pub fn percentage_fee(mut self, percentage_fee: f64) -> Self {
self.percentage_fee = Some(percentage_fee);
self
}
pub fn flat_fee(mut self, amount: i64, currency: impl Into<String>) -> Self {
self.flat_fee_amount = Some(amount);
self.flat_fee_currency = Some(currency.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct FeeScheduleUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub fee_type: Option<FeeType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage_fee: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub flat_fee_currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub min_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const FEE_SCHEDULE_UPDATE_REQUEST_NAMED: &[&str] = &[
"fee_type",
"percentage_fee",
"flat_fee_amount",
"flat_fee_currency",
"min_fee_amount",
"max_fee_amount",
"description",
"is_active",
];
impl ValidateRequest for FeeScheduleUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if FEE_SCHEDULE_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on FeeScheduleUpdateRequest"
)));
}
}
Ok(())
}
}
impl FeeScheduleUpdateRequest {
pub fn new() -> Self {
Self::default()
}
pub fn fee_type(mut self, fee_type: FeeType) -> Self {
self.fee_type = Some(fee_type);
self
}
pub fn percentage_fee(mut self, percentage_fee: f64) -> Self {
self.percentage_fee = Some(percentage_fee);
self
}
pub fn is_active(mut self, is_active: bool) -> Self {
self.is_active = Some(is_active);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const SCHEDULE_JSON: &str = r#"{
"id": "fee_1",
"merchant_id": "merch_1",
"fee_type": "percentage",
"is_active": true,
"fee_owner": "merchant",
"shop_id": "pro_1",
"percentage_fee": 2.5
}"#;
const PROGRAM_JSON: &str = r#"{
"name": "standard",
"fee_owner": "merchant",
"algorithm": {"defaultSelection": {}, "rules": [], "metadata": {}},
"created_at": 1767225600,
"modified_at": 1767225600
}"#;
fn sample_program() -> Value {
json!({
"algorithm": {
"defaultSelection": {},
"rules": [],
"metadata": {}
},
"name": "standard",
"profile_id": "pro_1"
})
}
#[tokio::test]
async fn create_posts_with_the_merchant_id_query() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let params = FeeScheduleCreateRequest::new(FeeType::Combined)
.shop_id("pro_1")
.percentage_fee(2.5)
.flat_fee(30, "USD");
let created = client.fees().create(¶ms, "merch_1").await.unwrap();
assert_eq!(created.id, "fee_1");
assert_eq!(created.fee_type, FeeType::Percentage);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees?merchant_id=merch_1"
);
let body = seen[0].body_json();
assert_eq!(body["fee_type"], "combined");
assert_eq!(body["shop_id"], "pro_1");
assert_eq!(body["percentage_fee"], 2.5);
assert_eq!(body["flat_fee_amount"], 30);
assert_eq!(body["flat_fee_currency"], "USD");
}
#[tokio::test]
async fn list_gets_the_list_path_with_the_merchant_id_query() {
let (client, mock) = client_with(vec![Step::ok(&format!("[{SCHEDULE_JSON}]"))]);
let schedules = client.fees().list("merch_1").await.unwrap();
assert_eq!(schedules.len(), 1);
assert_eq!(schedules[0].shop_id.as_deref(), Some("pro_1"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees/list?merchant_id=merch_1"
);
}
#[tokio::test]
async fn update_puts_to_the_encoded_fee_path() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let params = FeeScheduleUpdateRequest::new()
.fee_type(FeeType::Flat)
.is_active(false);
client.fees().update("fee/1", ¶ms).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(seen[0].url, "https://api.test/merchant-fees/fee%2F1");
let body = seen[0].body_json();
assert_eq!(body["fee_type"], "flat");
assert_eq!(body["is_active"], false);
}
#[tokio::test]
async fn delete_removes_the_schedule_by_id() {
let (client, mock) = client_with(vec![Step::ok(SCHEDULE_JSON)]);
let deleted = client.fees().delete("fee_1").await.unwrap();
assert_eq!(deleted.id, "fee_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(seen[0].url, "https://api.test/merchant-fees/fee_1");
}
#[tokio::test]
async fn rules_upsert_injects_the_merchant_fee_owner() {
let (client, mock) = client_with(vec![Step::ok(PROGRAM_JSON)]);
let record = client
.fees()
.rules()
.upsert(&sample_program(), "merch_1")
.await
.unwrap();
assert_eq!(record.name, "standard");
assert_eq!(record.created_at, Some(1_767_225_600));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees/rules?merchant_id=merch_1"
);
let body = seen[0].body_json();
assert_eq!(body["fee_owner"], "merchant");
assert_eq!(body["name"], "standard");
assert_eq!(body["profile_id"], "pro_1");
assert_eq!(body["algorithm"]["rules"], json!([]));
}
#[tokio::test]
async fn rules_upsert_program_wraps_the_typed_program_as_algorithm() {
use crate::resources::fee_program::{FeeRuleConditions, FeeRuleInput, FeeSpecInput};
let (client, mock) = client_with(vec![Step::ok(PROGRAM_JSON)]);
let program = crate::resources::fee_program::fee_program()
.rule(
FeeRuleInput::new("crypto", FeeSpecInput::new().percentage(1.0))
.when(FeeRuleConditions::new().payment_method("crypto")),
)
.otherwise(FeeSpecInput::new().percentage(3.0))
.build()
.unwrap();
client
.fees()
.rules()
.upsert_program(&program, Some("pro_1"), "merch_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees/rules?merchant_id=merch_1"
);
let body = seen[0].body_json();
assert_eq!(body["fee_owner"], "merchant");
assert_eq!(body["profile_id"], "pro_1");
assert_eq!(body["algorithm"]["rules"][0]["name"], "crypto");
assert_eq!(
body["algorithm"]["rules"][0]["statements"][0]["condition"][0]["lhs"],
"payment_method"
);
assert_eq!(
body["algorithm"]["defaultSelection"]["fee"]["percentage_fee"],
3.0
);
}
#[tokio::test]
async fn rules_upsert_program_omits_profile_id_when_merchant_wide() {
let (client, mock) = client_with(vec![Step::ok(PROGRAM_JSON)]);
let program = crate::resources::fee_program::PlatformFeeProgram::default();
client
.fees()
.rules()
.upsert_program(&program, None, "merch_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].body_json().get("profile_id"), None);
}
#[tokio::test]
async fn rules_upsert_overrides_a_caller_supplied_fee_owner() {
let (client, mock) = client_with(vec![Step::ok(PROGRAM_JSON)]);
let program = json!({"algorithm": {}, "fee_owner": "platform"});
client
.fees()
.rules()
.upsert(&program, "merch_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].body_json()["fee_owner"], "merchant");
}
#[tokio::test]
async fn rules_upsert_rejects_a_non_object_program() {
let (client, mock) = client_with(vec![Step::ok("{}")]);
let err = client
.fees()
.rules()
.upsert(&json!([1, 2, 3]), "merch_1")
.await
.unwrap_err();
assert!(matches!(err, DelopayError::InvalidRequest(_)));
assert!(
mock.seen.lock().unwrap().is_empty(),
"a non-object program must not reach the transport"
);
}
#[tokio::test]
async fn rules_retrieve_and_delete_scope_by_profile_when_given() {
let (client, mock) = client_with(vec![
Step::ok(PROGRAM_JSON),
Step::ok("null"),
Step::ok("null"),
]);
let rules = client.fees().rules();
rules.retrieve("merch_1", Some("pro_1")).await.unwrap();
rules.retrieve("merch_1", None).await.unwrap();
rules.delete("merch_1", Some("pro_1")).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees/rules?merchant_id=merch_1&profile_id=pro_1"
);
assert_eq!(
seen[1].url,
"https://api.test/merchant-fees/rules?merchant_id=merch_1"
);
assert_eq!(seen[2].method, "DELETE");
assert_eq!(
seen[2].url,
"https://api.test/merchant-fees/rules?merchant_id=merch_1&profile_id=pro_1"
);
}
#[tokio::test]
async fn rules_retrieve_decodes_a_null_program_as_none() {
let (client, _mock) = client_with(vec![Step::ok("null"), Step::ok(PROGRAM_JSON)]);
let rules = client.fees().rules();
assert!(
rules.retrieve("merch_1", None).await.unwrap().is_none(),
"a null body means no program is set for the scope"
);
let record = rules
.retrieve("merch_1", Some("pro_1"))
.await
.unwrap()
.expect("a program body decodes to Some");
assert_eq!(record.name, "standard");
}
#[tokio::test]
async fn rules_preview_posts_the_candidate_program_verbatim() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"matched_rule":"crypto","fell_through":false,"fee_amount":125,"fee_currency":"USD"}"#,
)]);
let input = json!({
"algorithm": {"defaultSelection": {}, "rules": [], "metadata": {}},
"amount": 1000,
"currency": "USD"
});
let preview = client
.fees()
.rules()
.preview(&input, "merch_1")
.await
.unwrap();
assert_eq!(preview.matched_rule.as_deref(), Some("crypto"));
assert_eq!(preview.fee_amount, Some(125));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/merchant-fees/rules/preview?merchant_id=merch_1"
);
let body = seen[0].body_json();
assert_eq!(body["amount"], 1000);
assert_eq!(body["currency"], "USD");
assert_eq!(body.get("fee_owner"), None);
}
#[test]
fn fee_schedule_create_request_named_fields_are_complete() {
let req = FeeScheduleCreateRequest {
fee_type: FeeType::Combined,
shop_id: Some("pro_1".to_string()),
percentage_fee: Some(2.5),
flat_fee_amount: Some(30),
flat_fee_currency: Some("USD".to_string()),
min_fee_amount: Some(1),
max_fee_amount: Some(1000),
description: Some("standard".to_string()),
extra: serde_json::Map::new(),
};
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
FEE_SCHEDULE_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"FEE_SCHEDULE_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn fee_schedule_update_request_named_fields_are_complete() {
let req = FeeScheduleUpdateRequest {
fee_type: Some(FeeType::Flat),
percentage_fee: Some(2.5),
flat_fee_amount: Some(30),
flat_fee_currency: Some("USD".to_string()),
min_fee_amount: Some(1),
max_fee_amount: Some(1000),
description: Some("standard".to_string()),
is_active: Some(true),
extra: serde_json::Map::new(),
};
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
FEE_SCHEDULE_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"FEE_SCHEDULE_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn fee_schedule_create_validate_rejects_colliding_extra_key() {
let mut req = FeeScheduleCreateRequest::new(FeeType::Flat);
req.extra.insert("shop_id".to_string(), json!("pro_2"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[test]
fn fee_schedule_update_validate_rejects_colliding_extra_key() {
let mut req = FeeScheduleUpdateRequest::new();
req.extra.insert("is_active".to_string(), json!(false));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
}