libkeri/keri/core/eventing/
query.rs1use 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
8pub 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 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 pub fn with_route(mut self, route: String) -> Self {
37 self.route = route;
38 self
39 }
40
41 pub fn with_reply_route(mut self, reply_route: String) -> Self {
47 self.reply_route = reply_route;
48 self
49 }
50
51 pub fn with_query(mut self, query: IndexMap<String, SadValue>) -> Self {
53 self.query = Some(query);
54 self
55 }
56
57 pub fn with_stamp(mut self, stamp: String) -> Self {
62 self.stamp = Some(stamp);
63 self
64 }
65
66 pub fn with_version(mut self, version: String) -> Self {
68 self.version = version;
69 self
70 }
71
72 pub fn with_kind(mut self, kind: String) -> Self {
74 self.kind = kind;
75 self
76 }
77
78 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 let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
86
87 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 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 ked.insert("q".to_string(), SadValue::Object(IndexMap::new()));
110 }
111
112 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 let serder = QueryEventBuilder::new()
128 .with_route("logs".to_string())
129 .with_reply_route("log/processor".to_string())
130 .build()?;
131
132 let ked = serder.ked();
134
135 assert_eq!(ked["t"].as_str().unwrap(), Ilks::QRY);
137
138 assert_eq!(ked["r"].as_str().unwrap(), "logs");
140 assert_eq!(ked["rr"].as_str().unwrap(), "log/processor");
141
142 assert!(ked.get("dt").is_some());
144
145 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 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 let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
170
171 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 let ked = serder.ked();
181
182 assert_eq!(ked["dt"].as_str().unwrap(), timestamp);
184
185 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 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 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 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 let serder = QueryEventBuilder::new()
239 .with_route("logs".to_string())
240 .build()?;
241
242 let said = serder.said().expect("Failed to get SAID");
244
245 assert!(said.starts_with('E'));
247
248 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 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 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 let mut query_data = IndexMap::new();
308 query_data.insert(
309 "i".to_string(),
310 SadValue::String("DAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI".to_string()),
311 );
312
313 let timestamp = "2021-01-01T00:00:00.000000+00:00".to_string();
315
316 let serder = QueryEventBuilder::new()
318 .with_route("log".to_string())
319 .with_query(query_data)
320 .with_stamp(timestamp)
321 .build()?;
322
323 let raw = serder.raw();
325
326 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 assert_eq!(raw, expected);
331
332 Ok(())
333 }
334}