Skip to main content

libkeri/keri/core/eventing/
query.rs

1use crate::cesr::Versionage;
2use crate::keri::core::serdering::{SadValue, SerderKERI};
3use crate::keri::{versify, Ilks, Kinds};
4use chrono::{DateTime, Utc};
5use indexmap::IndexMap;
6use std::error::Error;
7
8/// Builder for creating KERI query events
9pub struct QueryEventBuilder {
10    route: String,
11    reply_route: String,
12    query: Option<IndexMap<String, SadValue>>,
13    stamp: Option<String>,
14    version: String,
15    kind: String,
16}
17
18impl QueryEventBuilder {
19    /// Create a new QueryEventBuilder
20    pub fn new() -> Self {
21        Self {
22            route: String::new(),
23            reply_route: String::new(),
24            query: None,
25            stamp: None,
26            version: "KERI10JSON000000_".to_string(),
27            kind: "JSON".to_string(),
28        }
29    }
30
31    /// Set the route
32    ///
33    /// Parameters:
34    ///   route - namespaced path, '/' delimited, that indicates data flow
35    ///           handler (behavior) to process the query
36    pub fn with_route(mut self, route: String) -> Self {
37        self.route = route;
38        self
39    }
40
41    /// Set the reply route
42    ///
43    /// Parameters:
44    ///   reply_route - namespaced path, '/' delimited, that indicates data flow
45    ///                 handler (behavior) to process reply message to query if any
46    pub fn with_reply_route(mut self, reply_route: String) -> Self {
47        self.reply_route = reply_route;
48        self
49    }
50
51    /// Set the query data parameters
52    pub fn with_query(mut self, query: IndexMap<String, SadValue>) -> Self {
53        self.query = Some(query);
54        self
55    }
56
57    /// Set the timestamp
58    ///
59    /// Parameters:
60    ///   stamp - date-time-stamp RFC-3339 profile of ISO-8601 datetime of creation of message
61    pub fn with_stamp(mut self, stamp: String) -> Self {
62        self.stamp = Some(stamp);
63        self
64    }
65
66    /// Set the version string
67    pub fn with_version(mut self, version: String) -> Self {
68        self.version = version;
69        self
70    }
71
72    /// Set the serialization kind
73    pub fn with_kind(mut self, kind: String) -> Self {
74        self.kind = kind;
75        self
76    }
77
78    /// Build the query event serder
79    pub fn build(self) -> Result<SerderKERI, Box<dyn Error>> {
80        if !Kinds::contains(&self.kind) {
81            return Err(format!("Invalid kind = {} for qry.", self.kind).into());
82        }
83
84        // Create versified string
85        let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
86
87        // Generate timestamp if not provided
88        let timestamp = match self.stamp {
89            Some(ts) => ts,
90            None => {
91                let now: DateTime<Utc> = Utc::now();
92                now.to_rfc3339()
93            }
94        };
95
96        // Create the key event dict (ked)
97        let mut ked = IndexMap::new();
98        ked.insert("v".to_string(), SadValue::String(vs));
99        ked.insert("t".to_string(), SadValue::String(Ilks::QRY.to_string()));
100        ked.insert("d".to_string(), SadValue::String("".to_string()));
101        ked.insert("dt".to_string(), SadValue::String(timestamp));
102        ked.insert("r".to_string(), SadValue::String(self.route));
103        ked.insert("rr".to_string(), SadValue::String(self.reply_route));
104
105        if let Some(query_data) = self.query {
106            ked.insert("q".to_string(), SadValue::Object(query_data));
107        } else {
108            // If no query data is provided, use an empty object
109            ked.insert("q".to_string(), SadValue::Object(IndexMap::new()));
110        }
111
112        // Create the serder
113        let serder = SerderKERI::from_sad_and_saids(&ked, None)?;
114        Ok(serder)
115    }
116}
117
118#[cfg(test)]
119mod tests {
120    use super::*;
121    use crate::keri::core::serdering::Serder;
122    use std::error::Error;
123
124    #[test]
125    fn test_query_event_builder_basic() -> Result<(), Box<dyn Error>> {
126        // Create a basic query
127        let serder = QueryEventBuilder::new()
128            .with_route("logs".to_string())
129            .with_reply_route("log/processor".to_string())
130            .build()?;
131
132        // Verify the key event data
133        let ked = serder.ked();
134
135        // Check it's a query event
136        assert_eq!(ked["t"].as_str().unwrap(), Ilks::QRY);
137
138        // Check basic fields
139        assert_eq!(ked["r"].as_str().unwrap(), "logs");
140        assert_eq!(ked["rr"].as_str().unwrap(), "log/processor");
141
142        // Check dt field exists (timestamp)
143        assert!(ked.get("dt").is_some());
144
145        // Check q field is an empty object
146        match &ked["q"] {
147            SadValue::Object(obj) => assert!(obj.is_empty()),
148            _ => panic!("Expected q field to be an object"),
149        }
150
151        Ok(())
152    }
153
154    #[test]
155    fn test_query_event_with_query_data() -> Result<(), Box<dyn Error>> {
156        // Create query data
157        let mut query_data = IndexMap::new();
158        query_data.insert(
159            "i".to_string(),
160            SadValue::String("EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM".to_string()),
161        );
162        query_data.insert("sn".to_string(), SadValue::String("5".to_string()));
163        query_data.insert(
164            "dt".to_string(),
165            SadValue::String("2020-08-01T12:20:05.123456+00:00".to_string()),
166        );
167
168        // Set a specific timestamp
169        let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
170
171        // Create a query with data
172        let serder = QueryEventBuilder::new()
173            .with_route("logs".to_string())
174            .with_reply_route("log/processor".to_string())
175            .with_query(query_data)
176            .with_stamp(timestamp.clone())
177            .build()?;
178
179        // Verify the key event data
180        let ked = serder.ked();
181
182        // Check timestamp
183        assert_eq!(ked["dt"].as_str().unwrap(), timestamp);
184
185        // Check query data
186        let q = match &ked["q"] {
187            SadValue::Object(obj) => obj,
188            _ => panic!("Expected q field to be an object"),
189        };
190
191        assert_eq!(
192            q["i"].as_str().unwrap(),
193            "EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM"
194        );
195        assert_eq!(q["sn"].as_str().unwrap(), "5");
196        assert_eq!(
197            q["dt"].as_str().unwrap(),
198            "2020-08-01T12:20:05.123456+00:00"
199        );
200
201        Ok(())
202    }
203
204    #[test]
205    fn test_query_event_custom_version_kind() -> Result<(), Box<dyn Error>> {
206        // Create a query with custom version and kind
207        let serder = QueryEventBuilder::new()
208            .with_route("logs".to_string())
209            .with_version("KERI10".to_string())
210            .with_kind("CBOR".to_string())
211            .build()?;
212
213        // Verify the version string
214        let ked = serder.ked();
215        let version = ked["v"].as_str().unwrap();
216        assert!(version.starts_with("KERI10CBOR"));
217
218        Ok(())
219    }
220
221    #[test]
222    fn test_query_event_invalid_kind() -> Result<(), Box<dyn Error>> {
223        // Try to create a query with invalid kind
224        let result = QueryEventBuilder::new()
225            .with_kind("INVALID".to_string())
226            .build();
227
228        assert!(result.is_err());
229        let err = result.unwrap_err();
230        assert!(err.to_string().contains("Invalid kind"));
231
232        Ok(())
233    }
234
235    #[test]
236    fn test_query_event_said_derivation() -> Result<(), Box<dyn Error>> {
237        // Create a query
238        let serder = QueryEventBuilder::new()
239            .with_route("logs".to_string())
240            .build()?;
241
242        // Get the SAID (self-addressing identifier)
243        let said = serder.said().expect("Failed to get SAID");
244
245        // SAID should start with 'E' for BLAKE3_256 digest
246        assert!(said.starts_with('E'));
247
248        // Verify the SAID is in the 'd' field of the event
249        assert_eq!(serder.ked()["d"].as_str().unwrap(), said);
250
251        Ok(())
252    }
253
254    #[test]
255    fn test_query_matches_python_example() -> Result<(), Box<dyn Error>> {
256        // Recreate the Python example from the docstring
257        let mut query_data = IndexMap::new();
258        query_data.insert(
259            "i".to_string(),
260            SadValue::String("EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM".to_string()),
261        );
262        query_data.insert("sn".to_string(), SadValue::String("5".to_string()));
263        query_data.insert(
264            "dt".to_string(),
265            SadValue::String("2020-08-01T12:20:05.123456+00:00".to_string()),
266        );
267
268        let serder = QueryEventBuilder::new()
269            .with_route("logs".to_string())
270            .with_reply_route("log/processor".to_string())
271            .with_query(query_data)
272            .with_stamp("2020-08-22T17:50:12.988921+00:00".to_string())
273            .build()?;
274
275        let ked = serder.ked();
276
277        // Check expected fields from Python example
278        assert_eq!(ked["t"].as_str().unwrap(), Ilks::QRY);
279        assert_eq!(
280            ked["dt"].as_str().unwrap(),
281            "2020-08-22T17:50:12.988921+00:00"
282        );
283        assert_eq!(ked["r"].as_str().unwrap(), "logs");
284        assert_eq!(ked["rr"].as_str().unwrap(), "log/processor");
285
286        let q = match &ked["q"] {
287            SadValue::Object(obj) => obj,
288            _ => panic!("Expected q field to be an object"),
289        };
290
291        assert_eq!(
292            q["i"].as_str().unwrap(),
293            "EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM"
294        );
295        assert_eq!(q["sn"].as_str().unwrap(), "5");
296        assert_eq!(
297            q["dt"].as_str().unwrap(),
298            "2020-08-01T12:20:05.123456+00:00"
299        );
300
301        Ok(())
302    }
303
304    #[test]
305    fn test_query_event_builder_serialization() -> Result<(), Box<dyn Error>> {
306        // Create query data
307        let mut query_data = IndexMap::new();
308        query_data.insert(
309            "i".to_string(),
310            SadValue::String("DAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI".to_string()),
311        );
312
313        // Create a timestamp matching the Python test
314        let timestamp = "2021-01-01T00:00:00.000000+00:00".to_string();
315
316        // Create the query event
317        let serder = QueryEventBuilder::new()
318            .with_route("log".to_string())
319            .with_query(query_data)
320            .with_stamp(timestamp)
321            .build()?;
322
323        // Get raw serialized bytes
324        let raw = serder.raw();
325
326        // Expected bytes from Python test
327        let expected = b"{\"v\":\"KERI10JSON0000c9_\",\"t\":\"qry\",\"d\":\"EGN68_seecuzXQO15FFGJLVwZCBCPYW-hy29fjWWPQbp\",\"dt\":\"2021-01-01T00:00:00.000000+00:00\",\"r\":\"log\",\"rr\":\"\",\"q\":{\"i\":\"DAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI\"}}";
328
329        // Compare raw bytes with expected
330        assert_eq!(raw, expected);
331
332        Ok(())
333    }
334}