1use anyhow::{ensure, Result};
45
46use crate::dag_cbor::DagCbor;
47use crate::list_record::{self, ListExtra, ListItemRecord, ListRecord};
48
49pub const GROUP_COLLECTION_NSID: &str = "ai.hyprstream.event.group";
51pub const GROUP_ITEM_COLLECTION_NSID: &str = "ai.hyprstream.event.groupItem";
53
54#[derive(Clone, Debug, Eq, PartialEq)]
73pub struct EventGroupExtra {
74 pub keyset_id: String,
78}
79
80impl ListExtra for EventGroupExtra {
81 fn field_names() -> &'static [&'static str] {
82 &["keysetId"]
83 }
84
85 fn encode_into(&self, pairs: &mut Vec<(&'static str, DagCbor)>) {
86 pairs.push(("keysetId", DagCbor::Text(self.keyset_id.clone())));
87 }
88
89 fn decode_from(value: &DagCbor, nsid: &str) -> Result<Self> {
90 let keyset_id = list_record::map_get_str(value, "keysetId", nsid)?.to_owned();
91 Ok(Self { keyset_id })
92 }
93
94 fn validate(&self) -> Result<()> {
95 ensure!(!self.keyset_id.is_empty(), "keysetId must be non-empty");
96 Ok(())
97 }
98}
99
100pub type EventGroupRecord = ListRecord<EventGroupExtra>;
102
103pub type EventGroupItemRecord = ListItemRecord;
107
108pub use list_record::check_bidirectional_consent;
110
111impl EventGroupRecord {
112 pub fn new_event_group(
115 name: impl Into<String>,
116 owner_did: impl Into<String>,
117 purpose: Option<String>,
118 keyset_id: impl Into<String>,
119 created_at: impl Into<String>,
120 ) -> Result<Self> {
121 ListRecord::new(
122 name,
123 owner_did,
124 purpose,
125 created_at,
126 EventGroupExtra {
127 keyset_id: keyset_id.into(),
128 },
129 )
130 }
131}
132
133impl EventGroupItemRecord {
134 pub fn from_event_dag_cbor(bytes: &[u8]) -> Result<Self> {
136 Self::from_dag_cbor(bytes, GROUP_ITEM_COLLECTION_NSID)
137 }
138}
139
140#[cfg(test)]
141mod tests {
142 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)]
143 use super::*;
144
145 fn sample_group() -> EventGroupRecord {
146 EventGroupRecord::new_event_group(
147 "qwen3-serving",
148 "did:web:nodeA.example.com",
149 Some("serve:model:qwen3 subscribers".to_owned()),
150 "ks-2026-06-30-01",
151 "2026-06-30T12:00:00.000Z",
152 )
153 .expect("valid sample")
154 }
155
156 fn sample_item() -> EventGroupItemRecord {
157 EventGroupItemRecord::new(
158 "at://did:web:nodeA.example.com/ai.hyprstream.event.group/3k2x",
159 "did:web:memberB.example.com",
160 "2026-06-30T12:01:00.000Z",
161 )
162 .expect("valid sample")
163 }
164
165 #[test]
166 fn group_deterministic_across_rebuild() {
167 let r1 = sample_group();
168 let r2 = EventGroupRecord::new_event_group(
169 r1.name.clone(),
170 r1.owner_did.clone(),
171 r1.purpose.clone(),
172 r1.extra.keyset_id.clone(),
173 r1.created_at.clone(),
174 )
175 .unwrap();
176 assert_eq!(r1.to_dag_cbor(), r2.to_dag_cbor());
177 assert_eq!(r1.cid(), r2.cid());
178 }
179
180 #[test]
181 fn group_round_trips_through_dag_cbor() {
182 let r = sample_group();
183 let bytes = r.to_dag_cbor();
184 let decoded =
185 EventGroupRecord::from_dag_cbor(&bytes, GROUP_COLLECTION_NSID).expect("decode");
186 assert_eq!(r, decoded);
187 }
188
189 #[test]
190 fn group_round_trips_without_optional_purpose() {
191 let r = EventGroupRecord::new_event_group(
192 "no-purpose-group",
193 "did:web:nodeA.example.com",
194 None,
195 "ks-1",
196 "2026-06-30T12:00:00.000Z",
197 )
198 .unwrap();
199 let decoded = EventGroupRecord::from_dag_cbor(&r.to_dag_cbor(), GROUP_COLLECTION_NSID)
200 .expect("decode");
201 assert_eq!(r, decoded);
202 assert!(decoded.purpose.is_none());
203 }
204
205 #[test]
206 fn group_rejects_extra_fields() {
207 let mut extra = sample_group().to_value();
208 if let DagCbor::Map(ref mut v) = extra {
209 v.push((DagCbor::Text("extra".into()), DagCbor::Unsigned(1)));
210 v.sort_by(|a, b| a.0.as_str().unwrap_or("").cmp(b.0.as_str().unwrap_or("")));
211 }
212 assert!(EventGroupRecord::from_value(&extra, GROUP_COLLECTION_NSID).is_err());
213 }
214
215 #[test]
216 fn group_rejects_bad_did_and_keyset() {
217 assert!(EventGroupRecord::new_event_group(
218 "g",
219 "not-a-did",
220 None,
221 "ks-1",
222 "2026-06-30T12:00:00.000Z"
223 )
224 .is_err());
225 assert!(EventGroupRecord::new_event_group(
226 "g",
227 "did:web:x",
228 None,
229 "",
230 "2026-06-30T12:00:00.000Z"
231 )
232 .is_err());
233 }
234
235 #[test]
236 fn group_field_order_matches_lexicon_canonical_cbor() {
237 let v = DagCbor::decode(&sample_group().to_dag_cbor()).expect("decode");
238 let map = v.as_map().expect("map");
239 let keys: Vec<&str> = map.iter().map(|(k, _)| k.as_str().expect("str")).collect();
240 assert_eq!(
242 keys,
243 vec!["createdAt", "keysetId", "name", "ownerDid", "purpose"]
244 );
245 }
246
247 #[test]
248 fn group_item_round_trips() {
249 let item = sample_item();
250 let decoded =
251 EventGroupItemRecord::from_event_dag_cbor(&item.to_dag_cbor()).expect("decode");
252 assert_eq!(item, decoded);
253 }
254
255 #[test]
256 fn group_item_rejects_bad_at_uri_and_did() {
257 assert!(EventGroupItemRecord::new(
258 "not-an-at-uri",
259 "did:web:x",
260 "2026-06-30T12:00:00.000Z"
261 )
262 .is_err());
263 assert!(EventGroupItemRecord::new(
264 "at://did:web:x/ai.hyprstream.event.group/abc",
265 "not-a-did",
266 "2026-06-30T12:00:00.000Z"
267 )
268 .is_err());
269 }
270
271 #[test]
272 fn bidirectional_consent_requires_both_sides() {
273 let item = sample_item();
274 let group_uri = item.group.clone();
275 let member = item.subject.clone();
276
277 assert!(!check_bidirectional_consent(
278 &item,
279 &group_uri,
280 &member,
281 &[]
282 ));
283 assert!(!check_bidirectional_consent(
284 &item,
285 &group_uri,
286 &member,
287 &["at://did:web:other/ai.hyprstream.event.group/zzzz".to_owned()],
288 ));
289 assert!(check_bidirectional_consent(
290 &item,
291 &group_uri,
292 &member,
293 std::slice::from_ref(&group_uri),
294 ));
295 assert!(!check_bidirectional_consent(
296 &item,
297 "at://did:web:nodeA.example.com/ai.hyprstream.event.group/different",
298 &member,
299 &[group_uri],
300 ));
301 }
302}