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::connector::{
ConnectorResponse, ConnectorWebhookListResponse, ConnectorWebhookRegisterResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Connectors {
inner: Arc<Inner>,
}
impl Connectors {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(
&self,
account_id: &str,
params: &ConnectorCreateRequest,
) -> Result<ConnectorResponse> {
params.validate()?;
let path = format!("/account/{}/connectors", encode_segment(account_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn retrieve(
&self,
account_id: &str,
connector_id: &str,
) -> Result<ConnectorResponse> {
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list(&self, account_id: &str) -> Result<Vec<ConnectorResponse>> {
let path = format!("/account/{}/connectors", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorUpdateRequest,
) -> Result<ConnectorResponse> {
params.validate()?;
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_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, connector_id: &str) -> Result<ConnectorResponse> {
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
pub async fn clone_connector(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorCloneRequest,
) -> Result<ConnectorResponse> {
let path = format!(
"/account/{}/connectors/{}/clone",
encode_segment(account_id),
encode_segment(connector_id)
);
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn verify(&self, params: &Value) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/account/connectors/verify",
Some(&body),
&[],
None,
)
.await
}
pub async fn register_webhook(
&self,
merchant_id: &str,
connector_id: &str,
params: Option<&ConnectorWebhookRegisterRequest>,
) -> Result<ConnectorWebhookRegisterResponse> {
let path = format!(
"/account/{}/connectors/webhooks/{}",
encode_segment(merchant_id),
encode_segment(connector_id)
);
match params {
None => {
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
Some(p) => {
let body = to_json_vec(p)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
}
}
pub async fn webhook(
&self,
merchant_id: &str,
connector_id: &str,
) -> Result<ConnectorWebhookListResponse> {
let path = format!(
"/account/{}/connectors/webhooks/{}",
encode_segment(merchant_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list_payment_methods(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/account/payment-methods", None, &[], None)
.await
}
}
#[derive(Clone, Default, Serialize)]
pub struct ConnectorCreateRequest {
pub connector_type: String,
pub connector_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_account_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled: Option<Vec<Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_webhook_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_merchant_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const REDACTED: &str = "[redacted]";
fn redact(v: Option<&Value>) -> Option<&'static str> {
v.map(|_| REDACTED)
}
impl std::fmt::Debug for ConnectorCreateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorCreateRequest")
.field("connector_type", &self.connector_type)
.field("connector_name", &self.connector_name)
.field("connector_label", &self.connector_label)
.field("profile_id", &self.profile_id)
.field(
"connector_account_details",
&redact(self.connector_account_details.as_ref()),
)
.field("payment_methods_enabled", &self.payment_methods_enabled)
.field("metadata", &self.metadata)
.field("test_mode", &self.test_mode)
.field("disabled", &self.disabled)
.field(
"connector_webhook_details",
&redact(self.connector_webhook_details.as_ref()),
)
.field(
"additional_merchant_data",
&redact(self.additional_merchant_data.as_ref()),
)
.field("status", &self.status)
.field("extra", &self.extra)
.finish()
}
}
const CONNECTOR_CREATE_REQUEST_NAMED: &[&str] = &[
"connector_type",
"connector_name",
"connector_label",
"profile_id",
"connector_account_details",
"payment_methods_enabled",
"metadata",
"test_mode",
"disabled",
"connector_webhook_details",
"additional_merchant_data",
"status",
];
impl ValidateRequest for ConnectorCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CONNECTOR_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on ConnectorCreateRequest"
)));
}
}
Ok(())
}
}
impl ConnectorCreateRequest {
pub fn new(connector_type: impl Into<String>, connector_name: impl Into<String>) -> Self {
Self {
connector_type: connector_type.into(),
connector_name: connector_name.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
#[must_use]
pub fn connector_label(mut self, label: impl Into<String>) -> Self {
self.connector_label = Some(label.into());
self
}
#[must_use]
pub fn connector_account_details(mut self, details: Value) -> Self {
self.connector_account_details = Some(details);
self
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct ConnectorUpdateRequest {
pub connector_type: String,
pub status: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_account_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled: Option<Vec<Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_webhook_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_merchant_data: Option<Value>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for ConnectorUpdateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorUpdateRequest")
.field("connector_type", &self.connector_type)
.field("status", &self.status)
.field("connector_label", &self.connector_label)
.field(
"connector_account_details",
&redact(self.connector_account_details.as_ref()),
)
.field("payment_methods_enabled", &self.payment_methods_enabled)
.field("metadata", &self.metadata)
.field("test_mode", &self.test_mode)
.field("disabled", &self.disabled)
.field(
"connector_webhook_details",
&redact(self.connector_webhook_details.as_ref()),
)
.field(
"additional_merchant_data",
&redact(self.additional_merchant_data.as_ref()),
)
.field("extra", &self.extra)
.finish()
}
}
const CONNECTOR_UPDATE_REQUEST_NAMED: &[&str] = &[
"connector_type",
"status",
"connector_label",
"connector_account_details",
"payment_methods_enabled",
"metadata",
"test_mode",
"disabled",
"connector_webhook_details",
"additional_merchant_data",
];
impl ValidateRequest for ConnectorUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CONNECTOR_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on ConnectorUpdateRequest"
)));
}
}
Ok(())
}
}
impl ConnectorUpdateRequest {
pub fn new(connector_type: impl Into<String>, status: impl Into<String>) -> Self {
Self {
connector_type: connector_type.into(),
status: status.into(),
..Default::default()
}
}
#[must_use]
pub fn connector_account_details(mut self, details: Value) -> Self {
self.connector_account_details = Some(details);
self
}
#[must_use]
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = Some(disabled);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorCloneRequest {
pub profile_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_label: Option<String>,
}
impl ConnectorCloneRequest {
pub fn new(profile_id: impl Into<String>) -> Self {
Self {
profile_id: profile_id.into(),
connector_label: None,
}
}
#[must_use]
pub fn connector_label(mut self, label: impl Into<String>) -> Self {
self.connector_label = Some(label.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorWebhookRegisterRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_url: Option<String>,
}
impl ConnectorWebhookRegisterRequest {
pub fn all_events() -> Self {
Self {
event_type: Some(Value::String("all_events".to_string())),
..Default::default()
}
}
pub fn specific_event(event: impl Into<String>) -> Self {
Self {
event_type: Some(serde_json::json!({ "specific_event": event.into() })),
..Default::default()
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
#[must_use]
pub fn webhook_url(mut self, url: impl Into<String>) -> Self {
self.webhook_url = Some(url.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const CONNECTOR_JSON: &str = r#"{
"merchant_connector_id": "mca_1",
"connector_type": "payment_processor",
"connector_name": "stripe",
"profile_id": "pro_1",
"status": "active"
}"#;
fn full_create_request() -> ConnectorCreateRequest {
ConnectorCreateRequest {
connector_type: "payment_processor".to_string(),
connector_name: "stripe".to_string(),
connector_label: Some("stripe_uk".to_string()),
profile_id: Some("pro_1".to_string()),
connector_account_details: Some(json!({"api_key": "sk_live_supersecret"})),
payment_methods_enabled: Some(vec![json!({"payment_method": "card"})]),
metadata: Some(json!({"team": "payments"})),
test_mode: Some(false),
disabled: Some(false),
connector_webhook_details: Some(json!({"merchant_secret": "whsec_topsecret"})),
additional_merchant_data: Some(json!({"acquirer": "acq_1"})),
status: Some("active".to_string()),
extra: serde_json::Map::new(),
}
}
fn full_update_request() -> ConnectorUpdateRequest {
ConnectorUpdateRequest {
connector_type: "payment_processor".to_string(),
status: "active".to_string(),
connector_label: Some("stripe_uk".to_string()),
connector_account_details: Some(json!({"api_key": "sk_live_supersecret"})),
payment_methods_enabled: Some(vec![json!({"payment_method": "card"})]),
metadata: Some(json!({"team": "payments"})),
test_mode: Some(false),
disabled: Some(false),
connector_webhook_details: Some(json!({"merchant_secret": "whsec_topsecret"})),
additional_merchant_data: Some(json!({"acquirer": "acq_1"})),
extra: serde_json::Map::new(),
}
}
#[test]
fn connector_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!(
CONNECTOR_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"CONNECTOR_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn connector_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!(
CONNECTOR_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"CONNECTOR_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = ConnectorCreateRequest::new("payment_processor", "stripe");
req.extra.insert("profile_id".to_string(), json!("pro_2"));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("profile_id")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn update_validate_rejects_colliding_extra_key() {
let mut req = ConnectorUpdateRequest::new("payment_processor", "active");
req.extra.insert("status".to_string(), json!("inactive"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[test]
fn debug_redacts_connector_credentials() {
let rendered = format!("{:?}", full_create_request());
assert!(!rendered.contains("sk_live_supersecret"), "{rendered}");
assert!(!rendered.contains("whsec_topsecret"), "{rendered}");
assert!(!rendered.contains("acq_1"), "{rendered}");
assert!(rendered.contains("connector_account_details: Some(\"[redacted]\")"));
assert!(rendered.contains("stripe"), "{rendered}");
let rendered = format!("{:?}", full_update_request());
assert!(!rendered.contains("sk_live_supersecret"), "{rendered}");
assert!(!rendered.contains("whsec_topsecret"), "{rendered}");
assert!(!rendered.contains("acq_1"), "{rendered}");
assert!(rendered.contains("connector_account_details: Some(\"[redacted]\")"));
}
#[test]
fn debug_shows_none_for_unset_credentials() {
let rendered = format!(
"{:?}",
ConnectorCreateRequest::new("payment_processor", "stripe")
);
assert!(
rendered.contains("connector_account_details: None"),
"{rendered}"
);
}
#[tokio::test]
async fn create_posts_to_the_account_connectors_path() {
let (client, mock) = client_with(vec![Step::ok(CONNECTOR_JSON)]);
let req = ConnectorCreateRequest::new("payment_processor", "stripe")
.profile_id("pro_1")
.connector_account_details(json!({"api_key": "sk_test"}));
let created = client.connectors().create("mer/1", &req).await.unwrap();
assert_eq!(created.merchant_connector_id, "mca_1");
assert_eq!(created.connector_name.as_deref(), Some("stripe"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/account/mer%2F1/connectors");
let body = seen[0].body_json();
assert_eq!(body["connector_name"], "stripe");
assert_eq!(body["connector_account_details"]["api_key"], "sk_test");
}
#[tokio::test]
async fn retrieve_list_and_delete_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(CONNECTOR_JSON),
Step::ok("[]"),
Step::ok(CONNECTOR_JSON),
]);
let connectors = client.connectors();
let retrieved = connectors.retrieve("mer_1", "mca/1").await.unwrap();
assert_eq!(retrieved.status.as_deref(), Some("active"));
assert!(connectors.list("mer_1").await.unwrap().is_empty());
connectors.delete("mer_1", "mca_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/account/mer_1/connectors/mca%2F1")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/account/mer_1/connectors")
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("DELETE", "https://api.test/account/mer_1/connectors/mca_1")
);
}
#[tokio::test]
async fn update_posts_the_status_to_the_connector_path() {
let (client, mock) = client_with(vec![Step::ok(CONNECTOR_JSON)]);
let req = ConnectorUpdateRequest::new("payment_processor", "inactive").disabled(true);
client
.connectors()
.update("mer_1", "mca_1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1"
);
let body = seen[0].body_json();
assert_eq!(body["status"], "inactive");
assert_eq!(body["disabled"], true);
}
#[tokio::test]
async fn clone_connector_posts_the_target_profile() {
let (client, mock) = client_with(vec![Step::ok(CONNECTOR_JSON)]);
let req = ConnectorCloneRequest::new("pro_2").connector_label("stripe_de");
client
.connectors()
.clone_connector("mer_1", "mca_1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/clone"
);
let body = seen[0].body_json();
assert_eq!(body["profile_id"], "pro_2");
assert_eq!(body["connector_label"], "stripe_de");
}
#[tokio::test]
async fn verify_posts_the_open_body() {
let (client, mock) = client_with(vec![Step::ok(r#"{"status":"ok"}"#)]);
client
.connectors()
.verify(&json!({"connector_name": "stripe"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/account/connectors/verify");
assert_eq!(seen[0].body_json()["connector_name"], "stripe");
}
#[tokio::test]
async fn register_webhook_omits_the_body_when_no_params() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"webhook_registration_status":"success"}"#,
)]);
let registered = client
.connectors()
.register_webhook("mer_1", "mca_1", None)
.await
.unwrap();
assert_eq!(registered.webhook_registration_status, "success");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1"
);
assert!(seen[0].body.is_none(), "expected no request body");
}
#[tokio::test]
async fn register_webhook_sends_a_specific_event_scope() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"webhook_registration_status":"success"}"#,
)]);
let req = ConnectorWebhookRegisterRequest::specific_event("payment_intent.succeeded")
.environment("sandbox");
client
.connectors()
.register_webhook("mer_1", "mca_1", Some(&req))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body = seen[0].body_json();
assert_eq!(
body["event_type"]["specific_event"],
"payment_intent.succeeded"
);
assert_eq!(body["environment"], "sandbox");
}
#[tokio::test]
async fn webhook_and_payment_methods_get_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"connector":"stripe","webhooks":[{"connector_webhook_id":"we_1"}]}"#),
Step::ok("[]"),
]);
let connectors = client.connectors();
let listed = connectors.webhook("mer_1", "mca_1").await.unwrap();
assert_eq!(listed.connector, "stripe");
assert_eq!(listed.webhooks.len(), 1);
assert_eq!(listed.webhooks[0].connector_webhook_id, "we_1");
connectors.list_payment_methods().await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
(
"GET",
"https://api.test/account/mer_1/connectors/webhooks/mca_1"
)
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/account/payment-methods")
);
}
}