use std::sync::Arc;
use serde::Serialize;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::Result;
use crate::core::models::checkout_template::{
CheckoutTemplateApplyResponse, CheckoutTemplateListResponse, CheckoutTemplateOfShopResponse,
CheckoutTemplateResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
#[derive(Debug, Clone)]
pub struct CheckoutTemplates {
inner: Arc<Inner>,
}
impl CheckoutTemplates {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn list(&self, merchant_id: &str) -> Result<CheckoutTemplateListResponse> {
self.inner
.request(
HttpMethod::Get,
&merchant_path(merchant_id),
None,
&[],
None,
)
.await
}
pub async fn create(
&self,
merchant_id: &str,
params: &CheckoutTemplateCreateRequest,
) -> Result<CheckoutTemplateResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
&merchant_path(merchant_id),
Some(&body),
&[],
None,
)
.await
}
pub async fn retrieve(
&self,
merchant_id: &str,
template_id: &str,
) -> Result<CheckoutTemplateResponse> {
self.inner
.request(
HttpMethod::Get,
&template_path(merchant_id, template_id),
None,
&[],
None,
)
.await
}
pub async fn rename(
&self,
merchant_id: &str,
template_id: &str,
params: &CheckoutTemplateUpdateRequest,
) -> Result<CheckoutTemplateResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
&template_path(merchant_id, template_id),
Some(&body),
&[],
None,
)
.await
}
pub async fn delete(
&self,
merchant_id: &str,
template_id: &str,
) -> Result<CheckoutTemplateResponse> {
self.inner
.request_body_keyed_with_query(
HttpMethod::Delete,
&template_path(merchant_id, template_id),
None,
&[],
None,
)
.await
}
pub async fn assign(
&self,
merchant_id: &str,
template_id: &str,
params: &CheckoutTemplateAssignRequest,
) -> Result<CheckoutTemplateApplyResponse> {
let path = format!("{}/shops", template_path(merchant_id, template_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn unassign(
&self,
merchant_id: &str,
template_id: &str,
profile_id: &str,
reason: Option<&str>,
) -> Result<CheckoutTemplateResponse> {
let path = format!(
"{}/shops/{}",
template_path(merchant_id, template_id),
encode_segment(profile_id)
);
let query: Vec<(&str, String)> = reason
.map(|reason| vec![("reason", reason.to_string())])
.unwrap_or_default();
self.inner
.request_body_keyed_with_query(HttpMethod::Delete, &path, None, &query, None)
.await
}
pub async fn apply(
&self,
merchant_id: &str,
template_id: &str,
params: &CheckoutTemplateApplyRequest,
) -> Result<CheckoutTemplateApplyResponse> {
let path = format!("{}/apply", template_path(merchant_id, template_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn of_shop(
&self,
merchant_id: &str,
profile_id: &str,
) -> Result<CheckoutTemplateOfShopResponse> {
let path = format!(
"{}/shops/{}",
merchant_path(merchant_id),
encode_segment(profile_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
}
fn merchant_path(merchant_id: &str) -> String {
format!("/checkout-templates/{}", encode_segment(merchant_id))
}
fn template_path(merchant_id: &str, template_id: &str) -> String {
format!(
"{}/{}",
merchant_path(merchant_id),
encode_segment(template_id)
)
}
#[derive(Debug, Clone, Serialize)]
pub struct CheckoutTemplateCreateRequest {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_from_profile_id: Option<String>,
}
impl CheckoutTemplateCreateRequest {
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
copy_from_profile_id: None,
}
}
#[must_use]
pub fn copy_from_profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.copy_from_profile_id = Some(profile_id.into());
self
}
}
#[derive(Debug, Clone, Serialize)]
pub struct CheckoutTemplateUpdateRequest {
pub name: String,
}
impl CheckoutTemplateUpdateRequest {
pub fn new(name: impl Into<String>) -> Self {
Self { name: name.into() }
}
}
#[derive(Debug, Clone, Serialize)]
pub struct CheckoutTemplateAssignRequest {
pub profile_ids: Vec<String>,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub dry_run: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
impl CheckoutTemplateAssignRequest {
pub fn new(profile_ids: Vec<String>) -> Self {
Self {
profile_ids,
dry_run: false,
reason: None,
}
}
#[must_use]
pub fn dry_run(mut self, dry_run: bool) -> Self {
self.dry_run = dry_run;
self
}
#[must_use]
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CheckoutTemplateApplyRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub dry_run: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
impl CheckoutTemplateApplyRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn profile_ids(mut self, profile_ids: Vec<String>) -> Self {
self.profile_ids = Some(profile_ids);
self
}
#[must_use]
pub fn dry_run(mut self, dry_run: bool) -> Self {
self.dry_run = dry_run;
self
}
#[must_use]
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const TEMPLATE_JSON: &str = r#"{
"template_id": "pro_tpl",
"name": "EU shops",
"content_version": 7,
"created_at": "2026-01-01T00:00:00Z",
"modified_at": "2026-01-02T00:00:00Z",
"shops": [{"profile_id": "pro_1", "status": "up_to_date", "applied_version": 7}],
"surprise_field": 1
}"#;
const APPLY_JSON: &str = r#"{
"template_id": "pro_tpl",
"content_version": 7,
"dry_run": true,
"shops": [{
"profile_id": "pro_1",
"outcome": "blocked",
"blockers": [{"reason": "connector_switched_off_in_shop", "connector": "stripe"}],
"changes": {"connectors_added": ["stripe"], "fallback_order": false}
}],
"surprise_field": "a"
}"#;
#[tokio::test]
async fn list_gets_the_merchant_path() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"templates":[{TEMPLATE_JSON}],"surprise_field":0}}"#
))]);
let out = client.checkout_templates().list("mer/1").await.unwrap();
assert_eq!(out.templates[0].content_version, 7);
assert_eq!(out.templates[0].shops[0].applied_version, Some(7));
assert_eq!(out.extra["surprise_field"], 0);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/checkout-templates/mer%2F1");
}
#[tokio::test]
async fn create_posts_the_name_and_source_shop() {
let (client, mock) = client_with(vec![Step::ok(TEMPLATE_JSON)]);
let params = CheckoutTemplateCreateRequest::new("EU shops").copy_from_profile_id("pro_1");
let out = client
.checkout_templates()
.create("mer_1", ¶ms)
.await
.unwrap();
assert_eq!(out.template_id, "pro_tpl");
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/checkout-templates/mer_1");
assert_eq!(
seen[0].body_json(),
json!({"name": "EU shops", "copy_from_profile_id": "pro_1"})
);
}
#[tokio::test]
async fn retrieve_gets_the_template_path() {
let (client, mock) = client_with(vec![Step::ok(TEMPLATE_JSON)]);
let out = client
.checkout_templates()
.retrieve("mer_1", "pro/tpl")
.await
.unwrap();
assert_eq!(out.name, "EU shops");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro%2Ftpl"
);
}
#[tokio::test]
async fn rename_posts_the_new_name_to_the_template_path() {
let (client, mock) = client_with(vec![Step::ok(TEMPLATE_JSON)]);
client
.checkout_templates()
.rename(
"mer_1",
"pro_tpl",
&CheckoutTemplateUpdateRequest::new("EU"),
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro_tpl"
);
assert_eq!(seen[0].body_json(), json!({"name": "EU"}));
}
#[tokio::test]
async fn delete_deletes_the_template_path() {
let (client, mock) = client_with(vec![Step::ok(TEMPLATE_JSON)]);
client
.checkout_templates()
.delete("mer_1", "pro_tpl")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro_tpl"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn assign_posts_the_shops_with_dry_run() {
let (client, mock) = client_with(vec![Step::ok(APPLY_JSON)]);
let params = CheckoutTemplateAssignRequest::new(vec!["pro_1".to_string()])
.dry_run(true)
.reason("rollout");
let out = client
.checkout_templates()
.assign("mer_1", "pro_tpl", ¶ms)
.await
.unwrap();
assert!(out.dry_run);
assert_eq!(out.shops[0].outcome, "blocked");
assert_eq!(
out.shops[0].blockers[0].reason,
"connector_switched_off_in_shop"
);
assert_eq!(out.shops[0].changes["connectors_added"][0], "stripe");
assert_eq!(out.extra["surprise_field"], "a");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro_tpl/shops"
);
assert_eq!(
seen[0].body_json(),
json!({"profile_ids": ["pro_1"], "dry_run": true, "reason": "rollout"})
);
}
#[tokio::test]
async fn unassign_deletes_the_shop_path_with_the_reason() {
let (client, mock) = client_with(vec![Step::ok(TEMPLATE_JSON)]);
client
.checkout_templates()
.unassign("mer_1", "pro_tpl", "pro/1", Some("moved"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro_tpl/shops/pro%2F1?reason=moved"
);
}
#[tokio::test]
async fn apply_with_defaults_posts_an_empty_object() {
let (client, mock) = client_with(vec![Step::ok(APPLY_JSON)]);
client
.checkout_templates()
.apply("mer_1", "pro_tpl", &CheckoutTemplateApplyRequest::new())
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/pro_tpl/apply"
);
assert_eq!(seen[0].body_json(), json!({}));
}
#[tokio::test]
async fn of_shop_gets_the_merchant_shop_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"profile_id":"pro_1","template":{"template_id":"pro_tpl","name":"EU shops"},
"is_template":false,"surprise_field":1}"#,
)]);
let out = client
.checkout_templates()
.of_shop("mer_1", "pro_1")
.await
.unwrap();
assert_eq!(out.template.as_ref().unwrap().template_id, "pro_tpl");
assert!(!out.is_template);
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-templates/mer_1/shops/pro_1"
);
}
fn keyed_client_over_503s() -> (
crate::Delopay,
std::sync::Arc<crate::http::mock::MockTransport>,
) {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::status(503, "{}")],
2,
);
(client.with_idempotency_key("client-wide-key"), mock)
}
fn assert_sent_once_unkeyed(mock: &crate::http::mock::MockTransport) {
assert_eq!(mock.call_count(), 1, "a 503 was replayed");
assert!(
!mock.seen.lock().unwrap()[0].had_idempotency_key(),
"the client-wide key was inherited"
);
}
#[tokio::test]
async fn new_writes_do_not_inherit_the_client_key() {
let (client, mock) = keyed_client_over_503s();
let params = CheckoutTemplateCreateRequest::new("Standard");
assert!(
client
.checkout_templates()
.create("mer_1", ¶ms)
.await
.is_err()
);
assert_sent_once_unkeyed(&mock);
}
}