use serde::Deserialize;
use serde_json::Value;
const REDACTED: &str = "[redacted]";
#[derive(Clone, Deserialize)]
#[non_exhaustive]
pub struct ConnectorResponse {
pub merchant_connector_id: String,
#[serde(default)]
pub connector_type: Option<String>,
#[serde(default)]
pub connector_name: Option<String>,
#[serde(default)]
pub profile_id: Option<String>,
#[serde(default)]
pub merchant_id: Option<String>,
#[serde(default)]
pub status: Option<String>,
#[serde(default)]
pub connector_label: Option<String>,
#[serde(default)]
pub connector_account_details: Option<Value>,
#[serde(default)]
pub payment_methods_enabled: Option<Vec<Value>>,
#[serde(default)]
pub metadata: Option<Value>,
#[serde(default)]
pub test_mode: Option<bool>,
#[serde(default)]
pub disabled: Option<bool>,
#[serde(default)]
pub connector_webhook_details: Option<Value>,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub deleted: Option<bool>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for ConnectorResponse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorResponse")
.field("merchant_connector_id", &self.merchant_connector_id)
.field("connector_type", &self.connector_type)
.field("connector_name", &self.connector_name)
.field("profile_id", &self.profile_id)
.field("merchant_id", &self.merchant_id)
.field("status", &self.status)
.field("connector_label", &self.connector_label)
.field(
"connector_account_details",
&self.connector_account_details.as_ref().map(|_| REDACTED),
)
.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",
&self.connector_webhook_details.as_ref().map(|_| REDACTED),
)
.field("created_at", &self.created_at)
.field("deleted", &self.deleted)
.field("extra", &self.extra)
.finish()
}
}
#[derive(Clone, Deserialize)]
#[non_exhaustive]
pub struct ConnectorWebhookRegisterResponse {
pub webhook_registration_status: String,
#[serde(default)]
pub event_type: Option<Value>,
#[serde(default)]
pub environment: Option<String>,
#[serde(default)]
pub connector_webhook_id: Option<String>,
#[serde(default)]
pub webhook_secret: Option<String>,
#[serde(default)]
pub error_code: Option<String>,
#[serde(default)]
pub error_message: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for ConnectorWebhookRegisterResponse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorWebhookRegisterResponse")
.field(
"webhook_registration_status",
&self.webhook_registration_status,
)
.field("event_type", &self.event_type)
.field("environment", &self.environment)
.field("connector_webhook_id", &self.connector_webhook_id)
.field(
"webhook_secret",
&self.webhook_secret.as_ref().map(|_| REDACTED),
)
.field("error_code", &self.error_code)
.field("error_message", &self.error_message)
.field("extra", &self.extra)
.finish()
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ConnectorWebhookEntry {
pub connector_webhook_id: String,
#[serde(default)]
pub event_type: Option<Value>,
#[serde(default)]
pub environment: Option<String>,
#[serde(default)]
pub webhook_url: Option<String>,
#[serde(default)]
pub status: Option<String>,
#[serde(default)]
pub enabled_events: Option<Vec<String>>,
#[serde(default)]
pub created_at: Option<i64>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ConnectorWebhookListResponse {
pub connector: String,
#[serde(default = "Vec::new")]
pub webhooks: Vec<ConnectorWebhookEntry>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn connector_response_debug_redacts_credentials() {
let parsed: ConnectorResponse = serde_json::from_str(
r#"{
"merchant_connector_id": "mca_1",
"connector_name": "stripe",
"connector_account_details": {"api_key": "sk_live_supersecret"},
"connector_webhook_details": {"merchant_secret": "whsec_topsecret"}
}"#,
)
.unwrap();
let rendered = format!("{parsed:?}");
assert!(!rendered.contains("sk_live_supersecret"), "{rendered}");
assert!(!rendered.contains("whsec_topsecret"), "{rendered}");
assert!(
rendered.contains("connector_account_details: Some(\"[redacted]\")"),
"{rendered}"
);
assert!(
rendered.contains("connector_webhook_details: Some(\"[redacted]\")"),
"{rendered}"
);
assert!(rendered.contains("stripe"), "{rendered}");
assert!(rendered.contains("mca_1"), "{rendered}");
}
#[test]
fn connector_response_debug_shows_none_for_absent_credentials() {
let parsed: ConnectorResponse =
serde_json::from_str(r#"{"merchant_connector_id":"mca_1"}"#).unwrap();
let rendered = format!("{parsed:?}");
assert!(
rendered.contains("connector_account_details: None"),
"{rendered}"
);
}
#[test]
fn connector_response_keeps_unknown_fields() {
let parsed: ConnectorResponse = serde_json::from_str(
r#"{"merchant_connector_id":"mca_1","status":"active","brand_new_field":42}"#,
)
.unwrap();
assert_eq!(parsed.status.as_deref(), Some("active"));
assert_eq!(parsed.extra.get("brand_new_field"), Some(&Value::from(42)));
assert!(!parsed.extra.contains_key("status"));
}
#[test]
fn register_response_debug_redacts_the_webhook_secret() {
let parsed: ConnectorWebhookRegisterResponse = serde_json::from_str(
r#"{
"webhook_registration_status": "success",
"event_type": "all_events",
"environment": "sandbox",
"connector_webhook_id": "we_1",
"webhook_secret": "whsec_minted",
"error_code": null,
"error_message": null
}"#,
)
.unwrap();
let rendered = format!("{parsed:?}");
assert!(!rendered.contains("whsec_minted"), "{rendered}");
assert!(
rendered.contains("webhook_secret: Some(\"[redacted]\")"),
"{rendered}"
);
assert!(rendered.contains("we_1"), "{rendered}");
assert_eq!(parsed.webhook_registration_status, "success");
assert_eq!(parsed.environment.as_deref(), Some("sandbox"));
assert_eq!(parsed.error_code, None);
}
#[test]
fn webhook_list_parses_entries_and_structured_event_types() {
let parsed: ConnectorWebhookListResponse = serde_json::from_str(
r#"{
"connector": "stripe",
"webhooks": [
{
"connector_webhook_id": "we_1",
"event_type": {"specific_event": "payment_intent.succeeded"},
"enabled_events": ["payment_intent.succeeded"],
"created_at": 1700000000
}
]
}"#,
)
.unwrap();
assert_eq!(parsed.connector, "stripe");
assert_eq!(parsed.webhooks.len(), 1);
let entry = &parsed.webhooks[0];
assert_eq!(entry.connector_webhook_id, "we_1");
assert_eq!(
entry.event_type.as_ref().unwrap()["specific_event"],
"payment_intent.succeeded"
);
assert_eq!(entry.created_at, Some(1_700_000_000));
assert_eq!(entry.environment, None);
}
#[test]
fn webhook_list_defaults_to_no_webhooks() {
let parsed: ConnectorWebhookListResponse =
serde_json::from_str(r#"{"connector":"adyen"}"#).unwrap();
assert!(parsed.webhooks.is_empty());
}
}