use serde::Deserialize;
use serde_json::Value;
use crate::core::models::common::Currency;
pub type BillingStatus = String;
pub type SuspensionSource = String;
pub type AllocationStatus = String;
pub type BlockReason = String;
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AutoRechargeConfig {
pub enabled: bool,
pub threshold_amount: i64,
pub recharge_amount: i64,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct TierSummary {
pub level: i64,
pub name: String,
pub is_custom: bool,
#[serde(default)]
pub rate: Option<f64>,
#[serde(default)]
pub locked_until: Option<String>,
#[serde(default)]
pub volume_usd_minor: Option<i64>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct BillingProfileResponse {
pub id: String,
pub merchant_id: String,
pub has_payment_method: bool,
pub balance_amount: i64,
pub balance_currency: Currency,
pub billing_status: BillingStatus,
pub auto_recharge: AutoRechargeConfig,
pub hard_floor_amount: i64,
pub consecutive_recharge_failures: i64,
pub is_trusted: bool,
#[serde(default)]
pub stripe_customer_id: Option<String>,
#[serde(default)]
pub suspended_at: Option<String>,
#[serde(default)]
pub suspension_source: Option<SuspensionSource>,
#[serde(default)]
pub suspension_reason: Option<String>,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub modified_at: Option<String>,
#[serde(default)]
pub current_tier: Option<TierSummary>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Clone, Deserialize)]
#[non_exhaustive]
pub struct BillingSetupResponse {
pub billing_profile_id: String,
pub merchant_id: String,
pub stripe_customer_id: String,
pub setup_intent_id: String,
pub setup_intent_client_secret: String,
pub billing_status: BillingStatus,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for BillingSetupResponse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let extra_keys: Vec<&str> = self.extra.keys().map(String::as_str).collect();
f.debug_struct("BillingSetupResponse")
.field("billing_profile_id", &self.billing_profile_id)
.field("merchant_id", &self.merchant_id)
.field("stripe_customer_id", &self.stripe_customer_id)
.field("setup_intent_id", &self.setup_intent_id)
.field("setup_intent_client_secret", &"[redacted]")
.field("billing_status", &self.billing_status)
.field("extra_keys", &extra_keys)
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct TopupResponse {
pub payment_intent_id: String,
pub status: String,
pub amount: i64,
pub currency: Currency,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct LedgerEntry {
pub id: String,
pub entry_type: String,
pub amount: i64,
pub currency: Currency,
pub reference_kind: String,
pub reference_id: String,
pub balance_after: i64,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub original_amount: Option<i64>,
#[serde(default)]
pub original_currency: Option<Currency>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub profile_id: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct LedgerResponse {
#[serde(default = "Vec::new")]
pub entries: Vec<LedgerEntry>,
#[serde(default)]
pub total_count: Option<i64>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct BlockedAttempt {
pub id: String,
pub merchant_id: String,
pub payment_id: String,
pub block_reason: BlockReason,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub profile_id: Option<String>,
#[serde(default)]
pub suspension_source: Option<SuspensionSource>,
#[serde(default)]
pub amount: Option<i64>,
#[serde(default)]
pub currency: Option<Currency>,
#[serde(default)]
pub billing_status: Option<BillingStatus>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct BlockedAttemptListResponse {
#[serde(default = "Vec::new")]
pub entries: Vec<BlockedAttempt>,
#[serde(default)]
pub total_count: Option<i64>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AllocationResponse {
pub id: String,
pub merchant_id: String,
pub profile_id: String,
pub balance_amount: i64,
pub balance_currency: Currency,
pub allocation_status: AllocationStatus,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub modified_at: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AllocationListResponse {
#[serde(default = "Vec::new")]
pub allocations: Vec<AllocationResponse>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AllocationTransferResponse {
pub allocation_id: String,
pub profile_id: String,
pub allocation_balance: i64,
pub host_balance: i64,
pub ledger_entry_id: String,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[cfg(test)]
mod tests {
use super::*;
const SETUP_JSON: &str = r#"{
"billing_profile_id": "bp_1",
"merchant_id": "merch_1",
"stripe_customer_id": "cus_1",
"setup_intent_id": "seti_1",
"setup_intent_client_secret": "seti_1_secret_supersecretvalue",
"billing_status": "setup_incomplete"
}"#;
#[test]
fn setup_response_debug_redacts_the_client_secret() {
let setup: BillingSetupResponse = serde_json::from_str(SETUP_JSON).unwrap();
let printed = format!("{setup:?}");
assert!(
!printed.contains("seti_1_secret_supersecretvalue"),
"client secret leaked into Debug output: {printed}"
);
assert!(printed.contains("[redacted]"));
assert!(printed.contains("bp_1"));
}
#[test]
fn setup_response_debug_hides_extra_values() {
let mut setup: BillingSetupResponse = serde_json::from_str(SETUP_JSON).unwrap();
setup.extra.insert(
"client_secret".to_string(),
Value::String("another_secret".to_string()),
);
let printed = format!("{setup:?}");
assert!(
!printed.contains("another_secret"),
"an unmodeled secret leaked through `extra`: {printed}"
);
assert!(printed.contains("client_secret"));
}
#[test]
fn billing_profile_decodes_nested_config_and_keeps_unknown_fields() {
let profile: BillingProfileResponse = serde_json::from_str(
r#"{
"id": "bp_1",
"merchant_id": "merch_1",
"has_payment_method": true,
"balance_amount": 12345,
"balance_currency": "USD",
"billing_status": "active",
"auto_recharge": {
"enabled": true,
"threshold_amount": 1000,
"recharge_amount": 20000
},
"hard_floor_amount": -500,
"consecutive_recharge_failures": 0,
"is_trusted": false,
"created_at": "2026-01-01T00:00:00Z",
"modified_at": "2026-01-02T00:00:00Z",
"current_tier": {
"level": 3,
"name": "Growth",
"is_custom": false,
"rate": 3.5,
"volume_usd_minor": 900000
},
"brand_new_field": "keep me"
}"#,
)
.unwrap();
assert_eq!(profile.balance_amount, 12345);
assert_eq!(profile.hard_floor_amount, -500);
assert!(profile.auto_recharge.enabled);
assert_eq!(profile.auto_recharge.threshold_amount, 1000);
let tier = profile.current_tier.expect("current_tier decodes");
assert_eq!(tier.level, 3);
assert_eq!(tier.rate, Some(3.5));
assert_eq!(tier.locked_until, None);
assert_eq!(profile.extra["brand_new_field"], "keep me");
}
#[test]
fn billing_profile_tolerates_a_custom_tier_without_a_rate() {
let profile: BillingProfileResponse = serde_json::from_str(
r#"{
"id": "bp_1",
"merchant_id": "merch_1",
"has_payment_method": false,
"balance_amount": 0,
"balance_currency": "EUR",
"billing_status": "suspended",
"auto_recharge": {"enabled": false, "threshold_amount": 0, "recharge_amount": 0},
"hard_floor_amount": 0,
"consecutive_recharge_failures": 3,
"is_trusted": false,
"suspension_source": "auto_recharge",
"current_tier": {"level": 6, "name": "Custom", "is_custom": true, "rate": null}
}"#,
)
.unwrap();
let tier = profile.current_tier.expect("current_tier decodes");
assert!(tier.is_custom);
assert_eq!(tier.rate, None);
assert_eq!(
profile.suspension_source.as_deref(),
Some("auto_recharge"),
"suspension_source must survive decoding"
);
assert_eq!(profile.created_at, None);
}
#[test]
fn ledger_and_blocked_attempt_pages_decode_their_entries() {
let ledger: LedgerResponse = serde_json::from_str(
r#"{
"entries": [{
"id": "led_1",
"entry_type": "fee",
"amount": -250,
"currency": "USD",
"reference_kind": "payment",
"reference_id": "pay_1",
"balance_after": 9750,
"created_at": "2026-01-01T00:00:00Z",
"profile_id": "pro_1"
}],
"total_count": 1
}"#,
)
.unwrap();
assert_eq!(ledger.total_count, Some(1));
assert_eq!(ledger.entries[0].amount, -250);
assert_eq!(ledger.entries[0].balance_after, 9750);
assert_eq!(ledger.entries[0].profile_id.as_deref(), Some("pro_1"));
let blocked: BlockedAttemptListResponse = serde_json::from_str(
r#"{"entries": [{
"id": "blk_1",
"merchant_id": "merch_1",
"payment_id": "pay_1",
"block_reason": "billing_suspended",
"created_at": "2026-01-01T00:00:00Z",
"amount": 1000
}]}"#,
)
.unwrap();
assert_eq!(blocked.total_count, None);
assert_eq!(blocked.entries[0].block_reason, "billing_suspended");
assert_eq!(blocked.entries[0].amount, Some(1000));
assert_eq!(blocked.entries[0].currency, None);
}
#[test]
fn allocation_shapes_decode() {
let list: AllocationListResponse = serde_json::from_str(
r#"{"allocations": [{
"id": "alc_1",
"merchant_id": "merch_1",
"profile_id": "pro_1",
"balance_amount": 5000,
"balance_currency": "USD",
"allocation_status": "active",
"created_at": "2026-01-01T00:00:00Z",
"modified_at": "2026-01-02T00:00:00Z"
}]}"#,
)
.unwrap();
assert_eq!(list.allocations[0].balance_amount, 5000);
assert_eq!(list.allocations[0].allocation_status, "active");
let transfer: AllocationTransferResponse = serde_json::from_str(
r#"{
"allocation_id": "alc_1",
"profile_id": "pro_1",
"allocation_balance": 5250,
"host_balance": 4750,
"ledger_entry_id": "led_9"
}"#,
)
.unwrap();
assert_eq!(transfer.allocation_balance, 5250);
assert_eq!(transfer.host_balance, 4750);
assert_eq!(transfer.ledger_entry_id, "led_9");
}
#[test]
fn topup_response_decodes_minor_units() {
let topup: TopupResponse = serde_json::from_str(
r#"{"payment_intent_id":"pi_1","status":"succeeded","amount":20000,"currency":"USD"}"#,
)
.unwrap();
assert_eq!(topup.amount, 20000);
assert_eq!(topup.payment_intent_id, "pi_1");
assert_eq!(topup.currency, "USD");
}
}