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::merchant_account::MerchantAccountResponse;
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct MerchantAccounts {
inner: Arc<Inner>,
}
impl MerchantAccounts {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(
&self,
params: &MerchantAccountCreateRequest,
) -> Result<MerchantAccountResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/accounts", Some(&body), &[], None)
.await
}
pub async fn retrieve(&self, account_id: &str) -> Result<MerchantAccountResponse> {
let path = format!("/accounts/{}", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update(
&self,
account_id: &str,
params: &MerchantAccountUpdateRequest,
) -> Result<MerchantAccountResponse> {
params.validate()?;
let path = format!("/accounts/{}", encode_segment(account_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn delete(&self, account_id: &str) -> Result<MerchantAccountResponse> {
let path = format!("/accounts/{}", encode_segment(account_id));
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
pub async fn list(&self) -> Result<Vec<MerchantAccountResponse>> {
self.inner
.request(HttpMethod::Get, "/accounts/list", None, &[], None)
.await
}
pub async fn toggle_kv(&self, account_id: &str) -> Result<Value> {
let path = format!("/accounts/{}/kv", encode_segment(account_id));
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn kv_status(&self, account_id: &str) -> Result<Value> {
let path = format!("/accounts/{}/kv", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn transfer_keys(&self, params: &Value) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/accounts/transfer",
Some(&body),
&[],
None,
)
.await
}
}
const REDACTED: &str = "[redacted]";
fn redact(v: Option<&Value>) -> Option<&'static str> {
v.map(|_| REDACTED)
}
#[derive(Clone, Default, Serialize)]
pub struct MerchantAccountCreateRequest {
pub merchant_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_merchants_enabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_merchant_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub publishable_key: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for MerchantAccountCreateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MerchantAccountCreateRequest")
.field("merchant_id", &self.merchant_id)
.field("merchant_name", &self.merchant_name)
.field("return_url", &self.return_url)
.field("webhook_details", &redact(self.webhook_details.as_ref()))
.field("sub_merchants_enabled", &self.sub_merchants_enabled)
.field("parent_merchant_id", &self.parent_merchant_id)
.field("metadata", &self.metadata)
.field("publishable_key", &self.publishable_key)
.field("extra", &self.extra)
.finish()
}
}
const MERCHANT_ACCOUNT_CREATE_REQUEST_NAMED: &[&str] = &[
"merchant_id",
"merchant_name",
"return_url",
"webhook_details",
"sub_merchants_enabled",
"parent_merchant_id",
"metadata",
"publishable_key",
];
impl ValidateRequest for MerchantAccountCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if MERCHANT_ACCOUNT_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on \
MerchantAccountCreateRequest"
)));
}
}
Ok(())
}
}
impl MerchantAccountCreateRequest {
pub fn new(merchant_id: impl Into<String>) -> Self {
Self {
merchant_id: merchant_id.into(),
..Default::default()
}
}
#[must_use]
pub fn merchant_name(mut self, name: impl Into<String>) -> Self {
self.merchant_name = Some(name.into());
self
}
#[must_use]
pub fn return_url(mut self, url: impl Into<String>) -> Self {
self.return_url = Some(url.into());
self
}
#[must_use]
pub fn webhook_details(mut self, details: Value) -> Self {
self.webhook_details = Some(details);
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct MerchantAccountUpdateRequest {
pub merchant_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_merchants_enabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for MerchantAccountUpdateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MerchantAccountUpdateRequest")
.field("merchant_id", &self.merchant_id)
.field("merchant_name", &self.merchant_name)
.field("return_url", &self.return_url)
.field("webhook_details", &redact(self.webhook_details.as_ref()))
.field("sub_merchants_enabled", &self.sub_merchants_enabled)
.field("metadata", &self.metadata)
.field("extra", &self.extra)
.finish()
}
}
const MERCHANT_ACCOUNT_UPDATE_REQUEST_NAMED: &[&str] = &[
"merchant_id",
"merchant_name",
"return_url",
"webhook_details",
"sub_merchants_enabled",
"metadata",
];
impl ValidateRequest for MerchantAccountUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if MERCHANT_ACCOUNT_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on \
MerchantAccountUpdateRequest"
)));
}
}
Ok(())
}
}
impl MerchantAccountUpdateRequest {
pub fn new(merchant_id: impl Into<String>) -> Self {
Self {
merchant_id: merchant_id.into(),
..Default::default()
}
}
#[must_use]
pub fn merchant_name(mut self, name: impl Into<String>) -> Self {
self.merchant_name = Some(name.into());
self
}
#[must_use]
pub fn return_url(mut self, url: impl Into<String>) -> Self {
self.return_url = Some(url.into());
self
}
#[must_use]
pub fn webhook_details(mut self, details: Value) -> Self {
self.webhook_details = Some(details);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const ACCOUNT_JSON: &str = r#"{
"merchant_id": "mer_1",
"merchant_name": "Acme",
"organization_id": "org_1",
"merchant_account_type": "standard",
"enable_payment_response_hash": true,
"redirect_to_merchant_with_http_post": false,
"primary_business_details": [],
"is_recon_enabled": false,
"recon_status": "not_requested"
}"#;
fn full_create_request() -> MerchantAccountCreateRequest {
MerchantAccountCreateRequest {
merchant_id: "mer_1".to_string(),
merchant_name: Some("Acme".to_string()),
return_url: Some("https://acme.test/return".to_string()),
webhook_details: Some(json!({"webhook_password": "hunter2"})),
sub_merchants_enabled: Some(true),
parent_merchant_id: Some("mer_parent".to_string()),
metadata: Some(json!({"tier": "gold"})),
publishable_key: Some("pk_test_1".to_string()),
extra: serde_json::Map::new(),
}
}
fn full_update_request() -> MerchantAccountUpdateRequest {
MerchantAccountUpdateRequest {
merchant_id: "mer_1".to_string(),
merchant_name: Some("Acme".to_string()),
return_url: Some("https://acme.test/return".to_string()),
webhook_details: Some(json!({"webhook_password": "hunter2"})),
sub_merchants_enabled: Some(true),
metadata: Some(json!({"tier": "gold"})),
extra: serde_json::Map::new(),
}
}
#[test]
fn merchant_account_create_request_named_fields_are_complete() {
let value = serde_json::to_value(full_create_request()).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
MERCHANT_ACCOUNT_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"MERCHANT_ACCOUNT_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn merchant_account_update_request_named_fields_are_complete() {
let value = serde_json::to_value(full_update_request()).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
MERCHANT_ACCOUNT_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"MERCHANT_ACCOUNT_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn validate_rejects_colliding_extra_keys() {
let mut create = MerchantAccountCreateRequest::new("mer_1");
create
.extra
.insert("merchant_name".to_string(), json!("collide"));
match create.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("merchant_name")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
let mut update = MerchantAccountUpdateRequest::new("mer_1");
update.extra.insert("metadata".to_string(), json!({}));
assert!(matches!(
update.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[test]
fn debug_redacts_webhook_details() {
let created = format!("{:?}", full_create_request());
assert!(!created.contains("hunter2"), "{created}");
assert!(
created.contains("webhook_details: Some(\"[redacted]\")"),
"{created}"
);
assert!(created.contains("mer_1"), "{created}");
let updated = format!("{:?}", full_update_request());
assert!(!updated.contains("hunter2"), "{updated}");
assert!(
updated.contains("webhook_details: Some(\"[redacted]\")"),
"{updated}"
);
}
#[test]
fn debug_shows_none_for_unset_webhook_details() {
let rendered = format!("{:?}", MerchantAccountCreateRequest::new("mer_1"));
assert!(rendered.contains("webhook_details: None"), "{rendered}");
}
#[tokio::test]
async fn create_posts_to_accounts() {
let (client, mock) = client_with(vec![Step::ok(ACCOUNT_JSON)]);
let req = MerchantAccountCreateRequest::new("mer_1").merchant_name("Acme");
let created = client.merchant_accounts().create(&req).await.unwrap();
assert_eq!(created.merchant_id, "mer_1");
assert_eq!(created.merchant_name.as_deref(), Some("Acme"));
assert_eq!(created.enable_payment_response_hash, Some(true));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/accounts");
assert_eq!(seen[0].body_json()["merchant_name"], "Acme");
}
#[tokio::test]
async fn retrieve_update_and_delete_hit_the_account_path() {
let (client, mock) = client_with(vec![
Step::ok(ACCOUNT_JSON),
Step::ok(ACCOUNT_JSON),
Step::ok(ACCOUNT_JSON),
]);
let accounts = client.merchant_accounts();
let retrieved = accounts.retrieve("mer/1").await.unwrap();
assert_eq!(retrieved.organization_id.as_deref(), Some("org_1"));
accounts
.update(
"mer_1",
&MerchantAccountUpdateRequest::new("mer_1").return_url("https://a.test"),
)
.await
.unwrap();
accounts.delete("mer_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/accounts/mer%2F1")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/accounts/mer_1")
);
assert_eq!(seen[1].body_json()["return_url"], "https://a.test");
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("DELETE", "https://api.test/accounts/mer_1")
);
}
#[tokio::test]
async fn list_kv_and_transfer_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok("[]"),
Step::ok(r#"{"kv_enabled":true}"#),
Step::ok(r#"{"kv_enabled":true}"#),
Step::ok(r#"{"transferred":1}"#),
]);
let accounts = client.merchant_accounts();
assert!(accounts.list().await.unwrap().is_empty());
accounts.toggle_kv("mer_1").await.unwrap();
accounts.kv_status("mer_1").await.unwrap();
accounts
.transfer_keys(&json!({"from": "mer_1", "to": "mer_2"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/accounts/list")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/accounts/mer_1/kv")
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("GET", "https://api.test/accounts/mer_1/kv")
);
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
("POST", "https://api.test/accounts/transfer")
);
assert_eq!(seen[3].body_json()["to"], "mer_2");
}
}