use simpleplatform_sdk::prelude::*;
#[derive(Deserialize, Schema)]
struct Input {
lead_id: String,
duplicate_of: String,
}
#[derive(Deserialize)]
struct Lead {
id: String,
status: String,
email: Option<String>,
}
#[derive(Deserialize)]
struct Found {
leads: Vec<Lead>,
}
#[derive(Deserialize)]
struct Closed {
result: Affected,
}
#[derive(Deserialize)]
struct Affected {
affected_rows: i64,
}
#[derive(Debug, Serialize)]
struct Output {
closed: String,
merged_into: String,
rows_changed: i64,
}
const FIND_LEADS: &str = r#"
query FindLeads($ids: [ID!]!) {
leads: crm__lead(where: {id: {_in: $ids}}, limit: 2) {
id
status
email
}
}"#;
const CLOSE_LEAD: &str = r#"
mutation CloseLead($id: ID!, $merged: ID!) {
result: update_crm__lead(
where: {id: {_eq: $id}}
_set: {status: "closed", merged_into: $merged}
) {
affected_rows
}
}"#;
fn main() {
simple::run(handler)
}
fn handler(request: Request<Input>) -> Result<Output, Error> {
let duplicate = request.data.lead_id.trim();
let survivor = request.data.duplicate_of.trim();
if duplicate == survivor {
return Err(Error::invalid("A lead cannot be a duplicate of itself.")
.hint("Pass two different lead ids."));
}
let found: Found = simple::graphql::query(FIND_LEADS, json!({ "ids": [duplicate, survivor] }))?;
let duplicate_lead = found
.leads
.iter()
.find(|lead| lead.id == duplicate)
.ok_or_else(|| {
Error::invalid(format!("Lead {duplicate} does not exist."))
.details(json!({ "missing": duplicate }))
.hint("Search for the lead before closing it.")
})?;
let survivor_lead = found
.leads
.iter()
.find(|lead| lead.id == survivor)
.ok_or_else(|| {
Error::invalid(format!("Lead {survivor} does not exist."))
.details(json!({ "missing": survivor }))
.hint("Search for the lead before merging into it.")
})?;
if duplicate_lead.status == "closed" {
return Err(Error::domain(
"LEAD_ALREADY_CLOSED",
format!("Lead {duplicate} is already closed."),
)
.hint("Nothing to do."));
}
if duplicate_lead.email != survivor_lead.email {
return Err(Error::domain(
"LEAD_EMAIL_MISMATCH",
"The two leads do not share an email address.",
)
.details(json!({
"duplicate": duplicate_lead.email,
"survivor": survivor_lead.email,
}))
.hint("Confirm these are the same person before merging them."));
}
let closed: Closed =
simple::graphql::mutate(CLOSE_LEAD, json!({ "id": duplicate, "merged": survivor }))?;
Ok(Output {
closed: duplicate.to_string(),
merged_into: survivor.to_string(),
rows_changed: closed.result.affected_rows,
})
}
#[cfg(test)]
mod tests {
use simpleplatform_sdk::testing;
use super::*;
fn input(lead_id: &str, duplicate_of: &str) -> Request<Input> {
Request::new(Input {
lead_id: lead_id.to_string(),
duplicate_of: duplicate_of.to_string(),
})
}
fn two_leads() -> Value {
json!({
"leads": [
{ "id": "LEAD1", "status": "open", "email": "a@example.com" },
{ "id": "LEAD2", "status": "open", "email": "a@example.com" }
]
})
}
#[test]
fn it_closes_the_duplicate_and_reports_what_changed() {
let session = testing::install(|_name, params| {
if params["query"].as_str().unwrap().contains("mutation") {
Ok(json!({ "result": { "affected_rows": 1 } }))
} else {
Ok(two_leads())
}
});
let output = handler(input("LEAD1", "LEAD2")).unwrap();
assert_eq!(output.closed, "LEAD1");
assert_eq!(output.rows_changed, 1);
assert_eq!(session.calls().len(), 2);
}
#[test]
fn a_lead_that_is_its_own_duplicate_is_refused_before_any_read() {
let session = testing::install(|_name, _params| Ok(json!(null)));
let error = handler(input("LEAD1", "LEAD1")).unwrap_err();
assert_eq!(error.code().as_str(), "INVALID_TOOL_INPUT");
assert!(session.calls().is_empty());
}
#[test]
fn a_mismatched_email_stops_the_write() {
let session = testing::install(|_name, _params| {
Ok(json!({
"leads": [
{ "id": "LEAD1", "status": "open", "email": "a@example.com" },
{ "id": "LEAD2", "status": "open", "email": "b@example.com" }
]
}))
});
let error = handler(input("LEAD1", "LEAD2")).unwrap_err();
assert_eq!(error.code().as_str(), "LEAD_EMAIL_MISMATCH");
assert_eq!(session.calls().len(), 1, "nothing was written");
}
#[test]
fn a_write_the_host_refused_says_the_effect_is_unknown() {
let _session = testing::install(|_name, params| {
if params["query"].as_str().unwrap().contains("mutation") {
Err(Error::failed("deadlock detected"))
} else {
Ok(two_leads())
}
});
let error = handler(input("LEAD1", "LEAD2")).unwrap_err();
assert_eq!(error.code().as_str(), "MUTATION_EXECUTION_FAILED");
}
#[test]
fn the_whole_run_reports_one_envelope_the_platform_can_read() {
let session = testing::install(|_name, _params| Ok(json!(null)))
.with_request(json!({ "lead_id": "LEAD1", "duplicate_of": "LEAD1" }));
simple::run(handler);
let done = session.done().unwrap();
assert_eq!(done["ok"], json!(true));
assert_eq!(
done["data"]["error"]["extensions"]["retryable"],
json!(false)
);
}
}