Skip to main content

tuwunel_service/rooms/pdu_metadata/
bundling.rs

1use std::collections::BTreeSet;
2
3use futures::{Stream, StreamExt, TryFutureExt, pin_mut};
4use ruma::{OwnedUserId, UserId, api::Direction, events::room::encrypted::Relation};
5use tuwunel_core::{
6	arrayvec::ArrayVec,
7	implement,
8	result::LogErr,
9	utils::{
10		BoolExt,
11		stream::{ReadyExt, TryIgnore},
12		u64_from_u8,
13	},
14};
15use tuwunel_matrix::{Event, Pdu, PduCount, PduId, RawPduId};
16
17use super::{
18	ExtractRelatesTo, IgnoredThreadView,
19	IgnoredThreadView::{Adjusted, Unchanged, WithoutSummary},
20	Service,
21	typed_relations::{CHILD_COUNT_OFFSET, KEY_LEN, Tag, prefix},
22};
23
24type Seek = ArrayVec<u8, KEY_LEN>;
25
26/// Fold read-time bundled aggregations into a served event's `unsigned`,
27/// per-requester. MSC3816: the stored `m.thread` bundle carries a shared
28/// `current_user_participated`, recomputed here for `sender_user`. MSC3925:
29/// when `bundle_edit_relations` is enabled, the newest `m.replace` edit is
30/// folded in as the full replacement event, and the bundled thread
31/// `latest_event` carries its own newest edit (MSC3856). MSC3267: when
32/// `bundle_reference_relations` is enabled, the `m.reference` children are
33/// folded in as a `{ chunk: [{ event_id }] }` summary. The thread presence gate
34/// keeps the common no-bundle case to a substring scan; the edit and reference
35/// folds are skipped unless enabled.
36#[implement(Service)]
37#[tracing::instrument(skip_all, level = "trace")]
38pub async fn bundle_aggregations(&self, sender_user: &UserId, mut pdu: Pdu) -> Pdu {
39	// MSC4025: an erased sender's event serves as the pruned clone, and a
40	// pruned event carries no aggregations.
41	if let Some(pruned) = self
42		.services
43		.state_accessor
44		.erased_view(sender_user, &pdu)
45		.await
46	{
47		return pruned;
48	}
49
50	self.bundle_thread_for(sender_user, &mut pdu)
51		.await;
52
53	let replacement = self
54		.services
55		.server
56		.config
57		.rooms
58		.relations
59		.bundle_edits
60		.then_async(|| self.newest_replacement(&pdu))
61		.await
62		.flatten();
63
64	if let Some(replacement) = replacement
65		&& !self
66			.services
67			.state_accessor
68			.erased_for(sender_user, &replacement)
69			.await
70	{
71		let replacement = replacement.without_private_unless_sender(Some(sender_user));
72
73		pdu.set_replacement_bundle(&replacement.into_format())
74			.log_err()
75			.ok();
76	}
77
78	let references = self
79		.services
80		.server
81		.config
82		.rooms
83		.relations
84		.bundle_references
85		.then_async(|| self.references(&pdu))
86		.await
87		.unwrap_or_default();
88
89	if !references.is_empty() {
90		pdu.set_reference_bundle(&references)
91			.log_err()
92			.ok();
93	}
94
95	pdu
96}
97
98#[implement(Service)]
99#[tracing::instrument(skip_all, level = "trace")]
100async fn bundle_thread_for(&self, sender_user: &UserId, pdu: &mut Pdu) {
101	if pdu
102		.has_thread_bundle()
103		.log_err()
104		.unwrap_or(true)
105		.is_false()
106	{
107		return;
108	}
109
110	if pdu
111		.thread_latest_event()
112		.log_err()
113		.ok()
114		.flatten()
115		.is_none()
116		|| pdu
117			.remove_thread_latest_transaction_id_unless_sender(sender_user)
118			.log_err()
119			.is_err()
120	{
121		drop_thread_bundle(pdu);
122		return;
123	}
124
125	let participated = self
126		.services
127		.threads
128		.user_participated(pdu.event_id(), sender_user)
129		.await;
130
131	let participation = pdu
132		.set_thread_participated(participated)
133		.log_err();
134
135	if thread_result_or_drop(pdu, participation).is_none() {
136		return;
137	}
138
139	self.erase_thread_latest(sender_user, pdu).await;
140
141	let _: Option<()> = self
142		.services
143		.server
144		.config
145		.rooms
146		.relations
147		.bundle_edits
148		.then_async(|| self.bundle_thread_latest_edit(sender_user, pdu))
149		.await;
150}
151
152/// MSC4025: the stored thread bundle carries a full `latest_event` of any
153/// sender; an erased hit swaps in the pruned form for this recipient. The
154/// event load and membership check run only on the erased hit.
155#[implement(Service)]
156#[tracing::instrument(skip_all, level = "trace")]
157async fn erase_thread_latest(&self, sender_user: &UserId, pdu: &mut Pdu) {
158	let identity = pdu.thread_latest_event().log_err();
159
160	let Some((event_id, sender)) = thread_result_or_drop(pdu, identity).flatten() else {
161		return;
162	};
163
164	if !self.services.users.is_erased(&sender).await {
165		return;
166	}
167
168	let latest = self.services.timeline.get_pdu(&event_id).await;
169	let Some(latest) = thread_result_or_drop(pdu, latest) else {
170		return;
171	};
172
173	let Some(pruned) = self
174		.services
175		.state_accessor
176		.erased_view(sender_user, &latest)
177		.await
178	else {
179		return;
180	};
181
182	if pdu
183		.set_thread_latest_event(&pruned.into_format())
184		.log_err()
185		.is_err()
186	{
187		drop_thread_bundle(pdu);
188	}
189}
190
191fn thread_result_or_drop<T, E>(pdu: &mut Pdu, result: Result<T, E>) -> Option<T> {
192	result
193		.inspect_err(|_| drop_thread_bundle(pdu))
194		.ok()
195}
196
197fn drop_thread_bundle(pdu: &mut Pdu) { pdu.remove_thread_bundle().log_err().ok(); }
198
199/// The thread module's aggregated `latest_event` (MSC3856): when the edit
200/// fold is enabled, the bundled latest reply carries its own newest
201/// `m.replace` edit, so thread previews track edits. Erased-sender bundles
202/// stay in their pruned form.
203#[implement(Service)]
204#[tracing::instrument(skip_all, level = "trace")]
205async fn bundle_thread_latest_edit(&self, sender_user: &UserId, pdu: &mut Pdu) {
206	let identity = pdu.thread_latest_event().log_err();
207
208	let Some((event_id, _)) = thread_result_or_drop(pdu, identity).flatten() else {
209		return;
210	};
211
212	let latest_event = self
213		.services
214		.timeline
215		.get_pdu(&event_id)
216		.await
217		.log_err();
218
219	let Some(mut latest_event) = thread_result_or_drop(pdu, latest_event) else {
220		return;
221	};
222
223	if self
224		.services
225		.state_accessor
226		.erased_for(sender_user, &latest_event)
227		.await
228	{
229		return;
230	}
231
232	let Some(mut replacement_event) = self.newest_replacement(&latest_event).await else {
233		return;
234	};
235
236	if self
237		.services
238		.state_accessor
239		.erased_for(sender_user, &replacement_event)
240		.await
241	{
242		return;
243	}
244
245	replacement_event.remove_private_unless_sender(Some(sender_user));
246	latest_event.remove_private_unless_sender(Some(sender_user));
247
248	let replacement = latest_event
249		.set_replacement_bundle(&replacement_event.into_format())
250		.log_err();
251
252	if thread_result_or_drop(pdu, replacement).is_none() {
253		return;
254	}
255
256	let latest = pdu
257		.set_thread_latest_event(&latest_event.into_format())
258		.log_err();
259
260	thread_result_or_drop(pdu, latest);
261}
262
263/// MSC3925: the newest `m.replace` edit of `parent` as a full event, or `None`
264/// when `parent` is redacted or has no valid edit. An edit counts only when it
265/// shares the parent's sender and type and is not itself redacted; newest is by
266/// `origin_server_ts`, which the typed index sorts on.
267#[implement(Service)]
268#[tracing::instrument(skip_all, level = "trace")]
269async fn newest_replacement(&self, parent: &Pdu) -> Option<Pdu> {
270	if parent.is_redacted() {
271		return None;
272	}
273
274	let parent_id: PduId = self
275		.services
276		.timeline
277		.get_pdu_id(parent.event_id())
278		.map_ok(Into::into)
279		.await
280		.ok()?;
281
282	let replacements = self.replacement_children(parent, parent_id);
283
284	pin_mut!(replacements);
285	replacements.next().await
286}
287
288/// Stream `parent`'s valid `m.replace` children, newest `origin_server_ts`
289/// first, from the typed index. A child counts only when it shares the parent's
290/// sender and type and is not itself redacted.
291#[implement(Service)]
292fn replacement_children<'a>(
293	&'a self,
294	parent: &'a Pdu,
295	parent_id: PduId,
296) -> impl Stream<Item = Pdu> + Send + 'a {
297	let shortroomid = parent_id.shortroomid;
298	let prefix = prefix(shortroomid, parent_id.count, Tag::Replace);
299
300	let mut seek = Seek::new();
301
302	seek.extend(prefix.iter().copied());
303	seek.extend([u8::MAX; size_of::<u64>() * 2]);
304
305	self.db
306		.relatesto_typed
307		.rev_raw_keys_from(seek.as_slice())
308		.ignore_err()
309		.ready_take_while(move |key| key.starts_with(&prefix))
310		.map(|key| u64_from_u8(&key[CHILD_COUNT_OFFSET..KEY_LEN]))
311		.map(PduCount::from_unsigned)
312		.map(move |count| (shortroomid, count))
313		.filter_map(async |(shortroomid, count)| {
314			let child_id: RawPduId = PduId { shortroomid, count }.into();
315			self.services
316				.timeline
317				.get_pdu_from_id(&child_id)
318				.await
319				.ok()
320				.filter(|child| !child.is_redacted())
321				.filter(|child| child.sender() == parent.sender())
322				.filter(|child| child.kind() == parent.kind())
323		})
324}
325
326/// Evaluate one thread root against the requester's ignore list.
327///
328/// A cheap participant intersection gates the reply walk. One walk then yields
329/// the replacement `latest_event`, the ignored-aware `count`, and the
330/// summary-omission verdict when every reply is ignored. A root whose replies
331/// are not indexed adjusts nothing beyond its own redacted form.
332#[implement(Service)]
333#[tracing::instrument(skip_all, level = "trace")]
334pub async fn ignored_thread_view(
335	&self,
336	sender_user: &UserId,
337	ignored: &BTreeSet<OwnedUserId>,
338	root: &Pdu,
339) -> IgnoredThreadView {
340	let Ok(root_id) = self
341		.services
342		.timeline
343		.get_pdu_id(root.event_id())
344		.await
345	else {
346		return Unchanged;
347	};
348
349	let participants = self
350		.services
351		.threads
352		.get_participants(&root_id)
353		.await
354		.unwrap_or_default();
355
356	if !participants
357		.iter()
358		.any(|user| ignored.contains(user))
359	{
360		return Unchanged;
361	}
362
363	let root_pid: PduId = root_id.into();
364	let replies = self
365		.get_relations(
366			root_pid.shortroomid,
367			root_pid.count,
368			None,
369			Direction::Backward,
370			Some(sender_user),
371		)
372		.ready_filter_map(|(_, pdu)| {
373			pdu.get_content()
374				.is_ok_and(|content: ExtractRelatesTo| {
375					matches!(content.relates_to, Relation::Thread(_))
376				})
377				.then_some(pdu)
378		});
379
380	let fold = |(total, unignored, latest): (usize, usize, Option<Pdu>), pdu: Pdu| match ignored
381		.contains(pdu.sender())
382	{
383		| true => (total.saturating_add(1), unignored, latest),
384		| false => (total.saturating_add(1), unignored.saturating_add(1), latest.or(Some(pdu))),
385	};
386
387	let (total, unignored, latest) = replies.ready_fold((0, 0, None), fold).await;
388
389	if total == 0 {
390		return match self.redacted_root(ignored, root).await {
391			| None => Unchanged,
392			| root => Adjusted { root, count: None, latest: None },
393		};
394	}
395
396	if unignored == 0 {
397		return WithoutSummary {
398			root: self.redacted_root(ignored, root).await,
399		};
400	}
401
402	let swap = root
403		.thread_latest_event()
404		.ok()
405		.flatten()
406		.is_some_and(|(_, sender)| ignored.contains(&sender));
407
408	let latest = match swap.then_some(latest).flatten() {
409		| None => None,
410		| Some(reply) => {
411			// MSC4025: the swapped-in reply must not reopen the erased-sender
412			// seam the bundle pass gates on the stored latest.
413			let reply = self
414				.services
415				.state_accessor
416				.erased_view(sender_user, &reply)
417				.await
418				.unwrap_or(reply);
419
420			Some(reply.into_format())
421		},
422	};
423
424	let count = unignored.ne(&total).then_some(unignored);
425
426	let root = self.redacted_root(ignored, root).await;
427
428	if root.is_none() && count.is_none() && latest.is_none() {
429		return Unchanged;
430	}
431
432	Adjusted { root, count, latest }
433}
434
435/// The spec'd redacted form of an ignored sender's thread root, content side
436/// only; `None` when the sender is not ignored, or on a redaction failure
437/// (serving unredacted then matches the reference implementation).
438#[implement(Service)]
439#[tracing::instrument(skip_all, level = "trace")]
440async fn redacted_root(&self, ignored: &BTreeSet<OwnedUserId>, root: &Pdu) -> Option<Box<Pdu>> {
441	ignored
442		.contains(root.sender())
443		.then_async(async || {
444			self.services
445				.state
446				.get_room_version_rules(root.room_id())
447				.await
448				.log_err()
449				.ok()
450				.and_then(|rules| root.redacted(&rules.redaction).log_err().ok())
451				.map(Box::new)
452		})
453		.await
454		.flatten()
455}
456
457#[cfg(test)]
458mod tests {
459	use serde_json::json;
460
461	use super::*;
462
463	#[test]
464	fn thread_latest_load_error_drops_bundle() {
465		let mut pdu: Pdu = serde_json::from_value(json!({
466			"type": "m.room.member",
467			"content": { "membership": "join" },
468			"event_id": "$member:example.com",
469			"room_id": "!room:example.com",
470			"sender": "@alice:example.com",
471			"state_key": "@alice:example.com",
472			"prev_events": ["$prev:example.com"],
473			"auth_events": ["$auth:example.com"],
474			"origin_server_ts": 1_838_188_000,
475			"depth": 12,
476			"hashes": { "sha256": "thishashcoversallfieldsincasethisisredacted" },
477			"unsigned": {
478				"age": 4612,
479				"m.relations": {
480					"m.replace": { "event_id": "$edit:example.com" },
481					"m.thread": { "count": 3 },
482				},
483			},
484		}))
485		.expect("test fixture should deserialize as a valid PDU");
486
487		let latest: Option<()> = thread_result_or_drop(&mut pdu, Err("missing latest event"));
488
489		assert!(latest.is_none(), "load failure returned a latest event");
490
491		let unsigned: serde_json::Value = serde_json::from_str(
492			pdu.unsigned
493				.as_ref()
494				.expect("sibling unsigned data should remain")
495				.json()
496				.get(),
497		)
498		.expect("remaining unsigned data should be valid JSON");
499
500		assert!(
501			unsigned["m.relations"].get("m.thread").is_none(),
502			"failed load retained the thread bundle",
503		);
504
505		assert_eq!(
506			unsigned["m.relations"]["m.replace"],
507			json!({ "event_id": "$edit:example.com" }),
508			"failed load removed a sibling relation",
509		);
510		assert_eq!(unsigned["age"], 4612, "failed load removed outer unsigned data");
511	}
512}