use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::to_json_vec;
use crate::core::error::{DelopayError, Result};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Search {
inner: Arc<Inner>,
}
impl Search {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn global(&self, params: &GlobalSearchRequest) -> Result<Value> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/analytics/search",
Some(&body),
&[],
None,
)
.await
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchTimeRange {
#[serde(rename = "startTime")]
pub start_time: String,
#[serde(rename = "endTime")]
pub end_time: String,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct GlobalSearchRequest {
pub query: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Value>,
#[serde(rename = "timeRange", skip_serializing_if = "Option::is_none")]
pub time_range: Option<SearchTimeRange>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const GLOBAL_SEARCH_REQUEST_NAMED: &[&str] = &["query", "filters", "timeRange"];
impl ValidateRequest for GlobalSearchRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if GLOBAL_SEARCH_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on GlobalSearchRequest"
)));
}
}
Ok(())
}
}
impl GlobalSearchRequest {
pub fn new(query: impl Into<String>) -> Self {
Self {
query: query.into(),
..Default::default()
}
}
pub fn filters(mut self, filters: Value) -> Self {
self.filters = Some(filters);
self
}
pub fn time_range(
mut self,
start_time: impl Into<String>,
end_time: impl Into<String>,
) -> Self {
self.time_range = Some(SearchTimeRange {
start_time: start_time.into(),
end_time: end_time.into(),
});
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
fn full_global_search_request() -> GlobalSearchRequest {
GlobalSearchRequest::new("pay_abc")
.filters(json!({"currency": "USD"}))
.time_range("2026-01-01T00:00:00Z", "2026-01-31T00:00:00Z")
}
#[test]
fn global_search_request_named_fields_are_complete() {
let value = serde_json::to_value(full_global_search_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
GLOBAL_SEARCH_REQUEST_NAMED.contains(&key.as_str()),
"GLOBAL_SEARCH_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or GlobalSearchRequest's extra-key collision guard \
will silently stop covering this field"
);
}
}
#[test]
fn validate_rejects_extra_key_colliding_with_named_field() {
let mut req = GlobalSearchRequest::new("pay_abc");
req.extra.insert("timeRange".to_string(), json!("collide"));
let err = req.validate().unwrap_err();
match err {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("timeRange")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[tokio::test]
async fn global_posts_the_request_to_analytics_search() {
let (client, mock) = client_with(vec![Step::ok(
r#"[{"count":1,"index":"payment_intents","hits":[{"payment_id":"pay_1"}],"status":"Success"}]"#,
)]);
let out = client
.search()
.global(&full_global_search_request())
.await
.unwrap();
assert_eq!(out[0]["index"], "payment_intents");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/analytics/search");
let body = seen[0].body_json();
assert_eq!(body["query"], "pay_abc");
assert_eq!(body["filters"]["currency"], "USD");
assert_eq!(body["timeRange"]["startTime"], "2026-01-01T00:00:00Z");
assert_eq!(body["timeRange"]["endTime"], "2026-01-31T00:00:00Z");
}
#[tokio::test]
async fn global_omits_absent_optional_fields() {
let (client, mock) = client_with(vec![Step::ok("[]")]);
client
.search()
.global(&GlobalSearchRequest::new("cus_1"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body = seen[0].body_json();
assert_eq!(body, json!({"query": "cus_1"}));
}
}