1#![allow(async_fn_in_trait)]
60#![deny(clippy::await_holding_lock)]
61
62mod history;
63
64use std::collections::{BTreeSet, HashMap, HashSet};
65use std::marker::PhantomData;
66use std::sync::{Arc, Mutex};
67
68use crate::{
69 AttachmentBlob, ChatAccessPolicy, ChatEvents, ChatLimits, ChatMessageLifecycle, ChatModeration,
70 ChatResolvers, ChatRestrictions, ChatSettings, ChatSpaces, ChatStore, EmojiSetOp,
71 InviteJoinRefusal, OpResult, SlowModeError, SpacePatchOp, SpacePolicy,
72 strip_unsupported_chat_push, validate_chat_push,
73};
74use jmap_chat_types::{ChatPermission, ChatPushCapability};
75use jmap_metadata_server::{
76 ChangedProperties, MetadataCondition, MetadataFilterError, MetadataOnlyChanges, SetKind,
77 changed_properties, check_metadata_depth, check_metadata_write, is_metadata_property,
78};
79use jmap_metadata_types::DataTypeMetadataInfo;
80use jmap_object_history_server::{ChangeEvent, ChangeKind, fold_restore};
81use jmap_server::{
82 AddedItem, BackendChangesError, BackendQueryError, BackendSetError, ChangesResult, GetObject,
83 JmapAccounts, JmapObject, JmapReads, MemoryCaller, QueryChangesParams, QueryChangesResult,
84 QueryObject, QueryParams, QueryResult, SetError, SetErrorType, SetObject,
85};
86use jmap_server::{
87 BeginSetError, ConditionalBackend, DeferredFailure, MergePatchError, PatchPathError,
88 PushSubscriptionBackend, ScopedState, SetOp, SetScope, SetScopeRequest, StoredPushSubscription,
89 apply_patch_object, check_patch_paths, json_merge_patch, limit_or_max, now_utc_string,
90 resolve_query_start,
91};
92use jmap_types::{Id, PushSubscription, State};
93
94pub const MAX_PUSH_SUBSCRIPTIONS: usize = 50;
103
104#[derive(Debug, Clone, Copy)]
119enum IdFate {
120 Created,
121 Updated,
122 Destroyed,
123}
124
125#[derive(Clone, Debug)]
127struct ChangeEntry {
128 new_state: u64,
130 created: Vec<Id>,
131 updated: Vec<Id>,
132 destroyed: Vec<Id>,
133 updated_props: Option<BTreeSet<String>>,
138 restored: Vec<Id>,
141}
142
143impl ChangeEntry {
144 fn is_metadata_only_update(&self) -> bool {
147 self.created.is_empty()
148 && self.destroyed.is_empty()
149 && self.updated_props.as_ref().is_some_and(|props| {
150 !props.is_empty() && props.iter().all(|p| is_metadata_property(p))
151 })
152 }
153}
154
155#[derive(Default, Clone)]
158struct Inner {
159 objects: HashMap<&'static str, HashMap<String, HashMap<Id, serde_json::Value>>>,
161 states: HashMap<&'static str, HashMap<String, u64>>,
163 change_log: HashMap<&'static str, HashMap<String, Vec<ChangeEntry>>>,
165 change_log_floor: HashMap<&'static str, HashMap<String, u64>>,
169 change_log_limit: Option<usize>,
172 event_limit: Option<usize>,
175 known_accounts: HashSet<String>,
177 limits_override: Option<ChatLimits>,
181 attachment_blobs: HashMap<(String, Id), AttachmentBlob>,
185 retains_edit_history: bool,
188 maintains_unread_count: bool,
191 protect_last_admin: bool,
199 owner_user_ids: HashMap<String, String>,
203 push_subscriptions: HashMap<Id, StoredPushSubscription>,
206 chat_push_caps: HashMap<Id, ChatPushCapability>,
210 space_extension_properties: &'static [&'static str],
214 lifecycle_events: Vec<LifecycleEvent>,
217 outbound_events: Vec<crate::OutboundEvent>,
220 everyone_permissions: HashSet<ChatPermission>,
224 space_everyone_permissions: HashMap<String, HashSet<ChatPermission>>,
227 ids: Arc<Mutex<ulid::Generator>>,
232 metadata_info: HashMap<&'static str, DataTypeMetadataInfo>,
236 search: Option<jmap_search::SearchCapability>,
239 history: Option<jmap_object_history_server::HistoryStore>,
242}
243
244#[non_exhaustive]
247#[derive(Debug, Clone, PartialEq)]
248pub enum LifecycleEvent {
249 ChatDestroyed(Id),
251 SpaceDestroyed(Id),
253 SpaceBanCreated(jmap_chat_types::SpaceBan),
255}
256
257impl Inner {
258 fn mint_id(&mut self) -> Id {
266 let ulid = self
267 .ids
268 .lock()
269 .unwrap_or_else(std::sync::PoisonError::into_inner)
270 .generate()
271 .expect("80 random ULID bits cannot overflow within one millisecond in practice");
272 Id::from(ulid.to_string())
273 }
274
275 fn everyone_for(&self, space_id: &str) -> &HashSet<ChatPermission> {
277 self.space_everyone_permissions
278 .get(space_id)
279 .unwrap_or(&self.everyone_permissions)
280 }
281
282 fn everyone_in(&self, space_val: &serde_json::Value) -> &HashSet<ChatPermission> {
284 self.everyone_for(
285 space_val
286 .get("id")
287 .and_then(|v| v.as_str())
288 .unwrap_or_default(),
289 )
290 }
291
292 fn current_state(&self, type_name: &'static str, account_id: &str) -> u64 {
293 self.states
294 .get(type_name)
295 .and_then(|m| m.get(account_id))
296 .copied()
297 .unwrap_or(0)
298 }
299
300 fn bump_state(&mut self, type_name: &'static str, account_id: &str) -> u64 {
301 let entry = self
302 .states
303 .entry(type_name)
304 .or_default()
305 .entry(account_id.to_owned())
306 .or_insert(0);
307 *entry += 1;
308 *entry
309 }
310
311 fn objects_mut(
315 &mut self,
316 type_name: &'static str,
317 account_id: &str,
318 ) -> &mut HashMap<Id, serde_json::Value> {
319 self.objects
320 .entry(type_name)
321 .or_default()
322 .entry(account_id.to_owned())
323 .or_default()
324 }
325
326 fn require_account(&self, account_id: &str) -> Result<(), BackendSetError<MemoryError>> {
332 if self.known_accounts.contains(account_id) {
333 Ok(())
334 } else {
335 Err(BackendSetError::Other(MemoryError::new(format!(
336 "unknown account {account_id:?}"
337 ))))
338 }
339 }
340
341 fn require_account_for_target(
344 &self,
345 account_id: &str,
346 ) -> Result<(), BackendSetError<MemoryError>> {
347 if self.known_accounts.contains(account_id) {
348 Ok(())
349 } else {
350 Err(BackendSetError::SetError(Box::new(SetError::new(
351 SetErrorType::NotFound,
352 ))))
353 }
354 }
355
356 fn objects_ref(
357 &self,
358 type_name: &'static str,
359 account_id: &str,
360 ) -> Option<&HashMap<Id, serde_json::Value>> {
361 self.objects.get(type_name).and_then(|m| m.get(account_id))
362 }
363
364 fn change_log_mut(
369 &mut self,
370 type_name: &'static str,
371 account_id: &str,
372 ) -> &mut Vec<ChangeEntry> {
373 let limit = self.change_log_limit;
374 let log = self
375 .change_log
376 .entry(type_name)
377 .or_default()
378 .entry(account_id.to_owned())
379 .or_default();
380 if let Some(limit) = limit
381 && log.len() >= limit
382 {
383 let excess = log.len() + 1 - limit.max(1);
384 let n = excess.min(log.len());
385 let dropped_to = n.checked_sub(1).map(|i| log[i].new_state);
386 log.drain(..n);
387 if let Some(floor) = dropped_to {
388 let slot = self
389 .change_log_floor
390 .entry(type_name)
391 .or_default()
392 .entry(account_id.to_owned())
393 .or_default();
394 *slot = (*slot).max(floor);
395 }
396 }
397 self.change_log
398 .entry(type_name)
399 .or_default()
400 .entry(account_id.to_owned())
401 .or_default()
402 }
403
404 fn push_capped<T>(list: &mut Vec<T>, event: T, limit: Option<usize>) {
406 list.push(event);
407 if let Some(limit) = limit
408 && list.len() > limit
409 {
410 let excess = list.len() - limit;
411 list.drain(..excess);
412 }
413 }
414}
415
416#[non_exhaustive]
434pub struct MemoryBackend<C = Id> {
435 inner: ScopedState<Inner>,
436 caller: PhantomData<fn() -> C>,
437}
438
439impl<C> Clone for MemoryBackend<C> {
447 fn clone(&self) -> Self {
448 Self {
449 inner: self.inner.clone(),
450 caller: PhantomData,
451 }
452 }
453}
454
455impl<C> Default for MemoryBackend<C> {
456 fn default() -> Self {
457 Self {
458 inner: ScopedState::new(Inner {
459 everyone_permissions: HashSet::from([ChatPermission::View, ChatPermission::Send]),
460 ..Inner::default()
461 }),
462 caller: PhantomData,
463 }
464 }
465}
466
467impl MemoryBackend {
468 pub fn new() -> Self {
476 Self::default()
477 }
478}
479
480impl<C: MemoryCaller> MemoryBackend<C> {
481 #[must_use]
510 pub fn with_metadata_info(self, data_type: &str, info: DataTypeMetadataInfo) -> Self {
511 let type_name = metadata_type_name(data_type).unwrap_or_else(|| {
512 panic!(
513 "MemoryBackend supports metadata only on Chat, Message and Space, not {data_type:?}"
514 )
515 });
516 assert!(
517 !info.supports_private,
518 "MemoryBackend does not support privateMetadata (supportsPrivate must be false)"
519 );
520 self.inner
521 .lock_unscoped()
522 .metadata_info
523 .insert(type_name, info);
524 self
525 }
526
527 #[must_use]
543 pub fn with_search_capability(self, capability: jmap_search::SearchCapability) -> Self {
544 self.inner.lock_unscoped().search = Some(capability);
545 self
546 }
547
548 pub fn set_everyone_permissions(&self, permissions: HashSet<ChatPermission>) {
554 self.inner.lock_unscoped().everyone_permissions = permissions;
555 }
556
557 pub fn set_space_everyone_permissions(
561 &self,
562 space_id: &Id,
563 permissions: HashSet<ChatPermission>,
564 ) {
565 self.inner
566 .lock_unscoped()
567 .space_everyone_permissions
568 .insert(space_id.to_string(), permissions);
569 }
570
571 #[doc(hidden)]
583 pub fn register_account(&self, account_id: &Id) {
584 debug_assert!(
585 !account_id.as_ref().is_empty(),
586 "register_account: account_id must not be the empty string \
587 (RFC 8620 §1.2, bd:JMAP-dx0s)"
588 );
589 let mut inner = self.inner.lock_unscoped();
590 inner.known_accounts.insert(account_id.as_ref().to_owned());
591 }
592
593 #[must_use]
602 pub fn with_account(self, account_id: &Id) -> Self {
603 self.register_account(account_id);
604 self
605 }
606
607 pub fn seed_object(
621 &self,
622 account_id: &Id,
623 type_name: &'static str,
624 id: &Id,
625 value: serde_json::Value,
626 ) {
627 const KNOWN_TYPES: &[&str] = &[
628 jmap_chat_types::Chat::TYPE_NAME,
629 jmap_chat_types::Message::TYPE_NAME,
630 jmap_chat_types::Space::TYPE_NAME,
631 jmap_chat_types::ChatContact::TYPE_NAME,
632 jmap_chat_types::ReadPosition::TYPE_NAME,
633 jmap_chat_types::CustomEmoji::TYPE_NAME,
634 jmap_chat_types::SpaceInvite::TYPE_NAME,
635 jmap_chat_types::SpaceBan::TYPE_NAME,
636 jmap_chat_types::ChatBan::TYPE_NAME,
637 jmap_chat_types::PresenceStatus::TYPE_NAME,
638 ];
639 assert!(
640 KNOWN_TYPES.contains(&type_name),
641 "seed_object: type_name {type_name:?} is not one of the known \
642 TYPE_NAME values {KNOWN_TYPES:?}"
643 );
644 let obj = value.as_object().unwrap_or_else(|| {
645 panic!("seed_object: value must be a JSON object with an `id` field, got {value:?}")
646 });
647 let value_id = obj
648 .get("id")
649 .and_then(serde_json::Value::as_str)
650 .unwrap_or_else(|| {
651 panic!(
652 "seed_object: value must contain an `id` string field; got value = {value:?}"
653 )
654 });
655 assert_eq!(
656 value_id,
657 id.as_ref(),
658 "seed_object: value's `id` field {value_id:?} does not match the \
659 `id` argument {id:?}"
660 );
661 let account = account_id.as_ref();
662 let mut inner = self.inner.lock_unscoped();
663
664 inner.known_accounts.insert(account.to_owned());
667 inner
668 .objects_mut(type_name, account)
669 .insert(id.clone(), value);
670 }
671
672 #[doc(hidden)]
695 #[cfg(feature = "test-helpers")]
696 pub fn set_retains_edit_history_for_test(&self, retain: bool) {
697 let mut inner = self.inner.lock_unscoped();
698 inner.retains_edit_history = retain;
699 }
700
701 #[doc(hidden)]
710 #[cfg(feature = "test-helpers")]
711 pub fn set_maintains_unread_count_for_test(&self, value: bool) {
712 let mut inner = self.inner.lock_unscoped();
713 inner.maintains_unread_count = value;
714 }
715
716 #[doc(hidden)]
730 #[cfg(feature = "test-helpers")]
731 pub fn set_protect_last_admin_for_test(&self, value: bool) {
732 let mut inner = self.inner.lock_unscoped();
733 inner.protect_last_admin = value;
734 }
735
736 async fn record_lifecycle_event(&self, event: LifecycleEvent) {
739 let mut inner = self.inner.lock().await;
740 let limit = inner.event_limit;
741 Inner::push_capped(&mut inner.lifecycle_events, event, limit);
742 }
743
744 pub fn mint_id(&self) -> Id {
752 self.inner.lock_unscoped().mint_id()
753 }
754
755 pub async fn insert_object<O: SetObject + Send + Sync>(
770 &self,
771 account_id: &Id,
772 object: O,
773 ) -> Result<O, BackendSetError<MemoryError>> {
774 let val = serde_json::to_value(&object)
775 .map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
776 let id = object_id_of(&val)?;
777 let mut inner = self.inner.lock().await;
778 reject_taken_id(&inner, O::TYPE_NAME, account_id, &id)?;
779 let defer = self.inner.deferring();
780 insert_created(&mut inner, O::TYPE_NAME, account_id, &id, val, defer)?;
781 Ok(object)
782 }
783
784 pub async fn insert_message(
793 &self,
794 account_id: &Id,
795 message: jmap_chat_types::Message,
796 ) -> Result<jmap_chat_types::Message, BackendSetError<MemoryError>> {
797 let val = serde_json::to_value(&message)
798 .map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
799 let id = object_id_of(&val)?;
800 let mut inner = self.inner.lock().await;
801 reject_taken_id(&inner, "Message", account_id, &id)?;
802 let defer = self.inner.deferring();
803 insert_created(&mut inner, "Message", account_id, &id, val, defer)?;
804 let limit = inner.event_limit;
805 Inner::push_capped(
806 &mut inner.outbound_events,
807 crate::OutboundEvent::NewMessage {
808 chat_id: message.chat_id.clone(),
809 message_id: message.id.clone(),
810 sender_msg_id: message.sender_msg_id.clone(),
811 },
812 limit,
813 );
814 Ok(message)
815 }
816
817 #[must_use]
823 pub fn with_change_log_limit(self, limit: usize) -> Self {
824 self.inner.lock_unscoped().change_log_limit = Some(limit);
825 self
826 }
827
828 #[must_use]
834 pub fn with_event_limit(self, limit: usize) -> Self {
835 self.inner.lock_unscoped().event_limit = Some(limit);
836 self
837 }
838
839 pub fn drain_lifecycle_events(&self) -> Vec<LifecycleEvent> {
844 std::mem::take(&mut self.inner.lock_unscoped().lifecycle_events)
845 }
846
847 pub fn drain_outbound_events(&self) -> Vec<crate::OutboundEvent> {
850 std::mem::take(&mut self.inner.lock_unscoped().outbound_events)
851 }
852
853 #[doc(hidden)]
858 #[cfg(feature = "test-helpers")]
859 pub fn take_lifecycle_events_for_test(&self) -> Vec<LifecycleEvent> {
860 std::mem::take(&mut self.inner.lock_unscoped().lifecycle_events)
861 }
862
863 #[doc(hidden)]
866 #[cfg(feature = "test-helpers")]
867 pub fn take_outbound_events_for_test(&self) -> Vec<crate::OutboundEvent> {
868 std::mem::take(&mut self.inner.lock_unscoped().outbound_events)
869 }
870
871 #[doc(hidden)]
877 #[cfg(feature = "test-helpers")]
878 pub fn set_space_extension_properties_for_test(&self, keys: &'static [&'static str]) {
879 let mut inner = self.inner.lock_unscoped();
880 inner.space_extension_properties = keys;
881 }
882
883 #[doc(hidden)]
889 #[cfg(feature = "test-helpers")]
890 pub fn set_owner_user_id_for_test(&self, account_id: &Id, owner_user_id: &str) {
891 let mut inner = self.inner.lock_unscoped();
892 inner
893 .owner_user_ids
894 .insert(account_id.as_ref().to_owned(), owner_user_id.to_owned());
895 }
896
897 #[doc(hidden)]
908 #[cfg(feature = "test-helpers")]
909 pub fn set_chat_push_capability_for_test(
910 &self,
911 account_id: &Id,
912 cap: Option<ChatPushCapability>,
913 ) {
914 let mut inner = self.inner.lock_unscoped();
915 match cap {
916 Some(cap) => inner.chat_push_caps.insert(account_id.clone(), cap),
917 None => inner.chat_push_caps.remove(account_id),
918 };
919 }
920
921 #[doc(hidden)]
932 #[cfg(feature = "test-helpers")]
933 pub fn set_limits_for_test(&self, limits: Option<ChatLimits>) {
934 let mut inner = self.inner.lock_unscoped();
935 inner.limits_override = limits;
936 }
937
938 #[doc(hidden)]
945 #[cfg(feature = "test-helpers")]
946 pub fn set_attachment_blob_for_test(
947 &self,
948 account_id: &str,
949 blob_id: &str,
950 blob: Option<AttachmentBlob>,
951 ) {
952 let mut inner = self.inner.lock_unscoped();
953 let key = (account_id.to_owned(), Id::from(blob_id));
954 match blob {
955 Some(b) => inner.attachment_blobs.insert(key, b),
956 None => inner.attachment_blobs.remove(&key),
957 };
958 }
959
960 #[doc(hidden)]
970 #[cfg(feature = "test-helpers")]
971 pub fn insert_object_for_test(
972 &self,
973 type_name: &'static str,
974 account_id: &str,
975 id: &str,
976 value: serde_json::Value,
977 ) {
978 let mut inner = self.inner.lock_unscoped();
979 inner.known_accounts.insert(account_id.to_owned());
982 inner
983 .objects_mut(type_name, account_id)
984 .insert(Id::from(id), value);
985 }
986
987 #[doc(hidden)]
995 pub fn first_category_id(&self, space_id: &Id) -> Id {
996 let inner = self.inner.lock_unscoped();
997 for map in inner
1000 .objects
1001 .get("Space")
1002 .into_iter()
1003 .flat_map(HashMap::values)
1004 {
1005 if let Some(space) = map.get(space_id) {
1006 let cats = space
1007 .get("categories")
1008 .and_then(|v| v.as_array())
1009 .expect("Space.categories must be an array");
1010 let id = cats
1011 .first()
1012 .and_then(|c| c.get("id"))
1013 .and_then(|id| id.as_str())
1014 .expect("Space has at least one category");
1015 return Id::from(id);
1016 }
1017 }
1018 panic!("Space {space_id} not found");
1019 }
1020
1021 #[doc(hidden)]
1029 pub fn peek_chat(&self, chat_id: &Id) -> serde_json::Value {
1030 let inner = self.inner.lock_unscoped();
1031 for map in inner
1032 .objects
1033 .get("Chat")
1034 .into_iter()
1035 .flat_map(HashMap::values)
1036 {
1037 if let Some(chat) = map.get(chat_id) {
1038 return chat.clone();
1039 }
1040 }
1041 panic!("Chat {chat_id} not found");
1042 }
1043}
1044
1045#[non_exhaustive]
1062#[derive(Debug)]
1063pub struct MemoryError {
1064 description: String,
1065}
1066
1067impl MemoryError {
1068 pub fn new(description: impl Into<String>) -> Self {
1070 Self {
1071 description: description.into(),
1072 }
1073 }
1074
1075 pub fn description(&self) -> &str {
1077 &self.description
1078 }
1079
1080 pub(crate) fn serde(context: impl std::fmt::Display, e: &serde_json::Error) -> Self {
1089 Self::new(format!("{context}: serde_json {:?} error", e.classify()))
1090 }
1091}
1092
1093impl std::fmt::Display for MemoryError {
1094 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1095 write!(f, "MemoryBackend error: {}", self.description)
1096 }
1097}
1098
1099impl std::error::Error for MemoryError {}
1100
1101impl<C: MemoryCaller> JmapAccounts for MemoryBackend<C> {
1102 type Error = MemoryError;
1103 type CallerCtx = C;
1104
1105 fn principal_id(caller: &C) -> Option<&Id> {
1107 caller.principal()
1108 }
1109
1110 fn metadata_info<O: JmapObject>(
1113 &self,
1114 _caller: &C,
1115 _account_id: &Id,
1116 ) -> Option<DataTypeMetadataInfo> {
1117 self.inner
1118 .lock_unscoped()
1119 .metadata_info
1120 .get(O::TYPE_NAME)
1121 .cloned()
1122 }
1123
1124 async fn account_exists(&self, _caller: &C, account_id: &Id) -> Result<bool, Self::Error> {
1125 let inner = self.inner.lock().await;
1126 Ok(inner.known_accounts.contains(account_id.as_ref()))
1127 }
1128}
1129
1130impl<C: MemoryCaller> JmapReads for MemoryBackend<C> {
1131 async fn get_objects<O: GetObject + Send + Sync>(
1132 &self,
1133 _caller: &C,
1134 account_id: &Id,
1135 ids: Option<&[Id]>,
1136 _properties: Option<&[String]>,
1137 ) -> Result<(Vec<O>, Vec<Id>), Self::Error> {
1138 let inner = self.inner.lock().await;
1139 let map = inner.objects_ref(O::TYPE_NAME, account_id.as_ref());
1140
1141 match ids {
1142 None => {
1143 let mut list = Vec::new();
1145 if let Some(m) = map {
1146 for val in m.values() {
1147 match O::deserialize(val) {
1148 Ok(obj) => list.push(obj),
1149 Err(e) => {
1150 return Err(MemoryError::serde(
1151 format_args!("deserialize {}", O::TYPE_NAME),
1152 &e,
1153 ));
1154 }
1155 }
1156 }
1157 }
1158 Ok((list, vec![]))
1159 }
1160 Some(id_slice) => {
1161 let mut found = Vec::new();
1162 let mut not_found = Vec::new();
1163 for id in id_slice {
1164 match map.and_then(|m| m.get(id)) {
1165 Some(val) => match O::deserialize(val) {
1166 Ok(obj) => found.push(obj),
1167 Err(e) => {
1168 return Err(MemoryError::serde(
1169 format_args!("deserialize {}", O::TYPE_NAME),
1170 &e,
1171 ));
1172 }
1173 },
1174 None => not_found.push(id.clone()),
1175 }
1176 }
1177 Ok((found, not_found))
1178 }
1179 }
1180 }
1181
1182 async fn get_state<O: JmapObject + Send + Sync>(
1183 &self,
1184 _caller: &C,
1185 account_id: &Id,
1186 ) -> Result<State, Self::Error> {
1187 let inner = self.inner.lock().await;
1188 let n = inner.current_state(O::TYPE_NAME, account_id.as_ref());
1189 Ok(State::from(n.to_string()))
1190 }
1191
1192 async fn get_changes<O: JmapObject + Send + Sync>(
1193 &self,
1194 _caller: &C,
1195 account_id: &Id,
1196 params: jmap_server::ChangesParams<'_>,
1197 ) -> Result<ChangesResult, BackendChangesError<Self::Error>> {
1198 let since_state = params.since_state;
1199 let max_changes = params.max_changes;
1200 let mode = if params.ignore_metadata_only_changes {
1203 MetadataOnlyChanges::Ignore
1204 } else {
1205 MetadataOnlyChanges::Report
1206 };
1207 let inner = self.inner.lock().await;
1208
1209 let since_n: u64 = since_state
1210 .as_ref()
1211 .parse()
1212 .map_err(|_| BackendChangesError::CannotCalculate)?;
1213 if inner
1216 .change_log_floor
1217 .get(O::TYPE_NAME)
1218 .and_then(|m| m.get(account_id.as_ref()))
1219 .is_some_and(|&floor| since_n < floor)
1220 {
1221 return Err(BackendChangesError::CannotCalculate);
1222 }
1223
1224 let log = inner
1225 .change_log
1226 .get(O::TYPE_NAME)
1227 .and_then(|m| m.get(account_id.as_ref()))
1228 .map(Vec::as_slice)
1229 .unwrap_or(&[]);
1230
1231 let mut relevant: Vec<&ChangeEntry> =
1233 log.iter().filter(|e| e.new_state > since_n).collect();
1234
1235 let current_state = inner.current_state(O::TYPE_NAME, account_id.as_ref());
1236
1237 let mut has_more = false;
1246 if let Some(max) = max_changes {
1247 let mut ids = 0u64;
1248 if let Some(cut) = relevant.iter().position(|e| {
1249 if !(mode == MetadataOnlyChanges::Ignore && e.is_metadata_only_update()) {
1250 ids +=
1251 (e.created.len() + e.updated.len() + e.destroyed.len() + e.restored.len())
1252 as u64;
1253 }
1254 ids > max
1255 }) {
1256 if cut == 0 {
1257 return Err(BackendChangesError::TooManyChanges { limit: max });
1258 }
1259 relevant.truncate(cut);
1260 has_more = true;
1261 }
1262 }
1263 let new_state = match relevant.last() {
1264 Some(e) if has_more => e.new_state,
1265 _ => current_state,
1266 };
1267
1268 let (created, updated, destroyed, window_props) =
1269 window_changes(&relevant, O::TYPE_NAME, mode);
1270
1271 let updated_properties = window_props.updated_properties(&updated, mode, &[]);
1274 Ok(ChangesResult::new(
1275 created,
1276 updated,
1277 destroyed,
1278 has_more,
1279 State::from(new_state.to_string()),
1280 )
1281 .with_updated_properties(updated_properties))
1282 }
1283
1284 async fn query_objects<O: QueryObject + Send + Sync>(
1285 &self,
1286 _caller: &C,
1287 account_id: &Id,
1288 params: QueryParams<'_, O>,
1289 ) -> Result<QueryResult, BackendQueryError<Self::Error>> {
1290 let QueryParams {
1291 filter,
1292 sort,
1293 limit,
1294 position,
1295 anchor,
1296 anchor_offset,
1297 ..
1298 } = params;
1299 let inner = self.inner.lock().await;
1300
1301 let filter_val: Option<serde_json::Value> =
1305 filter.and_then(|f| serde_json::to_value(f).ok());
1306 let sort_val: Option<serde_json::Value> = sort.and_then(|s| serde_json::to_value(s).ok());
1307 if let Some(fv) = &filter_val {
1308 check_metadata_filter(fv, inner.metadata_info.get(O::TYPE_NAME))?;
1309 check_where(fv, O::TYPE_NAME, inner.search.as_ref())?;
1310 }
1311
1312 let mut ids: Vec<Id> = inner
1313 .objects_ref(O::TYPE_NAME, account_id.as_ref())
1314 .map(|m| {
1315 let mut keys: Vec<Id> = m.keys().cloned().collect();
1316
1317 if let Some(ref fv) = filter_val {
1320 keys.retain(|id| filter_matches(&inner, O::TYPE_NAME, &m[id], fv, account_id));
1321 }
1322
1323 if O::TYPE_NAME == "Message" {
1324 keys.retain(|id| message_listed(&inner, m.get(id), account_id));
1328 }
1329
1330 if O::TYPE_NAME == "Space" {
1340 let want_public = filter_val.as_ref().is_some_and(has_is_public_true);
1341 keys.retain(|id| space_listed(&m[id], account_id, want_public));
1342 }
1343
1344 keys.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
1345 if let Some(comparators) = sort_val.as_ref().and_then(|v| v.as_array()) {
1348 keys.sort_by(|a, b| compare_by_sort(&m[a], &m[b], comparators));
1349 }
1350 keys
1351 })
1352 .unwrap_or_default();
1353
1354 let total = ids.len() as u64;
1355 let query_state = State::from(
1356 inner
1357 .current_state(O::TYPE_NAME, account_id.as_ref())
1358 .to_string(),
1359 );
1360
1361 let start = resolve_query_start(&ids, position, anchor, anchor_offset)
1363 .map_err(BackendQueryError::Method)?;
1364
1365 ids = ids[start..]
1366 .iter()
1367 .take(limit_or_max(limit))
1368 .cloned()
1369 .collect();
1370
1371 Ok(QueryResult::new(
1372 ids,
1373 start as u64,
1374 Some(total),
1375 query_state,
1376 true,
1377 ))
1378 }
1379
1380 async fn query_changes<O: QueryObject + Send + Sync>(
1395 &self,
1396 caller: &C,
1397 account_id: &Id,
1398 params: QueryChangesParams<'_, O>,
1399 ) -> Result<QueryChangesResult, BackendChangesError<Self::Error>> {
1400 let QueryChangesParams {
1401 since_query_state,
1402 filter,
1403 sort,
1404 max_changes,
1405 ..
1406 } = params;
1407 let changes = self
1408 .get_changes::<O>(
1409 caller,
1410 account_id,
1411 jmap_server::ChangesParams::new(since_query_state).max_changes(max_changes),
1412 )
1413 .await?;
1414
1415 let current = self
1418 .query_objects::<O>(
1419 caller,
1420 account_id,
1421 QueryParams::new().filter(filter).sort(sort),
1422 )
1423 .await
1424 .map_err(|e| match e {
1425 BackendQueryError::Other(e) => BackendChangesError::Other(e),
1426 _ => BackendChangesError::CannotCalculate,
1430 })?;
1431 let created_set: HashSet<&Id> = changes.created.iter().collect();
1432 let updated_set: HashSet<&Id> = changes.updated.iter().collect();
1433
1434 let mut removed: Vec<Id> = changes
1438 .destroyed
1439 .iter()
1440 .chain(changes.updated.iter())
1441 .cloned()
1442 .collect();
1443 removed.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
1444 removed.dedup();
1445
1446 let added: Vec<AddedItem> = current
1448 .ids
1449 .iter()
1450 .enumerate()
1451 .filter(|(_, id)| created_set.contains(id) || updated_set.contains(id))
1452 .map(|(pos, id)| AddedItem::new(id.clone(), pos as u64))
1453 .collect();
1454
1455 Ok(QueryChangesResult::new(
1456 since_query_state.clone(),
1457 changes.new_state,
1458 current.total,
1459 removed,
1460 added,
1461 ))
1462 }
1463}
1464
1465impl<C: MemoryCaller> ChatStore for MemoryBackend<C> {
1466 async fn create_object<O, F>(
1467 &self,
1468 _caller: &C,
1469 account_id: &Id,
1470 _create_id: &str,
1471 build: F,
1472 ) -> Result<(Id, O), BackendSetError<Self::Error>>
1473 where
1474 O: SetObject + Send + Sync,
1475 F: FnOnce(&Id) -> O + Send,
1476 {
1477 let server_id = self.inner.lock().await.mint_id();
1478 let stored_obj = build(&server_id);
1479 let val = serde_json::to_value(&stored_obj)
1480 .map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
1481
1482 let mut inner = self.inner.lock().await;
1483 let defer = self.inner.deferring();
1484 insert_created(&mut inner, O::TYPE_NAME, account_id, &server_id, val, defer)?;
1485 Ok((server_id, stored_obj))
1486 }
1487
1488 async fn create_message<F>(
1493 &self,
1494 _caller: &C,
1495 account_id: &Id,
1496 _create_id: &str,
1497 build: F,
1498 ) -> Result<(Id, jmap_chat_types::Message), BackendSetError<Self::Error>>
1499 where
1500 F: FnOnce(&Id) -> jmap_chat_types::Message + Send,
1501 {
1502 let mut inner = self.inner.lock().await;
1503 let server_id = inner.mint_id();
1504 let message = build(&server_id);
1505 let val = serde_json::to_value(&message)
1506 .map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
1507 let defer = self.inner.deferring();
1508 insert_created(&mut inner, "Message", account_id, &server_id, val, defer)?;
1509 let limit = inner.event_limit;
1510 Inner::push_capped(
1511 &mut inner.outbound_events,
1512 crate::OutboundEvent::NewMessage {
1513 chat_id: message.chat_id.clone(),
1514 message_id: message.id.clone(),
1515 sender_msg_id: message.sender_msg_id.clone(),
1516 },
1517 limit,
1518 );
1519 Ok((server_id, message))
1520 }
1521
1522 async fn update_object<O: SetObject + Send + Sync>(
1523 &self,
1524 _caller: &C,
1525 account_id: &Id,
1526 id: &Id,
1527 patch: O::Patch,
1528 ) -> Result<Option<O>, BackendSetError<Self::Error>> {
1529 let mut inner = self.inner.lock().await;
1530 inner.require_account_for_target(account_id.as_ref())?;
1531 let (current, changed) = patched_copy::<O>(&mut inner, account_id.as_ref(), id, &patch)?;
1532
1533 if O::TYPE_NAME == "CustomEmoji"
1535 && !self.inner.deferring()
1536 && emoji_name_holder(&inner, account_id, ¤t, Some(id)).is_some()
1537 {
1538 return Err(BackendSetError::SetError(Box::new(
1539 SetError::new(SetErrorType::InvalidProperties).with_properties(["name"]),
1540 )));
1541 }
1542 if O::TYPE_NAME == "CustomEmoji" {
1546 let stored_blob = inner
1547 .objects_ref(O::TYPE_NAME, account_id.as_ref())
1548 .and_then(|m| m.get(id))
1549 .and_then(|e| e.get("blobId"));
1550 let limits = inner.limits_override.unwrap_or_default();
1551 if current.get("blobId") != stored_blob
1552 && emoji_blob_over_cap(&inner, account_id, ¤t, &limits)
1553 {
1554 return Err(over_quota_error(crate::emoji::EMOJI_TOO_LARGE));
1555 }
1556 }
1557
1558 let unread_changed = if O::TYPE_NAME == "ReadPosition" {
1559 let old = inner
1560 .objects_ref(O::TYPE_NAME, account_id.as_ref())
1561 .and_then(|m| m.get(id))
1562 .cloned()
1563 .unwrap_or_default();
1564 roots_with_unread_change(&inner, account_id.as_ref(), &old, ¤t)
1565 } else {
1566 Vec::new()
1567 };
1568 let previous = inner
1572 .objects_ref(O::TYPE_NAME, account_id.as_ref())
1573 .and_then(|m| m.get(id))
1574 .cloned();
1575 if O::TYPE_NAME == "Message" && current.get("deletedAt").is_some_and(|v| !v.is_null()) {
1576 inner.purge_message_history(account_id, id);
1577 } else if let (Some(h), Some(previous)) = (inner.history.as_mut(), previous) {
1578 h.record_replace(O::TYPE_NAME, account_id, id, previous);
1579 }
1580 let new_state = inner.bump_state(O::TYPE_NAME, account_id.as_ref());
1581 inner
1582 .objects_mut(O::TYPE_NAME, account_id.as_ref())
1583 .insert(id.clone(), current);
1584 inner
1585 .change_log_mut(O::TYPE_NAME, account_id.as_ref())
1586 .push(ChangeEntry {
1587 new_state,
1588 created: vec![],
1589 updated: vec![id.clone()],
1590 destroyed: vec![],
1591 restored: vec![],
1592 updated_props: Some(changed),
1593 });
1594 record_thread_count_changes(&mut inner, account_id.as_ref(), unread_changed);
1595
1596 Ok(None)
1597 }
1598
1599 async fn destroy_object<O: SetObject + Send + Sync>(
1600 &self,
1601 _caller: &C,
1602 account_id: &Id,
1603 id: &Id,
1604 ) -> Result<(), BackendSetError<Self::Error>> {
1605 let mut inner = self.inner.lock().await;
1606 inner.require_account_for_target(account_id.as_ref())?;
1607
1608 if O::TYPE_NAME == "Space"
1613 && let Some(space_val) = inner
1614 .objects_ref("Space", account_id.as_ref())
1615 .and_then(|m| m.get(id))
1616 {
1617 let caller_perms =
1618 caller_effective_permissions(space_val, account_id, inner.everyone_in(space_val))
1619 .unwrap_or_default();
1620 if !caller_perms.contains(&ChatPermission::ManageSpace) {
1621 return Err(BackendSetError::SetError(Box::new(
1622 SetError::new(SetErrorType::Forbidden).with_description(
1623 "caller lacks required permission `manage_space` to destroy the Space",
1624 ),
1625 )));
1626 }
1627 }
1628
1629 let space_chats: Vec<Id> = if O::TYPE_NAME == "Space" {
1631 inner
1632 .objects_ref("Chat", account_id.as_ref())
1633 .map(|chats| {
1634 chats
1635 .iter()
1636 .filter(|(_, c)| {
1637 c.get("spaceId").and_then(|v| v.as_str()) == Some(id.as_ref())
1638 })
1639 .map(|(k, _)| k.clone())
1640 .collect()
1641 })
1642 .unwrap_or_default()
1643 } else {
1644 Vec::new()
1645 };
1646 let removed = if O::TYPE_NAME == "Message" {
1647 hard_delete_message(&mut inner, account_id.as_ref(), id)
1649 } else {
1650 let last = inner
1651 .objects_mut(O::TYPE_NAME, account_id.as_ref())
1652 .remove(id);
1653 if let Some(last) = &last
1654 && O::TYPE_NAME != "Space"
1655 && let Some(h) = inner.history.as_mut()
1656 {
1657 h.record_destroy(O::TYPE_NAME, account_id, id, last.clone());
1658 }
1659 last.is_some()
1660 };
1661
1662 if !removed {
1663 return Err(BackendSetError::SetError(Box::new(SetError::new(
1664 SetErrorType::NotFound,
1665 ))));
1666 }
1667 let new_state = inner.bump_state(O::TYPE_NAME, account_id.as_ref());
1668 inner
1669 .change_log_mut(O::TYPE_NAME, account_id.as_ref())
1670 .push(ChangeEntry {
1671 new_state,
1672 created: vec![],
1673 updated: vec![],
1674 destroyed: vec![id.clone()],
1675 restored: vec![],
1676 updated_props: None,
1677 });
1678 if O::TYPE_NAME == "Space" {
1679 destroy_space_channels(&mut inner, account_id.as_ref(), id);
1680 inner.purge_space_history(account_id, id, &space_chats);
1681 }
1682 if O::TYPE_NAME == "Chat" {
1683 destroy_read_positions(&mut inner, account_id.as_ref(), std::slice::from_ref(id));
1684 }
1685 Ok(())
1686 }
1687
1688 fn supports_type<O: JmapObject>(&self, _caller: &C, _account_id: &jmap_types::Id) -> bool {
1689 true
1690 }
1691}
1692
1693impl<C: MemoryCaller> ChatSpaces for MemoryBackend<C> {
1694 async fn generate_invite_code(
1695 &self,
1696 _caller: &C,
1697 _account_id: &Id,
1698 ) -> Result<String, MemoryError> {
1699 let mut bytes = [0u8; 16];
1713 getrandom::fill(&mut bytes)
1714 .map_err(|e| MemoryError::new(format!("OS CSPRNG unavailable: {e}")))?;
1715 let mut out = String::with_capacity(bytes.len() * 2);
1717 for byte in bytes {
1718 use std::fmt::Write as _;
1720 let _ = write!(out, "{byte:02x}");
1721 }
1722 Ok(out)
1723 }
1724
1725 async fn join_space_with_invite(
1732 &self,
1733 _caller: &C,
1734 account_id: &Id,
1735 invite_id: &Id,
1736 joined_at: &jmap_types::UTCDate,
1737 ) -> Result<Result<(), InviteJoinRefusal>, Self::Error> {
1738 let mut inner = self.inner.lock().await;
1739 let acct = account_id.as_ref();
1740
1741 let Some(stored) = inner
1742 .objects_ref("SpaceInvite", acct)
1743 .and_then(|m| m.get(invite_id))
1744 else {
1745 return Ok(Err(InviteJoinRefusal::NotFound));
1746 };
1747 let invite: jmap_chat_types::SpaceInvite = serde_json::from_value(stored.clone())
1748 .map_err(|e| MemoryError::serde("stored SpaceInvite", &e))?;
1749 if invite.max_uses.is_some_and(|max| invite.uses >= max) {
1750 return Ok(Err(InviteJoinRefusal::Exhausted));
1751 }
1752
1753 let Some(space) = inner
1754 .objects_mut("Space", acct)
1755 .get_mut(&invite.space_id)
1756 .and_then(serde_json::Value::as_object_mut)
1757 else {
1758 return Ok(Err(InviteJoinRefusal::NotFound));
1759 };
1760 let Some(members) = space
1761 .entry("members")
1762 .or_insert_with(|| serde_json::json!([]))
1763 .as_array_mut()
1764 else {
1765 return Err(MemoryError::new("stored Space members is not an array"));
1766 };
1767 if members
1768 .iter()
1769 .any(|m| m.get("id").and_then(|v| v.as_str()) == Some(acct))
1770 {
1771 return Ok(Err(InviteJoinRefusal::AlreadyMember));
1772 }
1773 members.push(serde_json::json!({
1774 "id": acct,
1775 "roleIds": [],
1776 "joinedAt": joined_at,
1777 }));
1778 if let Some(stored) = inner
1779 .objects_mut("SpaceInvite", acct)
1780 .get_mut(invite_id)
1781 .and_then(serde_json::Value::as_object_mut)
1782 {
1783 stored.insert(
1784 "uses".to_owned(),
1785 serde_json::json!(invite.uses.saturating_add(1)),
1786 );
1787 }
1788
1789 for (type_name, id) in [("Space", &invite.space_id), ("SpaceInvite", invite_id)] {
1790 let new_state = inner.bump_state(type_name, acct);
1791 inner.change_log_mut(type_name, acct).push(ChangeEntry {
1792 new_state,
1793 created: vec![],
1794 updated: vec![id.clone()],
1795 destroyed: vec![],
1796 restored: vec![],
1797 updated_props: None,
1798 });
1799 }
1800 Ok(Ok(()))
1801 }
1802
1803 fn protect_last_admin(&self, _caller: &C, _account_id: &Id) -> bool {
1813 let inner = self.inner.lock_unscoped();
1814 inner.protect_last_admin
1815 }
1816
1817 fn space_extension_properties(&self, _caller: &C, _account_id: &Id) -> &'static [&'static str] {
1822 let inner = self.inner.lock_unscoped();
1823 inner.space_extension_properties
1824 }
1825
1826 async fn apply_space_patch(
1872 &self,
1873 _caller: &C,
1874 account_id: &Id,
1875 space_id: &Id,
1876 ops: Vec<SpacePatchOp>,
1877 ) -> Result<Vec<OpResult>, BackendSetError<Self::Error>> {
1878 let mut inner = self.inner.lock().await;
1879 apply_space_patch_impl(&mut inner, account_id, space_id, ops)
1880 }
1881
1882 async fn apply_space_metadata_patch(
1893 &self,
1894 _caller: &C,
1895 account_id: &Id,
1896 space_id: &Id,
1897 patch: jmap_chat_types::SpaceMetadataPatch,
1898 ) -> Result<Option<jmap_chat_types::Space>, BackendSetError<Self::Error>> {
1899 let patch_map = space_metadata_patch_to_map(patch).map_err(BackendSetError::Other)?;
1900 let mut inner = self.inner.lock().await;
1901 apply_space_metadata_patch_impl(&mut inner, account_id, space_id, patch_map)
1902 }
1903
1904 async fn everyone_permissions(
1907 &self,
1908 _caller: &C,
1909 _account_id: &Id,
1910 space: &jmap_chat_types::Space,
1911 ) -> Result<HashSet<ChatPermission>, Self::Error> {
1912 Ok(self
1913 .inner
1914 .lock()
1915 .await
1916 .everyone_for(space.id.as_ref())
1917 .clone())
1918 }
1919}
1920
1921impl<C: MemoryCaller> SpacePolicy for MemoryBackend<C> {
1922 async fn may_set_custom_emoji(
1935 &self,
1936 _caller: &C,
1937 _account_id: &Id,
1938 _target_space_id: Option<&Id>,
1939 _op: EmojiSetOp,
1940 ) -> Result<Result<(), SetError>, Self::Error> {
1941 Ok(Ok(()))
1942 }
1943
1944 async fn may_set_space_ban(
1951 &self,
1952 _caller: &C,
1953 account_id: &Id,
1954 space_id: &Id,
1955 ) -> Result<Result<(), SetError>, Self::Error> {
1956 let inner = self.inner.lock().await;
1957 let Some(space) = inner
1958 .objects_ref("Space", account_id.as_ref())
1959 .and_then(|m| m.get(space_id))
1960 else {
1961 return Ok(Ok(()));
1962 };
1963 Ok(
1964 if caller_effective_permissions(space, account_id, inner.everyone_in(space))
1965 .is_some_and(|perms| perms.contains(&ChatPermission::Ban))
1966 {
1967 Ok(())
1968 } else {
1969 Err(SetError::new(SetErrorType::Forbidden)
1970 .with_description("caller lacks required permission `ban` in this Space"))
1971 },
1972 )
1973 }
1974
1975 async fn may_set_space_invite(
1983 &self,
1984 _caller: &C,
1985 account_id: &Id,
1986 space_id: &Id,
1987 created_by: Option<&Id>,
1988 ) -> Result<Result<(), SetError>, Self::Error> {
1989 if created_by == Some(account_id) {
1990 return Ok(Ok(()));
1991 }
1992 let inner = self.inner.lock().await;
1993 let Some(space) = inner
1994 .objects_ref("Space", account_id.as_ref())
1995 .and_then(|m| m.get(space_id))
1996 else {
1997 return Ok(Ok(()));
1998 };
1999 Ok(
2000 if caller_effective_permissions(space, account_id, inner.everyone_in(space))
2001 .is_some_and(|perms| perms.contains(&ChatPermission::ManageMembers))
2002 {
2003 Ok(())
2004 } else {
2005 Err(SetError::new(SetErrorType::Forbidden).with_description(
2006 "caller lacks required permission `manage_members` in this Space",
2007 ))
2008 },
2009 )
2010 }
2011
2012 async fn may_get_space_invite(
2022 &self,
2023 _caller: &C,
2024 account_id: &Id,
2025 invite: &jmap_chat_types::SpaceInvite,
2026 ) -> Result<bool, Self::Error> {
2027 let inner = self.inner.lock().await;
2028 let Some(space) = inner
2029 .objects_ref("Space", account_id.as_ref())
2030 .and_then(|m| m.get(&invite.space_id))
2031 else {
2032 return Ok(true);
2033 };
2034 Ok(
2035 caller_effective_permissions(space, account_id, inner.everyone_in(space)).is_some_and(
2036 |p| p.contains(&ChatPermission::ManageMembers) || invite.created_by == *account_id,
2037 ),
2038 )
2039 }
2040
2041 async fn may_get_space_ban(
2049 &self,
2050 _caller: &C,
2051 account_id: &Id,
2052 ban: &jmap_chat_types::SpaceBan,
2053 ) -> Result<bool, Self::Error> {
2054 if ban.user_id == *account_id {
2055 return Ok(true);
2056 }
2057 let inner = self.inner.lock().await;
2058 let Some(space) = inner
2059 .objects_ref("Space", account_id.as_ref())
2060 .and_then(|m| m.get(&ban.space_id))
2061 else {
2062 return Ok(true);
2063 };
2064 Ok(
2065 caller_effective_permissions(space, account_id, inner.everyone_in(space))
2066 .is_some_and(|p| p.contains(&ChatPermission::Ban)),
2067 )
2068 }
2069}
2070
2071impl<C: MemoryCaller> ChatAccessPolicy for MemoryBackend<C> {
2072 async fn may_broadcast_mention(
2082 &self,
2083 _caller: &C,
2084 account_id: &Id,
2085 space_id: &Id,
2086 chat_id: &Id,
2087 ) -> Result<Result<(), SetError>, Self::Error> {
2088 let inner = self.inner.lock().await;
2089 let space_exists = inner
2090 .objects_ref("Space", account_id.as_ref())
2091 .is_some_and(|m| m.contains_key(space_id));
2092 let Some(chat) = inner
2093 .objects_ref("Chat", account_id.as_ref())
2094 .and_then(|m| m.get(chat_id))
2095 .filter(|_| space_exists)
2096 else {
2097 return Ok(Ok(()));
2098 };
2099 Ok(
2100 if owner_channel_permissions(&inner, account_id, chat)
2101 .is_some_and(|perms| perms.contains(&ChatPermission::MentionBroadcast))
2102 {
2103 Ok(())
2104 } else {
2105 Err(SetError::new(SetErrorType::Forbidden).with_description(
2106 "caller lacks required permission `mention_broadcast` in this channel",
2107 ))
2108 },
2109 )
2110 }
2111
2112 async fn may_send_message(
2122 &self,
2123 _caller: &C,
2124 account_id: &Id,
2125 chat_id: &Id,
2126 ) -> Result<Result<(), SetError>, Self::Error> {
2127 let inner = self.inner.lock().await;
2128 let Some(chat) = inner
2129 .objects_ref("Chat", account_id.as_ref())
2130 .and_then(|m| m.get(chat_id))
2131 else {
2132 return Ok(Ok(()));
2133 };
2134 let denied = match chat.get("kind").and_then(|v| v.as_str()) {
2135 Some("group") => {
2136 let is_member =
2137 chat.get("members")
2138 .and_then(|v| v.as_array())
2139 .is_some_and(|members| {
2140 members.iter().any(|m| {
2141 m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref())
2142 })
2143 });
2144 (!is_member).then_some("sender is not a member of this Chat")
2145 }
2146 Some("channel") => match owner_channel_permissions(&inner, account_id, chat) {
2147 None => Some("sender is not a member of the containing Space"),
2148 Some(perms) if !perms.contains(&ChatPermission::Send) => {
2149 Some("sender lacks required permission `send` in this channel")
2150 }
2151 Some(_) => None,
2152 },
2153 _ => None,
2154 };
2155 Ok(match denied {
2156 Some(desc) => Err(SetError::new(SetErrorType::Forbidden).with_description(desc)),
2157 None => Ok(()),
2158 })
2159 }
2160
2161 async fn may_view_chat(
2168 &self,
2169 _caller: &C,
2170 account_id: &Id,
2171 chat_id: &Id,
2172 ) -> Result<bool, Self::Error> {
2173 let inner = self.inner.lock().await;
2174 Ok(owner_may_view_chat(&inner, account_id, chat_id))
2175 }
2176
2177 async fn may_set_pinned_messages(
2191 &self,
2192 _caller: &C,
2193 account_id: &Id,
2194 chat_id: &Id,
2195 ) -> Result<Result<(), SetError>, Self::Error> {
2196 let inner = self.inner.lock().await;
2197 let Some(chat) = inner
2198 .objects_ref("Chat", account_id.as_ref())
2199 .and_then(|m| m.get(chat_id))
2200 else {
2201 return Ok(Ok(()));
2202 };
2203 let denied = match chat.get("kind").and_then(|v| v.as_str()) {
2204 Some("direct") => None,
2205 Some("group") => (!is_group_admin(chat, account_id))
2206 .then_some("only group chat admins may modify pinnedMessageIds"),
2207 Some("channel") => {
2208 let has_pin = owner_channel_permissions(&inner, account_id, chat)
2209 .is_some_and(|perms| perms.contains(&ChatPermission::Pin));
2210 (!has_pin).then_some("caller lacks required permission `pin` in this channel")
2211 }
2212 _ => Some("internal: Chat has no recognized kind"),
2213 };
2214 Ok(match denied {
2215 Some(desc) => Err(SetError::new(SetErrorType::Forbidden).with_description(desc)),
2216 None => Ok(()),
2217 })
2218 }
2219
2220 async fn slow_mode_check(
2234 &self,
2235 _caller: &C,
2236 _account_id: &Id,
2237 _chat_id: &Id,
2238 ) -> Result<(), SlowModeError> {
2239 Ok(())
2240 }
2241}
2242
2243impl<C: MemoryCaller> ChatRestrictions for MemoryBackend<C> {}
2244
2245impl<C: MemoryCaller> ChatModeration for MemoryBackend<C> {}
2246
2247impl<C: MemoryCaller> ChatMessageLifecycle for MemoryBackend<C> {
2248 async fn expire_message(
2260 &self,
2261 _caller: &C,
2262 account_id: &Id,
2263 message_id: &Id,
2264 ) -> Result<(), Self::Error> {
2265 let mut inner = self.inner.lock().await;
2266
2267 if hard_delete_message(&mut inner, account_id.as_ref(), message_id) {
2268 let new_state = inner.bump_state("Message", account_id.as_ref());
2269 inner
2270 .change_log_mut("Message", account_id.as_ref())
2271 .push(ChangeEntry {
2272 new_state,
2273 created: vec![],
2274 updated: vec![],
2275 destroyed: vec![message_id.clone()],
2276 restored: vec![],
2277 updated_props: None,
2278 });
2279 }
2280 Ok(())
2281 }
2282
2283 async fn read_and_burn_message(
2291 &self,
2292 _caller: &C,
2293 account_id: &Id,
2294 message_id: &Id,
2295 patch: jmap_types::PatchObject,
2296 ) -> Result<(), BackendSetError<Self::Error>> {
2297 let mut inner = self.inner.lock().await;
2298 let acct = account_id.as_ref();
2299 patched_copy::<jmap_chat_types::Message>(&mut inner, acct, message_id, &patch)?;
2300 hard_delete_message(&mut inner, acct, message_id);
2301 let new_state = inner.bump_state("Message", acct);
2302 inner.change_log_mut("Message", acct).push(ChangeEntry {
2303 new_state,
2304 created: vec![],
2305 updated: vec![],
2306 destroyed: vec![message_id.clone()],
2307 restored: vec![],
2308 updated_props: None,
2309 });
2310 Ok(())
2311 }
2312}
2313
2314impl<C: MemoryCaller> ChatEvents for MemoryBackend<C> {
2315 fn on_chat_destroyed(
2318 &self,
2319 _caller: &C,
2320 _account_id: &Id,
2321 chat_id: &Id,
2322 ) -> impl std::future::Future<Output = ()> + Send {
2323 self.record_lifecycle_event(LifecycleEvent::ChatDestroyed(chat_id.clone()))
2324 }
2325
2326 fn on_space_destroyed(
2329 &self,
2330 _caller: &C,
2331 _account_id: &Id,
2332 space_id: &Id,
2333 ) -> impl std::future::Future<Output = ()> + Send {
2334 self.record_lifecycle_event(LifecycleEvent::SpaceDestroyed(space_id.clone()))
2335 }
2336
2337 fn on_space_ban_created(
2340 &self,
2341 _caller: &C,
2342 _account_id: &Id,
2343 ban: &jmap_chat_types::SpaceBan,
2344 ) -> impl std::future::Future<Output = ()> + Send {
2345 self.record_lifecycle_event(LifecycleEvent::SpaceBanCreated(ban.clone()))
2346 }
2347
2348 fn on_outbound_event(
2351 &self,
2352 _caller: &C,
2353 _account_id: &Id,
2354 event: &crate::OutboundEvent,
2355 ) -> impl std::future::Future<Output = ()> + Send {
2356 let event = event.clone();
2357 async move {
2358 let mut inner = self.inner.lock().await;
2361 let limit = inner.event_limit;
2362 Inner::push_capped(&mut inner.outbound_events, event, limit);
2363 }
2364 }
2365}
2366
2367impl<C: MemoryCaller> ChatSettings for MemoryBackend<C> {
2368 fn limits(&self, _caller: &C, _account_id: &Id) -> ChatLimits {
2376 let inner = self.inner.lock_unscoped();
2377 inner.limits_override.unwrap_or_default()
2378 }
2379
2380 fn retains_edit_history(&self) -> bool {
2389 let inner = self.inner.lock_unscoped();
2390 inner.retains_edit_history
2391 }
2392
2393 fn maintains_unread_count(&self) -> bool {
2394 let inner = self.inner.lock_unscoped();
2395 inner.maintains_unread_count
2396 }
2397
2398 async fn owner_user_id(
2404 &self,
2405 _caller: &C,
2406 account_id: &Id,
2407 ) -> Result<Option<String>, Self::Error> {
2408 let inner = self.inner.lock().await;
2409 Ok(inner.owner_user_ids.get(account_id.as_ref()).cloned())
2410 }
2411
2412 async fn search_capability(
2416 &self,
2417 _caller: &C,
2418 _account_id: &Id,
2419 ) -> Result<Option<jmap_search::SearchCapability>, Self::Error> {
2420 Ok(self.inner.lock().await.search.clone())
2421 }
2422}
2423
2424impl<C: MemoryCaller> ChatResolvers for MemoryBackend<C> {
2425 async fn attachment_blob(
2429 &self,
2430 _caller: &C,
2431 account_id: &Id,
2432 blob_id: &Id,
2433 ) -> Result<Result<Option<AttachmentBlob>, SetError>, Self::Error> {
2434 let inner = self.inner.lock().await;
2435 Ok(Ok(inner
2436 .attachment_blobs
2437 .get(&(account_id.as_ref().to_owned(), blob_id.clone()))
2438 .copied()))
2439 }
2440}
2441
2442impl<C: MemoryCaller> PushSubscriptionBackend for MemoryBackend<C> {
2456 const PUSH_SUBSCRIPTION_EXTENSION_PROPERTIES: &'static [&'static str] =
2457 &[crate::push::CHAT_PUSH];
2458
2459 async fn list_push_subscriptions(
2460 &self,
2461 _caller: &C,
2462 ) -> Result<Vec<StoredPushSubscription>, MemoryError> {
2463 let inner = self.inner.lock().await;
2464 Ok(inner
2465 .push_subscriptions
2466 .values()
2467 .cloned()
2468 .map(|mut stored| {
2469 strip_unsupported_chat_push(&mut stored.subscription.extra, &inner.chat_push_caps);
2470 stored
2471 })
2472 .collect())
2473 }
2474
2475 async fn create_push_subscription(
2481 &self,
2482 _caller: &C,
2483 mut new: PushSubscription,
2484 ) -> Result<StoredPushSubscription, BackendSetError<MemoryError>> {
2485 let expected_code = random_base64url_code();
2486 let mut inner = self.inner.lock().await;
2487 validate_chat_push(&new.extra, &inner.chat_push_caps).map_err(BackendSetError::SetError)?;
2488 if !self.inner.deferring() && inner.push_subscriptions.len() >= MAX_PUSH_SUBSCRIPTIONS {
2492 return Err(BackendSetError::SetError(Box::new(
2493 SetError::new(SetErrorType::OverQuota).with_description(format!(
2494 "at most {MAX_PUSH_SUBSCRIPTIONS} push subscriptions per user"
2495 )),
2496 )));
2497 }
2498 let id = inner.mint_id();
2499 new.id = Some(id.clone());
2500 let stored = StoredPushSubscription {
2501 subscription: new,
2502 expected_code,
2503 };
2504 inner.push_subscriptions.insert(id, stored.clone());
2505 Ok(stored)
2506 }
2507
2508 async fn update_push_subscription(
2511 &self,
2512 _caller: &C,
2513 sub: PushSubscription,
2514 ) -> Result<PushSubscription, BackendSetError<MemoryError>> {
2515 let mut inner = self.inner.lock().await;
2516 validate_chat_push(&sub.extra, &inner.chat_push_caps).map_err(BackendSetError::SetError)?;
2517 let stored = sub
2518 .id
2519 .as_ref()
2520 .and_then(|id| inner.push_subscriptions.get_mut(id))
2521 .ok_or_else(|| {
2522 BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
2523 })?;
2524 stored.subscription = sub.clone();
2525 Ok(sub)
2526 }
2527
2528 async fn destroy_push_subscription(
2529 &self,
2530 _caller: &C,
2531 id: &Id,
2532 ) -> Result<(), BackendSetError<MemoryError>> {
2533 let mut inner = self.inner.lock().await;
2534 inner
2535 .push_subscriptions
2536 .remove(id)
2537 .map(|_| ())
2538 .ok_or_else(|| {
2539 BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
2540 })
2541 }
2542}
2543
2544fn random_base64url_code() -> String {
2552 let mut bytes = [0u8; 16];
2553 getrandom::fill(&mut bytes).expect("OS CSPRNG must be available for push verification codes");
2554 base64url_unpadded(&bytes)
2555}
2556
2557fn base64url_unpadded(bytes: &[u8]) -> String {
2559 const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
2560 let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
2561 for chunk in bytes.chunks(3) {
2562 let n = chunk
2563 .iter()
2564 .enumerate()
2565 .fold(0u32, |n, (i, &b)| n | u32::from(b) << (16 - 8 * i));
2566 for i in 0..=chunk.len() {
2567 out.push(char::from(ALPHABET[(n >> (18 - 6 * i)) as usize & 63]));
2568 }
2569 }
2570 out
2571}
2572
2573fn patched_copy<O: SetObject>(
2586 inner: &mut Inner,
2587 account_id: &str,
2588 id: &Id,
2589 patch: &O::Patch,
2590) -> Result<(serde_json::Value, BTreeSet<String>), BackendSetError<MemoryError>> {
2591 let invalid_patch = |e: PatchPathError| {
2592 BackendSetError::SetError(Box::new(
2593 SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
2594 ))
2595 };
2596 let patch_val = serde_json::to_value(patch)
2597 .map_err(|e| BackendSetError::Other(MemoryError::serde("serialize patch", &e)))?;
2598 let no_patch = serde_json::Map::new();
2599 let patch_map = patch_val.as_object().unwrap_or(&no_patch);
2600 check_patch_paths(patch_map).map_err(invalid_patch)?;
2604
2605 let existing = inner.objects_mut(O::TYPE_NAME, account_id).get(id).cloned();
2606
2607 let mut current = match existing {
2608 Some(v) => v,
2609 None => {
2610 return Err(BackendSetError::SetError(Box::new(SetError::new(
2611 SetErrorType::NotFound,
2612 ))));
2613 }
2614 };
2615
2616 let mut changed = BTreeSet::new();
2623 if let serde_json::Value::Object(base) = &mut current {
2624 let metadata_info = if metadata_type_name(O::TYPE_NAME).is_some() {
2626 inner.check_metadata_set(O::TYPE_NAME, SetKind::Update, patch_map, Some(base))?
2627 } else {
2628 None
2629 };
2630 if metadata_info.is_some() {
2633 base.entry("metadata")
2634 .or_insert_with(|| serde_json::Value::Object(serde_json::Map::new()));
2635 }
2636 let before = base.clone();
2637 apply_patch_object(base, patch_map).map_err(invalid_patch)?;
2640 if let Some(info) = &metadata_info {
2641 for property in ["metadata", "privateMetadata"] {
2644 if patch_map
2645 .get(property)
2646 .is_some_and(serde_json::Value::is_null)
2647 {
2648 base.insert(
2649 property.to_owned(),
2650 serde_json::Value::Object(serde_json::Map::new()),
2651 );
2652 }
2653 }
2654 check_metadata_depth(patch_map, base, info)
2656 .map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
2657 }
2658 changed = changed_properties(&before, base);
2659 }
2660
2661 if let Err(e) = O::deserialize(¤t) {
2667 let mut props: Vec<String> = patch_map
2668 .keys()
2669 .map(|k| {
2670 let top = k.split('/').next().unwrap_or(k);
2671 top.replace("~1", "/").replace("~0", "~")
2672 })
2673 .collect();
2674 props.sort();
2675 props.dedup();
2676 let mut err = SetError::new(SetErrorType::InvalidProperties)
2677 .with_description(format!("patched {} is invalid: {e}", O::TYPE_NAME));
2678 if props.len() == 1 {
2679 err = err.with_properties(props);
2680 }
2681 return Err(BackendSetError::SetError(Box::new(err)));
2682 }
2683 Ok((current, changed))
2684}
2685
2686fn metadata_type_name(data_type: &str) -> Option<&'static str> {
2692 [
2693 jmap_chat_types::Chat::TYPE_NAME,
2694 jmap_chat_types::Message::TYPE_NAME,
2695 jmap_chat_types::Space::TYPE_NAME,
2696 ]
2697 .into_iter()
2698 .find(|t| *t == data_type)
2699}
2700
2701fn invalid_metadata_property(property: &str, description: &str) -> BackendSetError<MemoryError> {
2702 BackendSetError::SetError(Box::new(
2703 SetError::new(SetErrorType::InvalidProperties)
2704 .with_properties([property])
2705 .with_description(description),
2706 ))
2707}
2708
2709impl Inner {
2710 fn check_metadata_set(
2721 &self,
2722 type_name: &'static str,
2723 kind: SetKind,
2724 entry: &serde_json::Map<String, serde_json::Value>,
2725 stored: Option<&serde_json::Map<String, serde_json::Value>>,
2726 ) -> Result<Option<DataTypeMetadataInfo>, BackendSetError<MemoryError>> {
2727 let Some(first) = entry.keys().find(|k| crate::helpers::is_metadata_key(k)) else {
2728 return Ok(None);
2729 };
2730 let Some(info) = self.metadata_info.get(type_name) else {
2733 return Err(invalid_metadata_property(
2734 first,
2735 "metadata is not supported on this data type",
2736 ));
2737 };
2738 check_metadata_write(kind, entry, stored, info)
2739 .map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
2740 Ok(Some(info.clone()))
2741 }
2742}
2743
2744fn object_id_of(val: &serde_json::Value) -> Result<Id, BackendSetError<MemoryError>> {
2757 match val.get("id").and_then(serde_json::Value::as_str) {
2758 Some(id) if !id.is_empty() => Ok(Id::from(id)),
2759 _ => Err(BackendSetError::Other(MemoryError::new(
2760 "insert_object: object has no non-empty `id` string",
2761 ))),
2762 }
2763}
2764
2765fn reject_taken_id(
2768 inner: &Inner,
2769 type_name: &'static str,
2770 account_id: &Id,
2771 id: &Id,
2772) -> Result<(), BackendSetError<MemoryError>> {
2773 if inner
2774 .objects_ref(type_name, account_id.as_ref())
2775 .is_some_and(|m| m.contains_key(id))
2776 {
2777 return Err(BackendSetError::SetError(Box::new(
2778 SetError::new(SetErrorType::AlreadyExists).with_existing_id(id.clone()),
2779 )));
2780 }
2781 Ok(())
2782}
2783
2784fn insert_created(
2785 inner: &mut Inner,
2786 type_name: &'static str,
2787 account_id: &Id,
2788 server_id: &Id,
2789 val: serde_json::Value,
2790 defer: bool,
2791) -> Result<(), BackendSetError<MemoryError>> {
2792 check_metadata_create(inner, type_name, &val)?;
2793
2794 if type_name == "ChatContact" {
2797 let existing = inner
2798 .objects_ref(type_name, account_id.as_ref())
2799 .and_then(|m| {
2800 m.iter()
2801 .find(|(_, c)| c.get("identity") == val.get("identity"))
2802 })
2803 .map(|(id, _)| id.clone());
2804 if let Some(existing) = existing {
2805 return Err(BackendSetError::SetError(Box::new(
2806 SetError::new(SetErrorType::AlreadyExists).with_existing_id(existing),
2807 )));
2808 }
2809 }
2810
2811 if type_name == "CustomEmoji"
2813 && !defer
2814 && let Some(existing) = emoji_name_holder(inner, account_id, &val, None)
2815 {
2816 return Err(BackendSetError::SetError(Box::new(
2817 SetError::new(SetErrorType::AlreadyExists).with_existing_id(existing),
2818 )));
2819 }
2820
2821 if type_name == "CustomEmoji" {
2825 let limits = inner.limits_override.unwrap_or_default();
2826 let space_full = !defer
2827 && limits.max_custom_emoji_per_space.is_some_and(|max| {
2828 emoji_scope(&val).is_some_and(|space| {
2829 emoji_count_in_space(inner, account_id.as_ref(), &space) >= u64::from(max)
2830 })
2831 });
2832 if space_full {
2833 return Err(over_quota_error(crate::emoji::TOO_MANY_EMOJI));
2834 }
2835 if emoji_blob_over_cap(inner, account_id, &val, &limits) {
2836 return Err(over_quota_error(crate::emoji::EMOJI_TOO_LARGE));
2837 }
2838 }
2839
2840 let reply_parent = if type_name == "Message" {
2841 stored_reply_parent(inner, account_id.as_ref(), &val)
2842 } else {
2843 None
2844 };
2845 inner.require_account(account_id.as_ref())?;
2846 let new_state = inner.bump_state(type_name, account_id.as_ref());
2847 inner
2848 .objects_mut(type_name, account_id.as_ref())
2849 .insert(server_id.clone(), val);
2850 inner
2851 .change_log_mut(type_name, account_id.as_ref())
2852 .push(ChangeEntry {
2853 new_state,
2854 created: vec![server_id.clone()],
2855 updated: vec![],
2856 destroyed: vec![],
2857 restored: vec![],
2858 updated_props: None,
2859 });
2860 record_thread_count_changes(
2861 inner,
2862 account_id.as_ref(),
2863 reply_parent.into_iter().collect(),
2864 );
2865 Ok(())
2866}
2867
2868fn check_metadata_create(
2872 inner: &Inner,
2873 type_name: &'static str,
2874 val: &serde_json::Value,
2875) -> Result<(), BackendSetError<MemoryError>> {
2876 let (Some(type_name), Some(obj)) = (metadata_type_name(type_name), val.as_object()) else {
2877 return Ok(());
2878 };
2879 let entry: serde_json::Map<String, serde_json::Value> = obj
2880 .iter()
2881 .filter(|(k, _)| is_metadata_property(k))
2882 .map(|(k, v)| (k.clone(), v.clone()))
2883 .collect();
2884 if let Some(info) = inner.check_metadata_set(type_name, SetKind::Create, &entry, None)? {
2885 check_metadata_depth(&entry, obj, &info)
2886 .map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
2887 }
2888 Ok(())
2889}
2890
2891fn hard_delete_message(inner: &mut Inner, account_id: &str, id: &Id) -> bool {
2899 inner.purge_message_history(&Id::from(account_id), id);
2902 let Some(msg) = inner.objects_mut("Message", account_id).remove(id) else {
2903 return false;
2904 };
2905 let reply_parent = stored_reply_parent(inner, account_id, &msg);
2906 record_thread_count_changes(inner, account_id, reply_parent.into_iter().collect());
2907 let Some(chat_id) = msg.get("chatId").and_then(|v| v.as_str()).map(Id::from) else {
2908 return true;
2909 };
2910 let unpinned = inner
2911 .objects_mut("Chat", account_id)
2912 .get_mut(&chat_id)
2913 .and_then(|chat| chat.get_mut("pinnedMessageIds")?.as_array_mut())
2914 .is_some_and(|pins| {
2915 let before = pins.len();
2916 pins.retain(|v| v.as_str() != Some(id.as_ref()));
2917 pins.len() != before
2918 });
2919 if unpinned {
2920 let new_state = inner.bump_state("Chat", account_id);
2921 inner.change_log_mut("Chat", account_id).push(ChangeEntry {
2922 new_state,
2923 created: vec![],
2924 updated: vec![chat_id],
2925 destroyed: vec![],
2926 restored: vec![],
2927 updated_props: None,
2928 });
2929 }
2930 true
2931}
2932
2933fn stored_reply_parent(inner: &Inner, account_id: &str, msg: &serde_json::Value) -> Option<Id> {
2938 let parent = Id::from(msg.get("replyTo")?.as_str()?);
2939 inner
2940 .objects_ref("Message", account_id)?
2941 .contains_key(&parent)
2942 .then_some(parent)
2943}
2944
2945fn roots_with_unread_change(
2954 inner: &Inner,
2955 account_id: &str,
2956 old: &serde_json::Value,
2957 new: &serde_json::Value,
2958) -> Vec<Id> {
2959 let last_read = |rp: &serde_json::Value| {
2960 rp.get("lastReadMessageId")
2961 .and_then(|v| v.as_str())
2962 .map(str::to_owned)
2963 };
2964 let (old_read, new_read) = (last_read(old), last_read(new));
2965 if old_read == new_read {
2966 return Vec::new();
2967 }
2968 let chat_id = new.get("chatId");
2969 let Some(msgs) = inner.objects_ref("Message", account_id) else {
2970 return Vec::new();
2971 };
2972 let unread = |read: &Option<String>, id: &str| read.as_deref().is_none_or(|l| id > l);
2973 let mut roots: Vec<Id> = Vec::new();
2974 for (id, reply) in msgs {
2975 if reply.get("chatId") != chat_id
2976 || reply.get("senderId").and_then(|v| v.as_str()) == Some(account_id)
2977 || unread(&old_read, id.as_ref()) == unread(&new_read, id.as_ref())
2978 {
2979 continue;
2980 }
2981 let Some(parent) = reply.get("replyTo").and_then(|v| v.as_str()).map(Id::from) else {
2982 continue;
2983 };
2984 let is_root = msgs
2985 .get(&parent)
2986 .is_some_and(|p| p.get("threadRootId").is_none_or(serde_json::Value::is_null));
2987 if is_root && !roots.contains(&parent) {
2988 roots.push(parent);
2989 }
2990 }
2991 roots
2992}
2993
2994fn record_thread_count_changes(inner: &mut Inner, account_id: &str, ids: Vec<Id>) {
2999 if ids.is_empty() || !inner.limits_override.unwrap_or_default().supports_threads {
3000 return;
3001 }
3002 let new_state = inner.bump_state("Message", account_id);
3003 inner
3004 .change_log_mut("Message", account_id)
3005 .push(ChangeEntry {
3006 new_state,
3007 created: vec![],
3008 updated: ids,
3009 destroyed: vec![],
3010 restored: vec![],
3011 updated_props: None,
3012 });
3013}
3014
3015fn destroy_space_channels(inner: &mut Inner, account_id: &str, space_id: &Id) {
3023 let chat_ids: Vec<Id> = inner
3024 .objects_ref("Chat", account_id)
3025 .map(|chats| {
3026 chats
3027 .keys()
3028 .filter(|id| channel_belongs_to_space(inner, account_id, id, space_id))
3029 .cloned()
3030 .collect()
3031 })
3032 .unwrap_or_default();
3033 if chat_ids.is_empty() {
3034 return;
3035 }
3036 let message_ids: Vec<Id> = chat_ids
3037 .iter()
3038 .flat_map(|chat_id| scan_messages_in_chat(inner, account_id, chat_id))
3039 .collect();
3040 let msgs = inner.objects_mut("Message", account_id);
3041 for msg_id in &message_ids {
3042 msgs.remove(msg_id);
3043 }
3044 let chats = inner.objects_mut("Chat", account_id);
3045 for chat_id in &chat_ids {
3046 chats.remove(chat_id);
3047 }
3048 destroy_read_positions(inner, account_id, &chat_ids);
3049 let new_state = inner.bump_state("Chat", account_id);
3050 inner.change_log_mut("Chat", account_id).push(ChangeEntry {
3051 new_state,
3052 created: vec![],
3053 updated: vec![],
3054 destroyed: chat_ids,
3055 restored: vec![],
3056 updated_props: None,
3057 });
3058 if !message_ids.is_empty() {
3059 let new_state = inner.bump_state("Message", account_id);
3060 inner
3061 .change_log_mut("Message", account_id)
3062 .push(ChangeEntry {
3063 new_state,
3064 created: vec![],
3065 updated: vec![],
3066 destroyed: message_ids,
3067 restored: vec![],
3068 updated_props: None,
3069 });
3070 }
3071}
3072
3073fn apply_space_patch_impl(
3084 inner: &mut Inner,
3085 account_id: &Id,
3086 space_id: &Id,
3087 ops: Vec<SpacePatchOp>,
3088) -> Result<Vec<OpResult>, BackendSetError<MemoryError>> {
3089 if !inner
3091 .objects_ref("Space", account_id.as_ref())
3092 .is_some_and(|m| m.contains_key(space_id))
3093 {
3094 return Err(BackendSetError::SetError(Box::new(SetError::new(
3095 SetErrorType::NotFound,
3096 ))));
3097 }
3098
3099 let protect_last_admin = inner.protect_last_admin;
3110 let space_snapshot = inner
3112 .objects_ref("Space", account_id.as_ref())
3113 .and_then(|m| m.get(space_id))
3114 .cloned()
3115 .ok_or_else(|| {
3116 BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
3117 })?;
3118 let everyone = inner.everyone_in(&space_snapshot).clone();
3119
3120 if let Err(e) = validate_space_patch_ops(
3121 &space_snapshot,
3122 account_id,
3123 &ops,
3124 protect_last_admin,
3125 &everyone,
3126 ) {
3127 return Err(BackendSetError::SetError(e));
3128 }
3129
3130 let limits = inner.limits_override.unwrap_or_default();
3136 if let Some(set_err) = check_count_caps(&space_snapshot, &ops, &limits) {
3137 return Err(BackendSetError::SetError(Box::new(set_err)));
3138 }
3139
3140 let mut results = Vec::with_capacity(ops.len());
3141 let mut effects = SpacePatchEffects::default();
3142
3143 let leaving_space_manager = ops
3150 .iter()
3151 .any(|op| matches!(op, SpacePatchOp::RemoveMember(id) if id == account_id))
3152 && member_effective_permissions(&space_snapshot, account_id.as_ref(), &everyone)
3153 .is_some_and(|p| p.contains(&ChatPermission::ManageSpace));
3154
3155 for (op_index, op) in ops.into_iter().enumerate() {
3156 let outcome = apply_space_patch_op(inner, account_id.as_ref(), space_id, op, &mut effects);
3157 results.push(OpResult {
3158 op_index,
3159 outcome: outcome.map_err(|e| *e),
3160 });
3161 }
3162
3163 if leaving_space_manager && close_if_no_manager(inner, account_id, space_id, &everyone) {
3164 effects.space_mutated = true;
3165 }
3166 log_space_patch(inner, account_id.as_ref(), space_id, effects);
3167 Ok(results)
3168}
3169
3170#[derive(Default)]
3173struct SpacePatchEffects {
3174 space_mutated: bool,
3176 chats_created: Vec<Id>,
3178 chats_updated: HashSet<Id>,
3180 chats_destroyed: Vec<Id>,
3182 messages_destroyed: Vec<Id>,
3184}
3185
3186fn apply_space_patch_op(
3190 inner: &mut Inner,
3191 account_id: &str,
3192 space_id: &Id,
3193 op: SpacePatchOp,
3194 effects: &mut SpacePatchEffects,
3195) -> Result<Option<Id>, Box<SetError>> {
3196 let space_mutated = &mut effects.space_mutated;
3197 match &op {
3198 SpacePatchOp::AddRole(_) => apply_add_role(inner, account_id, space_id, op, space_mutated),
3199 SpacePatchOp::RemoveRole(_) => apply_remove_role(
3200 inner,
3201 account_id,
3202 space_id,
3203 op,
3204 &mut effects.chats_updated,
3205 space_mutated,
3206 ),
3207 SpacePatchOp::UpdateRole { .. } => {
3208 apply_update_role(inner, account_id, space_id, op, space_mutated)
3209 }
3210 SpacePatchOp::AddMember(_) => {
3211 apply_add_member(inner, account_id, space_id, op, space_mutated)
3212 }
3213 SpacePatchOp::RemoveMember(_) => {
3214 apply_remove_member(inner, account_id, space_id, op, space_mutated)
3215 }
3216 SpacePatchOp::UpdateMember { .. } => {
3217 apply_update_member(inner, account_id, space_id, op, space_mutated)
3218 }
3219 SpacePatchOp::AddCategory(_)
3220 | SpacePatchOp::RemoveCategory(_)
3221 | SpacePatchOp::UpdateCategory { .. } => apply_category_op(
3222 inner,
3223 account_id,
3224 space_id,
3225 op,
3226 &mut effects.chats_updated,
3227 space_mutated,
3228 ),
3229 SpacePatchOp::AddChannel(_) => apply_add_channel(
3230 inner,
3231 account_id,
3232 space_id,
3233 op,
3234 &mut effects.chats_created,
3235 space_mutated,
3236 ),
3237 SpacePatchOp::RemoveChannel(_) => apply_remove_channel(
3238 inner,
3239 account_id,
3240 space_id,
3241 op,
3242 &mut effects.chats_destroyed,
3243 &mut effects.messages_destroyed,
3244 space_mutated,
3245 ),
3246 SpacePatchOp::UpdateChannel { .. } => apply_update_channel(
3247 inner,
3248 account_id,
3249 space_id,
3250 op,
3251 &mut effects.chats_updated,
3252 space_mutated,
3253 ),
3254 _ => Err(Box::new(
3258 SetError::new(SetErrorType::Forbidden).with_description(stub_description(&op)),
3259 )),
3260 }
3261}
3262
3263fn close_if_no_manager(
3268 inner: &mut Inner,
3269 account_id: &Id,
3270 space_id: &Id,
3271 everyone: &HashSet<ChatPermission>,
3272) -> bool {
3273 let Some(space) = inner
3274 .objects_mut("Space", account_id.as_ref())
3275 .get_mut(space_id)
3276 else {
3277 return false;
3278 };
3279 let member_ids: Vec<&str> = space
3280 .get("members")
3281 .and_then(|v| v.as_array())
3282 .map(|arr| arr.iter().filter_map(|m| m["id"].as_str()).collect())
3283 .unwrap_or_default();
3284 let closes = space.get("closedAt").is_none()
3285 && !member_ids.is_empty()
3286 && !member_ids.contains(&account_id.as_ref())
3287 && member_ids.iter().all(|m| {
3288 !member_effective_permissions(space, m, everyone)
3289 .is_some_and(|p| p.contains(&ChatPermission::ManageSpace))
3290 });
3291 if closes {
3292 space["closedAt"] = serde_json::Value::String(now_utc_string().into_inner());
3293 }
3294 closes
3295}
3296
3297fn log_space_patch(inner: &mut Inner, account_id: &str, space_id: &Id, effects: SpacePatchEffects) {
3301 let SpacePatchEffects {
3302 space_mutated,
3303 chats_created,
3304 chats_updated,
3305 chats_destroyed,
3306 messages_destroyed,
3307 } = effects;
3308 if space_mutated {
3314 let new_state = inner.bump_state("Space", account_id);
3315 inner.change_log_mut("Space", account_id).push(ChangeEntry {
3316 new_state,
3317 created: vec![],
3318 updated: vec![space_id.clone()],
3319 destroyed: vec![],
3320 restored: vec![],
3321 updated_props: None,
3322 });
3323 }
3324
3325 destroy_read_positions(inner, account_id, &chats_destroyed);
3326
3327 if !chats_created.is_empty() || !chats_updated.is_empty() || !chats_destroyed.is_empty() {
3331 let new_state = inner.bump_state("Chat", account_id);
3332 let mut updated: Vec<Id> = chats_updated
3338 .into_iter()
3339 .filter(|id| !chats_created.contains(id) && !chats_destroyed.contains(id))
3340 .collect();
3341 updated.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
3342 inner.change_log_mut("Chat", account_id).push(ChangeEntry {
3343 new_state,
3344 created: chats_created,
3345 updated,
3346 destroyed: chats_destroyed,
3347 restored: vec![],
3348 updated_props: None,
3349 });
3350 }
3351
3352 if !messages_destroyed.is_empty() {
3353 let new_state = inner.bump_state("Message", account_id);
3354 inner
3355 .change_log_mut("Message", account_id)
3356 .push(ChangeEntry {
3357 new_state,
3358 created: vec![],
3359 updated: vec![],
3360 destroyed: messages_destroyed,
3361 restored: vec![],
3362 updated_props: None,
3363 });
3364 }
3365}
3366
3367fn space_metadata_patch_to_map(
3378 patch: jmap_chat_types::SpaceMetadataPatch,
3379) -> Result<serde_json::Map<String, serde_json::Value>, MemoryError> {
3380 let value = jmap_server::serialize_value(&patch)
3384 .map_err(|_| MemoryError::new("SpaceMetadataPatch serialization failed"))?;
3385 Ok(match value {
3386 serde_json::Value::Object(map) => map,
3387 _ => serde_json::Map::new(),
3391 })
3392}
3393
3394fn apply_space_metadata_patch_impl(
3426 inner: &mut Inner,
3427 account_id: &Id,
3428 space_id: &Id,
3429 patch_map: serde_json::Map<String, serde_json::Value>,
3430) -> Result<Option<jmap_chat_types::Space>, BackendSetError<MemoryError>> {
3431 let space_val = inner
3435 .objects_ref("Space", account_id.as_ref())
3436 .and_then(|m| m.get(space_id))
3437 .cloned()
3438 .ok_or_else(|| {
3439 BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
3440 })?;
3441
3442 let caller_perms =
3445 caller_effective_permissions(&space_val, account_id, inner.everyone_in(&space_val))
3446 .unwrap_or_default();
3447 if !caller_perms.contains(&ChatPermission::ManageSpace) {
3448 return Err(BackendSetError::SetError(
3449 Box::new(SetError::new(SetErrorType::Forbidden).with_description(
3450 "caller lacks required permission `manage_space` to mutate Space top-level metadata",
3451 )),
3452 ));
3453 }
3454
3455 if patch_map.is_empty() {
3461 return Ok(None);
3462 }
3463
3464 let mut current = space_val;
3475 if let Err(MergePatchError::DepthExceeded) =
3476 json_merge_patch(&mut current, serde_json::Value::Object(patch_map))
3477 {
3478 return Err(BackendSetError::SetError(Box::new(
3479 SetError::new(SetErrorType::InvalidPatch)
3480 .with_description("patch nesting exceeds server limit"),
3481 )));
3482 }
3483
3484 let new_state = inner.bump_state("Space", account_id.as_ref());
3485 inner
3486 .objects_mut("Space", account_id.as_ref())
3487 .insert(space_id.clone(), current);
3488 inner
3489 .change_log_mut("Space", account_id.as_ref())
3490 .push(ChangeEntry {
3491 new_state,
3492 created: vec![],
3493 updated: vec![space_id.clone()],
3494 destroyed: vec![],
3495 restored: vec![],
3496 updated_props: None,
3497 });
3498
3499 Ok(None)
3502}
3503
3504fn apply_category_op(
3528 inner: &mut Inner,
3529 account_id: &str,
3530 space_id: &Id,
3531 op: SpacePatchOp,
3532 chats_updated: &mut HashSet<Id>,
3533 space_mutated: &mut bool,
3534) -> Result<Option<Id>, Box<SetError>> {
3535 let mut space_val = stored_space(inner, account_id, space_id)?;
3538 let categories: &mut Vec<serde_json::Value> = space_val
3539 .get_mut("categories")
3540 .and_then(|v| v.as_array_mut())
3541 .ok_or_else(categories_not_array)?;
3542
3543 let assigned_id = match op {
3544 SpacePatchOp::AddCategory(cat) => Some(add_category(
3545 inner,
3546 account_id,
3547 space_id,
3548 cat,
3549 categories,
3550 chats_updated,
3551 )?),
3552 SpacePatchOp::RemoveCategory(target_id) => {
3553 remove_category(
3554 inner,
3555 account_id,
3556 space_id,
3557 &target_id,
3558 categories,
3559 chats_updated,
3560 )?;
3561 None
3562 }
3563 SpacePatchOp::UpdateCategory { id, patch } => {
3564 update_category(
3565 inner,
3566 (account_id, space_id),
3567 &id,
3568 patch,
3569 categories,
3570 chats_updated,
3571 )?;
3572 None
3573 }
3574
3575 _ => unreachable!("apply_category_op called with non-category variant"),
3577 };
3578 *space_mutated = true;
3579
3580 Ok(assigned_id)
3581}
3582
3583fn stored_space(
3585 inner: &Inner,
3586 account_id: &str,
3587 space_id: &Id,
3588) -> Result<serde_json::Value, Box<SetError>> {
3589 inner
3590 .objects_ref("Space", account_id)
3591 .and_then(|m| m.get(space_id))
3592 .cloned()
3593 .ok_or_else(|| Box::new(SetError::new(SetErrorType::NotFound)))
3594}
3595
3596fn categories_not_array() -> SetError {
3599 SetError::new(SetErrorType::Forbidden)
3600 .with_description("internal: Space.categories not an array")
3601}
3602
3603fn not_a_space_channel(ch_id: &Id) -> Box<SetError> {
3606 Box::new(
3607 SetError::new(SetErrorType::InvalidProperties)
3608 .with_properties(vec!["channelIds".to_owned()])
3609 .with_description(format!(
3610 "channelId {} is not a channel of this Space",
3611 ch_id.as_ref()
3612 )),
3613 )
3614}
3615
3616fn category_position(categories: &[serde_json::Value], id: &Id) -> Result<usize, Box<SetError>> {
3619 categories
3620 .iter()
3621 .position(|v| v.get("id").and_then(|s| s.as_str()) == Some(id.as_ref()))
3622 .ok_or_else(|| {
3623 Box::new(
3624 SetError::new(SetErrorType::NotFound)
3625 .with_description(format!("category {} not found", id.as_ref())),
3626 )
3627 })
3628}
3629
3630fn add_category(
3634 inner: &mut Inner,
3635 account_id: &str,
3636 space_id: &Id,
3637 cat: jmap_chat_types::CategoryCreate,
3638 categories: &[serde_json::Value],
3639 chats_updated: &mut HashSet<Id>,
3640) -> Result<Id, Box<SetError>> {
3641 let new_id = inner.mint_id();
3644 let position = cat.position.unwrap_or_else(|| {
3647 categories
3648 .iter()
3649 .filter_map(|c| c.get("position").and_then(serde_json::Value::as_u64))
3650 .max()
3651 .map_or(0, |max| max.saturating_add(1))
3652 });
3653
3654 if let Some(ch_id) = cat
3660 .channel_ids
3661 .iter()
3662 .find(|ch_id| !channel_belongs_to_space(inner, account_id, ch_id, space_id))
3663 {
3664 return Err(not_a_space_channel(ch_id));
3665 }
3666
3667 let mut space_val = stored_space(inner, account_id, space_id)?;
3670
3671 let owned_channel_ids: Vec<Id> = cat.channel_ids.clone();
3676 for ch_id in &owned_channel_ids {
3677 set_channel_category(inner, account_id, ch_id, Some(&new_id));
3678 chats_updated.insert(ch_id.clone());
3679 }
3680 if let Some(unc) = space_val
3681 .get_mut("uncategorizedChannelIds")
3682 .and_then(|v| v.as_array_mut())
3683 {
3684 unc.retain(|v| {
3685 v.as_str()
3686 .is_none_or(|s| !owned_channel_ids.iter().any(|id| id.as_ref() == s))
3687 });
3688 }
3689 let cats = space_val
3690 .get_mut("categories")
3691 .and_then(|v| v.as_array_mut())
3692 .ok_or_else(categories_not_array)?;
3693 remove_from_categories(cats, &owned_channel_ids);
3694 let channel_ids = owned_channel_ids
3695 .iter()
3696 .map(|id| serde_json::Value::from(id.as_ref()))
3697 .collect();
3698 let mut stored = cat.extra;
3699 stored.insert("id".to_owned(), serde_json::Value::from(new_id.as_ref()));
3700 stored.insert("name".to_owned(), serde_json::Value::String(cat.name));
3701 stored.insert("position".to_owned(), serde_json::Value::from(position));
3702 stored.insert(
3703 "channelIds".to_owned(),
3704 serde_json::Value::Array(channel_ids),
3705 );
3706 cats.push(serde_json::Value::Object(stored));
3707
3708 inner
3709 .objects_mut("Space", account_id)
3710 .insert(space_id.clone(), space_val);
3711 Ok(new_id)
3712}
3713
3714fn remove_category(
3718 inner: &mut Inner,
3719 account_id: &str,
3720 space_id: &Id,
3721 target_id: &Id,
3722 categories: &[serde_json::Value],
3723 chats_updated: &mut HashSet<Id>,
3724) -> Result<(), Box<SetError>> {
3725 let pos = category_position(categories, target_id)?;
3729 let scanned: Vec<Id> = scan_channels_in_category(inner, account_id, target_id);
3732
3733 let mut space_val = stored_space(inner, account_id, space_id)?;
3735 let cats = space_val
3736 .get_mut("categories")
3737 .and_then(|v| v.as_array_mut())
3738 .ok_or_else(categories_not_array)?;
3739 cats.remove(pos);
3740
3741 let unc = space_val
3742 .get_mut("uncategorizedChannelIds")
3743 .and_then(|v| v.as_array_mut())
3744 .ok_or_else(|| {
3745 SetError::new(SetErrorType::Forbidden)
3746 .with_description("internal: Space.uncategorizedChannelIds not an array")
3747 })?;
3748 for ch_id in &scanned {
3749 unc.push(serde_json::Value::String(ch_id.as_ref().to_owned()));
3750 }
3751 inner
3752 .objects_mut("Space", account_id)
3753 .insert(space_id.clone(), space_val);
3754
3755 for ch_id in &scanned {
3759 set_channel_category(inner, account_id, ch_id, None);
3760 chats_updated.insert(ch_id.clone());
3761 }
3762 Ok(())
3763}
3764
3765fn update_category(
3771 inner: &mut Inner,
3772 space: (&str, &Id),
3773 id: &Id,
3774 patch: jmap_chat_types::CategoryPatch,
3775 categories: &[serde_json::Value],
3776 chats_updated: &mut HashSet<Id>,
3777) -> Result<(), Box<SetError>> {
3778 use jmap_chat_types::Category;
3779 let (account_id, space_id) = space;
3780
3781 let pos = category_position(categories, id)?;
3783
3784 let mut cat: Category = serde_json::from_value(categories[pos].clone()).map_err(|e| {
3786 SetError::new(SetErrorType::Forbidden)
3787 .with_description(format!("internal: deserialize Category: {e}"))
3788 })?;
3789
3790 if let Some(name) = patch.name {
3791 cat.name = name;
3792 }
3793 if let Some(position) = patch.position {
3794 cat.position = position;
3795 }
3796
3797 let Some(new_ids) = patch.channel_ids else {
3800 return write_category(inner, space, pos, &cat, &[], &[]);
3802 };
3803 if let Some(ch_id) = new_ids
3805 .iter()
3806 .find(|ch_id| !channel_belongs_to_space(inner, account_id, ch_id, space_id))
3807 {
3808 return Err(not_a_space_channel(ch_id));
3809 }
3810
3811 let old_ids = cat.channel_ids.clone();
3812
3813 let removed: Vec<&Id> = old_ids.iter().filter(|o| !new_ids.contains(o)).collect();
3816 let added: Vec<&Id> = new_ids.iter().filter(|n| !old_ids.contains(n)).collect();
3819
3820 cat.channel_ids = new_ids.clone();
3821 write_category(inner, space, pos, &cat, &removed, &added)?;
3822
3823 for ch_id in &removed {
3827 set_channel_category(inner, account_id, ch_id, None);
3828 chats_updated.insert((*ch_id).clone());
3829 }
3830 for ch_id in &added {
3831 set_channel_category(inner, account_id, ch_id, Some(id));
3832 chats_updated.insert((*ch_id).clone());
3833 }
3834 Ok(())
3835}
3836
3837fn write_category(
3843 inner: &mut Inner,
3844 space: (&str, &Id),
3845 pos: usize,
3846 cat: &jmap_chat_types::Category,
3847 removed: &[&Id],
3848 added: &[&Id],
3849) -> Result<(), Box<SetError>> {
3850 let (account_id, space_id) = space;
3851 let mut space_val = stored_space(inner, account_id, space_id)?;
3853 if let Some(unc) = space_val
3854 .get_mut("uncategorizedChannelIds")
3855 .and_then(|v| v.as_array_mut())
3856 {
3857 for ch_id in removed {
3858 unc.push(serde_json::Value::String(ch_id.as_ref().to_owned()));
3859 }
3860 unc.retain(|v| {
3861 v.as_str()
3862 .is_none_or(|s| !added.iter().any(|id| id.as_ref() == s))
3863 });
3864 }
3865 let cats = space_val
3867 .get_mut("categories")
3868 .and_then(|v| v.as_array_mut())
3869 .ok_or_else(categories_not_array)?;
3870 remove_from_categories(cats, added);
3871 cats[pos] = serde_json::to_value(cat).map_err(|e| {
3872 SetError::new(SetErrorType::Forbidden)
3873 .with_description(format!("internal: serialize Category: {e}"))
3874 })?;
3875 inner
3876 .objects_mut("Space", account_id)
3877 .insert(space_id.clone(), space_val);
3878 Ok(())
3879}
3880
3881fn apply_add_channel(
3896 inner: &mut Inner,
3897 account_id: &str,
3898 space_id: &Id,
3899 op: SpacePatchOp,
3900 chats_created: &mut Vec<Id>,
3901 space_mutated: &mut bool,
3902) -> Result<Option<Id>, Box<SetError>> {
3903 use jmap_chat_types::ChannelCreate;
3904
3905 let create: ChannelCreate = match op {
3906 SpacePatchOp::AddChannel(c) => c,
3907 _ => unreachable!("apply_add_channel called with non-AddChannel variant"),
3908 };
3909
3910 if let Some(cat_id) = &create.category_id {
3914 check_space_category(inner, account_id, space_id, cat_id)?;
3915 }
3916
3917 let new_id = inner.mint_id();
3919 let category_id = create.category_id.clone();
3920 let chat_obj = new_channel_object(&new_id, space_id, create);
3921 inner
3922 .objects_mut("Chat", account_id)
3923 .insert(new_id.clone(), serde_json::Value::Object(chat_obj));
3924
3925 let mut space_val = inner
3929 .objects_ref("Space", account_id)
3930 .and_then(|m| m.get(space_id))
3931 .cloned()
3932 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
3933 place_channel(&mut space_val, &new_id, category_id.as_ref())?;
3936 inner
3937 .objects_mut("Space", account_id)
3938 .insert(space_id.clone(), space_val);
3939
3940 chats_created.push(new_id.clone());
3941 *space_mutated = true;
3942 Ok(Some(new_id))
3943}
3944
3945fn new_channel_object(
3955 new_id: &Id,
3956 space_id: &Id,
3957 create: jmap_chat_types::ChannelCreate,
3958) -> serde_json::Map<String, serde_json::Value> {
3959 let now = now_utc_string();
3960 let mut chat_obj = serde_json::Map::new();
3961 chat_obj.insert(
3962 "id".to_owned(),
3963 serde_json::Value::String(new_id.as_ref().to_owned()),
3964 );
3965 chat_obj.insert(
3966 "kind".to_owned(),
3967 serde_json::Value::String("channel".to_owned()),
3968 );
3969 chat_obj.insert(
3970 "createdAt".to_owned(),
3971 serde_json::Value::String(now.into_inner()),
3972 );
3973 chat_obj.insert("unreadCount".to_owned(), serde_json::Value::from(0u64));
3974 chat_obj.insert(
3975 "pinnedMessageIds".to_owned(),
3976 serde_json::Value::Array(vec![]),
3977 );
3978 chat_obj.insert("muted".to_owned(), serde_json::Value::Bool(false));
3979 chat_obj.insert(
3980 "receiveTypingIndicators".to_owned(),
3981 serde_json::Value::Bool(true),
3982 );
3983 chat_obj.insert(
3984 "spaceId".to_owned(),
3985 serde_json::Value::String(space_id.as_ref().to_owned()),
3986 );
3987 chat_obj.insert("name".to_owned(), serde_json::Value::String(create.name));
3988 if let Some(cat_id) = &create.category_id {
3989 chat_obj.insert(
3990 "categoryId".to_owned(),
3991 serde_json::Value::String(cat_id.as_ref().to_owned()),
3992 );
3993 }
3994 if let Some(pos) = create.position {
3995 chat_obj.insert("position".to_owned(), serde_json::Value::from(pos));
3996 }
3997 if let Some(topic) = create.topic {
3998 chat_obj.insert("topic".to_owned(), serde_json::Value::String(topic));
3999 }
4000 chat_obj
4001}
4002
4003fn apply_remove_channel(
4021 inner: &mut Inner,
4022 account_id: &str,
4023 space_id: &Id,
4024 op: SpacePatchOp,
4025 chats_destroyed: &mut Vec<Id>,
4026 messages_destroyed: &mut Vec<Id>,
4027 space_mutated: &mut bool,
4028) -> Result<Option<Id>, Box<SetError>> {
4029 let target_id: Id = match op {
4030 SpacePatchOp::RemoveChannel(id) => id,
4031 _ => unreachable!("apply_remove_channel called with non-RemoveChannel variant"),
4032 };
4033
4034 if !channel_belongs_to_space(inner, account_id, &target_id, space_id) {
4036 return Err(Box::new(
4037 SetError::new(SetErrorType::NotFound).with_description(format!(
4038 "channel {} is not a channel of this Space",
4039 target_id.as_ref()
4040 )),
4041 ));
4042 }
4043
4044 let cascade_ids = scan_messages_in_chat(inner, account_id, &target_id);
4050 if !cascade_ids.is_empty() {
4051 let msg_map = inner.objects_mut("Message", account_id);
4052 for msg_id in &cascade_ids {
4053 msg_map.remove(msg_id);
4054 }
4055 messages_destroyed.extend(cascade_ids);
4056 }
4057
4058 inner.objects_mut("Chat", account_id).remove(&target_id);
4060
4061 let mut space_val = inner
4063 .objects_ref("Space", account_id)
4064 .and_then(|m| m.get(space_id))
4065 .cloned()
4066 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4067
4068 if let Some(unc) = space_val
4069 .get_mut("uncategorizedChannelIds")
4070 .and_then(|v| v.as_array_mut())
4071 {
4072 unc.retain(|v| v.as_str() != Some(target_id.as_ref()));
4073 }
4074 if let Some(cats) = space_val
4075 .get_mut("categories")
4076 .and_then(|v| v.as_array_mut())
4077 {
4078 for cat in cats.iter_mut() {
4079 if let Some(ch_ids) = cat.get_mut("channelIds").and_then(|v| v.as_array_mut()) {
4080 ch_ids.retain(|v| v.as_str() != Some(target_id.as_ref()));
4081 }
4082 }
4083 }
4084 inner
4085 .objects_mut("Space", account_id)
4086 .insert(space_id.clone(), space_val);
4087
4088 chats_destroyed.push(target_id);
4089 *space_mutated = true;
4090 Ok(None)
4091}
4092
4093fn apply_update_channel(
4108 inner: &mut Inner,
4109 account_id: &str,
4110 space_id: &Id,
4111 op: SpacePatchOp,
4112 chats_updated: &mut HashSet<Id>,
4113 space_mutated: &mut bool,
4114) -> Result<Option<Id>, Box<SetError>> {
4115 use jmap_chat_types::ChannelPatch;
4116 use jmap_chat_types::Clearable;
4117
4118 let (id, patch): (Id, ChannelPatch) = match op {
4119 SpacePatchOp::UpdateChannel { id, patch } => (id, patch),
4120 _ => unreachable!("apply_update_channel called with non-UpdateChannel variant"),
4121 };
4122
4123 if !channel_belongs_to_space(inner, account_id, &id, space_id) {
4125 return Err(Box::new(
4126 SetError::new(SetErrorType::NotFound).with_description(format!(
4127 "channel {} is not a channel of this Space",
4128 id.as_ref()
4129 )),
4130 ));
4131 }
4132
4133 if let Some(Clearable::Set(new_cat)) = &patch.category_id {
4137 check_space_category(inner, account_id, space_id, new_cat)?;
4138 }
4139
4140 let old_category_id: Option<Id> = inner
4144 .objects_ref("Chat", account_id)
4145 .and_then(|m| m.get(&id))
4146 .and_then(|v| v.get("categoryId"))
4147 .and_then(|c| c.as_str())
4148 .map(Id::from);
4149
4150 let category_id = {
4151 let chat_map = inner.objects_mut("Chat", account_id);
4152 let Some(chat_val) = chat_map.get_mut(&id) else {
4153 return Err(Box::new(SetError::new(SetErrorType::NotFound)));
4156 };
4157 let serde_json::Value::Object(obj) = chat_val else {
4158 return Err(Box::new(
4159 SetError::new(SetErrorType::Forbidden)
4160 .with_description("internal: Chat record not a JSON object"),
4161 ));
4162 };
4163 patch_channel_record(obj, patch)?
4164 };
4165
4166 if let Some(category_id) = category_id {
4168 let new_category_id: Option<Id> = match category_id {
4169 Clearable::Set(c) => Some(c),
4170 Clearable::Clear => None,
4171 };
4172
4173 if old_category_id != new_category_id {
4176 let mut space_val = inner
4177 .objects_ref("Space", account_id)
4178 .and_then(|m| m.get(space_id))
4179 .cloned()
4180 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4181
4182 unplace_channel(&mut space_val, &id, old_category_id.as_ref());
4184 place_channel(&mut space_val, &id, new_category_id.as_ref())?;
4186
4187 inner
4188 .objects_mut("Space", account_id)
4189 .insert(space_id.clone(), space_val);
4190 *space_mutated = true;
4191 }
4192 }
4193
4194 chats_updated.insert(id);
4195 Ok(None)
4196}
4197
4198fn patch_channel_record(
4203 obj: &mut serde_json::Map<String, serde_json::Value>,
4204 patch: jmap_chat_types::ChannelPatch,
4205) -> Result<Option<jmap_chat_types::Clearable<Id>>, Box<SetError>> {
4206 use jmap_chat_types::Clearable;
4207
4208 if let Some(name) = patch.name {
4209 obj.insert("name".to_owned(), serde_json::Value::String(name));
4210 }
4211 if let Some(pos) = patch.position {
4212 obj.insert("position".to_owned(), serde_json::Value::from(pos));
4213 }
4214 match patch.topic {
4215 Some(Clearable::Set(t)) => {
4216 obj.insert("topic".to_owned(), serde_json::Value::String(t));
4217 }
4218 Some(Clearable::Clear) => {
4219 obj.remove("topic");
4220 }
4221 None => {}
4222 }
4223 match &patch.category_id {
4224 Some(Clearable::Set(c)) => {
4225 obj.insert(
4226 "categoryId".to_owned(),
4227 serde_json::Value::String(c.as_ref().to_owned()),
4228 );
4229 }
4230 Some(Clearable::Clear) => {
4231 obj.remove("categoryId");
4232 }
4233 None => {}
4234 }
4235 match patch.slow_mode_seconds {
4236 Some(Clearable::Set(s)) => {
4237 obj.insert("slowModeSeconds".to_owned(), serde_json::Value::from(s));
4238 }
4239 Some(Clearable::Clear) => {
4240 obj.remove("slowModeSeconds");
4241 }
4242 None => {}
4243 }
4244 match patch.permission_overrides {
4245 Some(Clearable::Set(po)) => {
4246 let val = serde_json::to_value(&po).map_err(|e| {
4247 SetError::new(SetErrorType::Forbidden)
4248 .with_description(format!("internal: serialize permissionOverrides: {e}"))
4249 })?;
4250 obj.insert("permissionOverrides".to_owned(), val);
4251 }
4252 Some(Clearable::Clear) => {
4253 obj.remove("permissionOverrides");
4254 }
4255 None => {}
4256 }
4257 Ok(patch.category_id)
4258}
4259
4260fn check_space_category(
4264 inner: &Inner,
4265 account_id: &str,
4266 space_id: &Id,
4267 cat_id: &Id,
4268) -> Result<(), Box<SetError>> {
4269 let space_val = inner
4270 .objects_ref("Space", account_id)
4271 .and_then(|m| m.get(space_id))
4272 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4273 let exists = space_val
4274 .get("categories")
4275 .and_then(|v| v.as_array())
4276 .is_some_and(|cats| {
4277 cats.iter()
4278 .any(|c| c.get("id").and_then(|s| s.as_str()) == Some(cat_id.as_ref()))
4279 });
4280 if !exists {
4281 return Err(Box::new(
4282 SetError::new(SetErrorType::InvalidProperties)
4283 .with_properties(vec!["categoryId".to_owned()])
4284 .with_description(format!(
4285 "categoryId {} does not refer to a category of this Space",
4286 cat_id.as_ref()
4287 )),
4288 ));
4289 }
4290 Ok(())
4291}
4292
4293fn unplace_channel(space_val: &mut serde_json::Value, id: &Id, category: Option<&Id>) {
4297 match category {
4298 Some(prev_cat) => {
4299 if let Some(cats) = space_val
4300 .get_mut("categories")
4301 .and_then(|v| v.as_array_mut())
4302 {
4303 for cat in cats.iter_mut() {
4304 if cat.get("id").and_then(|s| s.as_str()) == Some(prev_cat.as_ref()) {
4305 if let Some(ch_ids) =
4306 cat.get_mut("channelIds").and_then(|v| v.as_array_mut())
4307 {
4308 ch_ids.retain(|v| v.as_str() != Some(id.as_ref()));
4309 }
4310 break;
4311 }
4312 }
4313 }
4314 }
4315 None => {
4316 if let Some(unc) = space_val
4317 .get_mut("uncategorizedChannelIds")
4318 .and_then(|v| v.as_array_mut())
4319 {
4320 unc.retain(|v| v.as_str() != Some(id.as_ref()));
4321 }
4322 }
4323 }
4324}
4325
4326fn place_channel(
4331 space_val: &mut serde_json::Value,
4332 id: &Id,
4333 category: Option<&Id>,
4334) -> Result<(), Box<SetError>> {
4335 if let Some(new_cat) = category {
4336 let cats = space_val
4337 .get_mut("categories")
4338 .and_then(|v| v.as_array_mut())
4339 .ok_or_else(categories_not_array)?;
4340 for cat in cats.iter_mut() {
4341 if cat.get("id").and_then(|s| s.as_str()) == Some(new_cat.as_ref()) {
4342 let ch_ids = cat
4343 .get_mut("channelIds")
4344 .and_then(|v| v.as_array_mut())
4345 .ok_or_else(|| {
4346 SetError::new(SetErrorType::Forbidden)
4347 .with_description("internal: Category.channelIds not an array")
4348 })?;
4349 ch_ids.push(serde_json::Value::String(id.as_ref().to_owned()));
4350 break;
4351 }
4352 }
4353 } else {
4354 let unc = space_val
4355 .get_mut("uncategorizedChannelIds")
4356 .and_then(|v| v.as_array_mut())
4357 .ok_or_else(|| {
4358 SetError::new(SetErrorType::Forbidden)
4359 .with_description("internal: Space.uncategorizedChannelIds not an array")
4360 })?;
4361 unc.push(serde_json::Value::String(id.as_ref().to_owned()));
4362 }
4363 Ok(())
4364}
4365
4366fn apply_add_role(
4375 inner: &mut Inner,
4376 account_id: &str,
4377 space_id: &Id,
4378 op: SpacePatchOp,
4379 space_mutated: &mut bool,
4380) -> Result<Option<Id>, Box<SetError>> {
4381 let role = match op {
4382 SpacePatchOp::AddRole(r) => r,
4383 _ => unreachable!("apply_add_role called with non-AddRole variant"),
4384 };
4385
4386 let new_id = inner.mint_id();
4390 let mut stored = serde_json::to_value(&role).map_err(|e| {
4391 SetError::new(SetErrorType::Forbidden)
4392 .with_description(format!("internal: serialize RoleCreate: {e}"))
4393 })?;
4394 if let Some(fields) = stored.as_object_mut() {
4395 fields.insert("id".to_owned(), serde_json::Value::from(new_id.as_ref()));
4396 }
4397
4398 let mut space_val = inner
4399 .objects_ref("Space", account_id)
4400 .and_then(|m| m.get(space_id))
4401 .cloned()
4402 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4403
4404 let roles = space_val
4405 .get_mut("roles")
4406 .and_then(|v| v.as_array_mut())
4407 .ok_or_else(|| {
4408 SetError::new(SetErrorType::Forbidden)
4409 .with_description("internal: Space.roles not an array")
4410 })?;
4411
4412 roles.push(stored);
4413
4414 inner
4415 .objects_mut("Space", account_id)
4416 .insert(space_id.clone(), space_val);
4417 *space_mutated = true;
4418 Ok(Some(new_id))
4419}
4420
4421fn apply_remove_role(
4426 inner: &mut Inner,
4427 account_id: &str,
4428 space_id: &Id,
4429 op: SpacePatchOp,
4430 chats_updated: &mut HashSet<Id>,
4431 space_mutated: &mut bool,
4432) -> Result<Option<Id>, Box<SetError>> {
4433 let target_id = match op {
4434 SpacePatchOp::RemoveRole(id) => id,
4435 _ => unreachable!("apply_remove_role called with non-RemoveRole variant"),
4436 };
4437
4438 let mut space_val = inner
4439 .objects_ref("Space", account_id)
4440 .and_then(|m| m.get(space_id))
4441 .cloned()
4442 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4443
4444 let roles = space_val
4445 .get_mut("roles")
4446 .and_then(|v| v.as_array_mut())
4447 .ok_or_else(|| {
4448 SetError::new(SetErrorType::Forbidden)
4449 .with_description("internal: Space.roles not an array")
4450 })?;
4451 let pos = roles
4452 .iter()
4453 .position(|v| v.get("id").and_then(|s| s.as_str()) == Some(target_id.as_ref()));
4454 let Some(pos) = pos else {
4455 return Err(Box::new(
4456 SetError::new(SetErrorType::NotFound)
4457 .with_description(format!("role {} not found", target_id.as_ref())),
4458 ));
4459 };
4460 roles.remove(pos);
4461
4462 if let Some(members) = space_val.get_mut("members").and_then(|v| v.as_array_mut()) {
4468 for member in members.iter_mut() {
4469 if let Some(role_ids) = member.get_mut("roleIds").and_then(|v| v.as_array_mut()) {
4470 role_ids.retain(|v| v.as_str() != Some(target_id.as_ref()));
4471 }
4472 }
4473 }
4474
4475 inner
4476 .objects_mut("Space", account_id)
4477 .insert(space_id.clone(), space_val);
4478 *space_mutated = true;
4479
4480 for (chat_id, chat) in inner.objects_mut("Chat", account_id).iter_mut() {
4485 if chat.get("kind").and_then(|k| k.as_str()) != Some("channel")
4486 || chat.get("spaceId").and_then(|s| s.as_str()) != Some(space_id.as_ref())
4487 {
4488 continue;
4489 }
4490 let Some(overrides) = chat
4491 .get_mut("permissionOverrides")
4492 .and_then(|v| v.as_array_mut())
4493 else {
4494 continue;
4495 };
4496 let before = overrides.len();
4497 overrides.retain(|o| {
4498 o.get("targetType").and_then(|t| t.as_str()) != Some("role")
4499 || o.get("targetId").and_then(|t| t.as_str()) != Some(target_id.as_ref())
4500 });
4501 if overrides.len() != before {
4502 chats_updated.insert(chat_id.clone());
4503 }
4504 }
4505 Ok(None)
4506}
4507
4508fn apply_update_role(
4512 inner: &mut Inner,
4513 account_id: &str,
4514 space_id: &Id,
4515 op: SpacePatchOp,
4516 space_mutated: &mut bool,
4517) -> Result<Option<Id>, Box<SetError>> {
4518 use jmap_chat_types::Clearable;
4519 use jmap_chat_types::SpaceRole;
4520
4521 let (target_id, patch) = match op {
4522 SpacePatchOp::UpdateRole { id, patch } => (id, patch),
4523 _ => unreachable!("apply_update_role called with non-UpdateRole variant"),
4524 };
4525
4526 let mut space_val = inner
4527 .objects_ref("Space", account_id)
4528 .and_then(|m| m.get(space_id))
4529 .cloned()
4530 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4531
4532 let roles = space_val
4533 .get_mut("roles")
4534 .and_then(|v| v.as_array_mut())
4535 .ok_or_else(|| {
4536 SetError::new(SetErrorType::Forbidden)
4537 .with_description("internal: Space.roles not an array")
4538 })?;
4539 let pos = roles
4540 .iter()
4541 .position(|v| v.get("id").and_then(|s| s.as_str()) == Some(target_id.as_ref()));
4542 let Some(pos) = pos else {
4543 return Err(Box::new(
4544 SetError::new(SetErrorType::NotFound)
4545 .with_description(format!("role {} not found", target_id.as_ref())),
4546 ));
4547 };
4548
4549 let mut role: SpaceRole = serde_json::from_value(roles[pos].clone()).map_err(|e| {
4553 SetError::new(SetErrorType::Forbidden)
4554 .with_description(format!("internal: deserialize SpaceRole: {e}"))
4555 })?;
4556 if let Some(name) = patch.name {
4557 role.name = name;
4558 }
4559 match patch.color {
4560 Some(Clearable::Set(c)) => role.color = Some(c),
4561 Some(Clearable::Clear) => role.color = None,
4562 None => {}
4563 }
4564 if let Some(permissions) = patch.permissions {
4565 role.permissions = permissions;
4566 }
4567 if let Some(position) = patch.position {
4568 role.position = position;
4569 }
4570 roles[pos] = serde_json::to_value(&role).map_err(|e| {
4571 SetError::new(SetErrorType::Forbidden)
4572 .with_description(format!("internal: serialize SpaceRole: {e}"))
4573 })?;
4574
4575 inner
4576 .objects_mut("Space", account_id)
4577 .insert(space_id.clone(), space_val);
4578 *space_mutated = true;
4579 Ok(None)
4580}
4581
4582fn apply_add_member(
4587 inner: &mut Inner,
4588 account_id: &str,
4589 space_id: &Id,
4590 op: SpacePatchOp,
4591 space_mutated: &mut bool,
4592) -> Result<Option<Id>, Box<SetError>> {
4593 let (user_id, role_ids) = match op {
4594 SpacePatchOp::AddMember(create) => (create.user_id, create.role_ids),
4595 _ => unreachable!("apply_add_member called with non-AddMember variant"),
4596 };
4597
4598 let mut space_val = inner
4599 .objects_ref("Space", account_id)
4600 .and_then(|m| m.get(space_id))
4601 .cloned()
4602 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4603 check_new_member(&space_val, &user_id, &role_ids)?;
4604
4605 let mut member_obj = serde_json::Map::new();
4609 member_obj.insert(
4610 "id".to_owned(),
4611 serde_json::Value::String(user_id.as_ref().to_owned()),
4612 );
4613 member_obj.insert(
4614 "roleIds".to_owned(),
4615 serde_json::Value::Array(
4616 role_ids
4617 .iter()
4618 .map(|id| serde_json::Value::String(id.as_ref().to_owned()))
4619 .collect(),
4620 ),
4621 );
4622 member_obj.insert(
4623 "joinedAt".to_owned(),
4624 serde_json::Value::String(now_utc_string().into_inner()),
4625 );
4626
4627 let members = space_val
4628 .get_mut("members")
4629 .and_then(|v| v.as_array_mut())
4630 .ok_or_else(|| {
4631 SetError::new(SetErrorType::Forbidden)
4632 .with_description("internal: Space.members not an array")
4633 })?;
4634 members.push(serde_json::Value::Object(member_obj));
4635
4636 let new_count = members.len() as u64;
4640 if let Some(count_field) = space_val.get_mut("memberCount") {
4641 *count_field = serde_json::Value::from(new_count);
4642 }
4643
4644 inner
4645 .objects_mut("Space", account_id)
4646 .insert(space_id.clone(), space_val);
4647 *space_mutated = true;
4648 Ok(None)
4649}
4650
4651fn check_new_member(
4655 space_val: &serde_json::Value,
4656 user_id: &Id,
4657 role_ids: &[Id],
4658) -> Result<(), Box<SetError>> {
4659 if space_val
4662 .get("members")
4663 .and_then(|v| v.as_array())
4664 .is_some_and(|members| {
4665 members
4666 .iter()
4667 .any(|m| m.get("id").and_then(|v| v.as_str()) == Some(user_id.as_ref()))
4668 })
4669 {
4670 return Err(Box::new(
4671 SetError::new(SetErrorType::InvalidProperties)
4672 .with_properties(vec!["userId".to_owned()])
4673 .with_description(format!(
4674 "member {} is already a member of this Space",
4675 user_id.as_ref()
4676 )),
4677 ));
4678 }
4679
4680 if !role_ids.is_empty() {
4684 let existing: HashSet<String> = space_val
4685 .get("roles")
4686 .and_then(|v| v.as_array())
4687 .map(|arr| {
4688 arr.iter()
4689 .filter_map(|r| r.get("id").and_then(|v| v.as_str()).map(str::to_owned))
4690 .collect()
4691 })
4692 .unwrap_or_default();
4693 for rid in role_ids {
4694 if !existing.contains(rid.as_ref()) {
4695 return Err(Box::new(
4696 SetError::new(SetErrorType::InvalidProperties)
4697 .with_properties(vec!["roleIds".to_owned()])
4698 .with_description(format!(
4699 "role {} does not exist in this Space",
4700 rid.as_ref()
4701 )),
4702 ));
4703 }
4704 }
4705 }
4706 Ok(())
4707}
4708
4709fn apply_remove_member(
4713 inner: &mut Inner,
4714 account_id: &str,
4715 space_id: &Id,
4716 op: SpacePatchOp,
4717 space_mutated: &mut bool,
4718) -> Result<Option<Id>, Box<SetError>> {
4719 let target_id = match op {
4720 SpacePatchOp::RemoveMember(id) => id,
4721 _ => unreachable!("apply_remove_member called with non-RemoveMember variant"),
4722 };
4723
4724 let mut space_val = inner
4725 .objects_ref("Space", account_id)
4726 .and_then(|m| m.get(space_id))
4727 .cloned()
4728 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4729
4730 let members = space_val
4731 .get_mut("members")
4732 .and_then(|v| v.as_array_mut())
4733 .ok_or_else(|| {
4734 SetError::new(SetErrorType::Forbidden)
4735 .with_description("internal: Space.members not an array")
4736 })?;
4737
4738 let pos = members
4739 .iter()
4740 .position(|m| m.get("id").and_then(|v| v.as_str()) == Some(target_id.as_ref()));
4741 let Some(pos) = pos else {
4742 return Err(Box::new(
4743 SetError::new(SetErrorType::NotFound)
4744 .with_description(format!("member {} not found", target_id.as_ref())),
4745 ));
4746 };
4747 members.remove(pos);
4748
4749 let new_count = members.len() as u64;
4751 if let Some(count_field) = space_val.get_mut("memberCount") {
4752 *count_field = serde_json::Value::from(new_count);
4753 }
4754
4755 inner
4756 .objects_mut("Space", account_id)
4757 .insert(space_id.clone(), space_val);
4758 *space_mutated = true;
4759 Ok(None)
4760}
4761
4762fn apply_update_member(
4767 inner: &mut Inner,
4768 account_id: &str,
4769 space_id: &Id,
4770 op: SpacePatchOp,
4771 space_mutated: &mut bool,
4772) -> Result<Option<Id>, Box<SetError>> {
4773 use jmap_chat_types::Clearable;
4774
4775 let (user_id, patch) = match op {
4776 SpacePatchOp::UpdateMember { user_id, patch } => (user_id, patch),
4777 _ => unreachable!("apply_update_member called with non-UpdateMember variant"),
4778 };
4779
4780 let mut space_val = inner
4781 .objects_ref("Space", account_id)
4782 .and_then(|m| m.get(space_id))
4783 .cloned()
4784 .ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
4785
4786 if let Some(role_ids) = &patch.role_ids {
4788 let existing: HashSet<String> = space_val
4789 .get("roles")
4790 .and_then(|v| v.as_array())
4791 .map(|arr| {
4792 arr.iter()
4793 .filter_map(|r| r.get("id").and_then(|v| v.as_str()).map(str::to_owned))
4794 .collect()
4795 })
4796 .unwrap_or_default();
4797 for rid in role_ids {
4798 if !existing.contains(rid.as_ref()) {
4799 return Err(Box::new(
4800 SetError::new(SetErrorType::InvalidProperties)
4801 .with_properties(vec!["roleIds".to_owned()])
4802 .with_description(format!(
4803 "role {} does not exist in this Space",
4804 rid.as_ref()
4805 )),
4806 ));
4807 }
4808 }
4809 }
4810
4811 let members = space_val
4812 .get_mut("members")
4813 .and_then(|v| v.as_array_mut())
4814 .ok_or_else(|| {
4815 SetError::new(SetErrorType::Forbidden)
4816 .with_description("internal: Space.members not an array")
4817 })?;
4818
4819 let pos = members
4820 .iter()
4821 .position(|m| m.get("id").and_then(|v| v.as_str()) == Some(user_id.as_ref()));
4822 let Some(pos) = pos else {
4823 return Err(Box::new(
4824 SetError::new(SetErrorType::NotFound)
4825 .with_description(format!("member {} not found", user_id.as_ref())),
4826 ));
4827 };
4828
4829 let member_obj = members[pos].as_object_mut().ok_or_else(|| {
4834 SetError::new(SetErrorType::Forbidden)
4835 .with_description("internal: SpaceMember not a JSON object")
4836 })?;
4837 if let Some(role_ids) = patch.role_ids {
4838 member_obj.insert(
4839 "roleIds".to_owned(),
4840 serde_json::Value::Array(
4841 role_ids
4842 .iter()
4843 .map(|id| serde_json::Value::String(id.as_ref().to_owned()))
4844 .collect(),
4845 ),
4846 );
4847 }
4848 match patch.nick {
4849 Some(Clearable::Set(s)) => {
4850 member_obj.insert("nick".to_owned(), serde_json::Value::String(s));
4851 }
4852 Some(Clearable::Clear) => {
4853 member_obj.remove("nick");
4854 }
4855 None => {}
4856 }
4857
4858 inner
4859 .objects_mut("Space", account_id)
4860 .insert(space_id.clone(), space_val);
4861 *space_mutated = true;
4862 Ok(None)
4863}
4864
4865fn check_count_caps(
4891 space_val: &serde_json::Value,
4892 ops: &[SpacePatchOp],
4893 limits: &ChatLimits,
4894) -> Option<SetError> {
4895 let (add_roles, add_members, add_channels, add_categories) = crate::helpers::count_add_ops(ops);
4896 if add_roles == 0 && add_members == 0 && add_channels == 0 && add_categories == 0 {
4897 return None;
4898 }
4899
4900 let count_array = |key: &str| -> u32 {
4901 space_val
4902 .get(key)
4903 .and_then(|v| v.as_array())
4904 .map(|a| u32::try_from(a.len()).unwrap_or(u32::MAX))
4905 .unwrap_or(0)
4906 };
4907
4908 let cur_roles = count_array("roles");
4909 let cur_members = count_array("members");
4910 let cur_categories = count_array("categories");
4911 let uncategorized = space_val
4913 .get("uncategorizedChannelIds")
4914 .and_then(|v| v.as_array())
4915 .map(|a| a.len())
4916 .unwrap_or(0);
4917 let categorized: usize = space_val
4918 .get("categories")
4919 .and_then(|v| v.as_array())
4920 .map(|arr| {
4921 arr.iter()
4922 .map(|c| {
4923 c.get("channelIds")
4924 .and_then(|v| v.as_array())
4925 .map(|a| a.len())
4926 .unwrap_or(0)
4927 })
4928 .sum()
4929 })
4930 .unwrap_or(0);
4931 let cur_channels = u32::try_from(uncategorized + categorized).unwrap_or(u32::MAX);
4932
4933 let exceeded =
4941 |description: &'static str, current: u32, add: u32, cap: u32| -> Option<SetError> {
4942 if add == 0 {
4943 return None;
4944 }
4945 if current.saturating_add(add) > cap {
4946 Some(SetError::new(SetErrorType::OverQuota).with_description(description))
4947 } else {
4948 None
4949 }
4950 };
4951
4952 [
4957 (
4958 "too many roles",
4959 cur_roles,
4960 add_roles,
4961 limits.max_roles_per_space,
4962 ),
4963 (
4964 "too many members",
4965 cur_members,
4966 add_members,
4967 limits.max_space_members,
4968 ),
4969 (
4970 "too many channels",
4971 cur_channels,
4972 add_channels,
4973 limits.max_channels_per_space,
4974 ),
4975 (
4976 "too many categories",
4977 cur_categories,
4978 add_categories,
4979 limits.max_categories_per_space,
4980 ),
4981 ]
4982 .into_iter()
4983 .find_map(|(description, current, add, cap)| exceeded(description, current, add, cap))
4984}
4985
4986fn validate_space_patch_ops(
5045 space_val: &serde_json::Value,
5046 account_id: &Id,
5047 ops: &[SpacePatchOp],
5048 protect_last_admin: bool,
5049 everyone: &HashSet<ChatPermission>,
5050) -> Result<(), Box<SetError>> {
5051 let mut removed = ops.iter().filter_map(|op| match op {
5056 SpacePatchOp::RemoveMember(id) => Some(id),
5057 _ => None,
5058 });
5059 let self_removal =
5060 matches!((removed.next(), removed.next()), (Some(id), None) if id == account_id);
5061
5062 let mut updated = ops.iter().filter_map(|op| match op {
5067 SpacePatchOp::UpdateMember { user_id, patch } => Some((user_id, patch)),
5068 _ => None,
5069 });
5070 let self_nick = match (updated.next(), updated.next()) {
5071 (Some((id, patch)), None) => {
5072 id == account_id
5073 && patch.nick.is_some()
5074 && patch.role_ids.is_none()
5075 && patch.extra.is_empty()
5076 }
5077 _ => false,
5078 };
5079
5080 let caller_perms =
5082 caller_effective_permissions(space_val, account_id, everyone).unwrap_or_default();
5083 let caller_highest = caller_highest_position(space_val, account_id).unwrap_or(0);
5084
5085 for op in ops {
5086 let exempt = (self_removal && matches!(op, SpacePatchOp::RemoveMember(_)))
5087 || (self_nick && matches!(op, SpacePatchOp::UpdateMember { .. }));
5088 check_op_permissions(op, &caller_perms, exempt)?;
5089 check_op_hierarchy(space_val, op, caller_highest)?;
5090 }
5091
5092 if protect_last_admin && let Some(keys) = last_admin_patch_keys(space_val, ops, self_removal) {
5097 return Err(Box::new(
5098 SetError::new(SetErrorType::InvalidProperties)
5099 .with_properties(keys)
5100 .with_description(
5101 "this patch would leave the Space with no \
5102 `manage_members`/`manage_space` holder (last-admin protection)",
5103 ),
5104 ));
5105 }
5106
5107 Ok(())
5108}
5109
5110fn check_op_permissions(
5114 op: &SpacePatchOp,
5115 caller_perms: &HashSet<ChatPermission>,
5116 exempt: bool,
5117) -> Result<(), Box<SetError>> {
5118 use crate::permissions::{RequiredPermissions, required_permissions_for_op};
5119
5120 let required = match required_permissions_for_op(op) {
5136 RequiredPermissions::Known(slice) => slice,
5137 RequiredPermissions::UnknownOp => {
5138 return Err(Box::new(
5139 SetError::new(SetErrorType::Forbidden).with_description(format!(
5140 "unknown SpacePatchOp variant `{}`; this version of \
5141 the kit cannot determine its permission requirement, \
5142 rejecting fail-closed",
5143 variant_name(op)
5144 )),
5145 ));
5146 }
5147 };
5148 let required = if exempt { &[] } else { required };
5149 for req in required {
5150 if !caller_perms.contains(req) {
5151 return Err(Box::new(
5152 SetError::new(SetErrorType::Forbidden).with_description(format!(
5153 "caller lacks required permission `{}` for {}",
5154 req,
5155 variant_name(op)
5156 )),
5157 ));
5158 }
5159 }
5160 Ok(())
5161}
5162
5163fn check_op_hierarchy(
5167 space_val: &serde_json::Value,
5168 op: &SpacePatchOp,
5169 caller_highest: u64,
5170) -> Result<(), Box<SetError>> {
5171 match op {
5189 SpacePatchOp::AddRole(role) if role.position >= caller_highest => {
5190 return Err(Box::new(hierarchy_error(
5191 role.position,
5192 caller_highest,
5193 "AddRole",
5194 )));
5195 }
5196 SpacePatchOp::RemoveRole(target_id) => {
5197 if let Some(pos) = role_position(space_val, target_id.as_ref())
5198 && pos >= caller_highest
5199 {
5200 return Err(Box::new(hierarchy_error(pos, caller_highest, "RemoveRole")));
5201 }
5202 }
5206 SpacePatchOp::UpdateRole { id, patch } => {
5207 if let Some(pos) = role_position(space_val, id.as_ref())
5208 && pos >= caller_highest
5209 {
5210 return Err(Box::new(hierarchy_error(pos, caller_highest, "UpdateRole")));
5211 }
5212 if let Some(new_pos) = patch.position
5213 && new_pos >= caller_highest
5214 {
5215 return Err(Box::new(hierarchy_error(
5216 new_pos,
5217 caller_highest,
5218 "UpdateRole (new position)",
5219 )));
5220 }
5221 }
5222 SpacePatchOp::AddMember(create) => {
5223 for rid in &create.role_ids {
5224 if let Some(pos) = role_position(space_val, rid.as_ref())
5225 && pos >= caller_highest
5226 {
5227 return Err(Box::new(hierarchy_error(pos, caller_highest, "AddMember")));
5228 }
5229 }
5232 }
5233 SpacePatchOp::UpdateMember { user_id, patch } => {
5234 if let Some(role_ids) = &patch.role_ids {
5235 let current = member_role_ids(space_val, user_id.as_ref());
5236 let new: HashSet<&str> = role_ids.iter().map(|r| r.as_ref()).collect();
5237 for rid in current.symmetric_difference(&new) {
5238 if let Some(pos) = role_position(space_val, rid)
5239 && pos >= caller_highest
5240 {
5241 return Err(Box::new(hierarchy_error(
5242 pos,
5243 caller_highest,
5244 "UpdateMember",
5245 )));
5246 }
5247 }
5248 }
5249 }
5250 SpacePatchOp::RemoveMember(_) => {
5251 }
5253 _ => {}
5254 }
5255 Ok(())
5256}
5257
5258fn last_admin_patch_keys(
5271 space_val: &serde_json::Value,
5272 ops: &[SpacePatchOp],
5273 self_removal: bool,
5274) -> Option<Vec<&'static str>> {
5275 let pre_roles = admin_roles(space_val);
5277 let pre_members: HashMap<&str, HashSet<&str>> = space_val
5279 .get("members")
5280 .and_then(|v| v.as_array())
5281 .into_iter()
5282 .flatten()
5283 .filter_map(|m| {
5284 let id = m.get("id")?.as_str()?;
5285 Some((id, member_role_ids(space_val, id)))
5286 })
5287 .collect();
5288
5289 let is_admin = |roles: &HashMap<&str, bool>, role_ids: &HashSet<&str>| {
5290 role_ids
5291 .iter()
5292 .any(|r| roles.get(r).copied().unwrap_or(false))
5293 };
5294 if !pre_members.values().any(|ids| is_admin(&pre_roles, ids)) {
5295 return None;
5296 }
5297
5298 let mut roles = pre_roles.clone();
5299 let mut members = pre_members.clone();
5300 let mut flagged = [false; 4];
5302 const KEYS: [&str; 4] = [
5303 "removeRoles",
5304 "updateRoles",
5305 "removeMembers",
5306 "updateMembers",
5307 ];
5308 for op in ops {
5309 match op {
5310 SpacePatchOp::RemoveRole(id) => {
5311 flagged[0] |= pre_roles.get(id.as_ref()).copied().unwrap_or(false);
5312 roles.remove(id.as_ref());
5313 }
5314 SpacePatchOp::UpdateRole { id, patch } => {
5315 if let (Some(perms), Some(admin)) = (&patch.permissions, roles.get_mut(id.as_ref()))
5316 {
5317 *admin = perms.iter().any(|p| grants_admin(p.as_str()));
5318 flagged[1] |= pre_roles[id.as_ref()] && !*admin;
5319 }
5320 }
5321 SpacePatchOp::RemoveMember(id) if !self_removal => {
5322 if let Some(ids) = pre_members.get(id.as_ref()) {
5323 flagged[2] |= is_admin(&pre_roles, ids);
5324 }
5325 members.remove(id.as_ref());
5326 }
5327 SpacePatchOp::UpdateMember { user_id, patch } => {
5328 if let (Some(new), Some(cur)) = (&patch.role_ids, members.get_mut(user_id.as_ref()))
5329 {
5330 *cur = new.iter().map(|r| r.as_ref()).collect();
5331 flagged[3] |= pre_members
5332 .get(user_id.as_ref())
5333 .is_some_and(|pre| is_admin(&pre_roles, pre))
5334 && !is_admin(&pre_roles, cur);
5335 }
5336 }
5337 SpacePatchOp::AddMember(create) => {
5338 members.insert(
5339 create.user_id.as_ref(),
5340 create.role_ids.iter().map(|r| r.as_ref()).collect(),
5341 );
5342 }
5343 _ => {}
5344 }
5345 }
5346
5347 if members.values().any(|ids| is_admin(&roles, ids)) {
5348 return None;
5349 }
5350 Some(
5351 KEYS.iter()
5352 .zip(flagged)
5353 .filter_map(|(k, f)| f.then_some(*k))
5354 .collect(),
5355 )
5356}
5357
5358fn grants_admin(p: &str) -> bool {
5361 p == ChatPermission::ManageMembers.as_str() || p == ChatPermission::ManageSpace.as_str()
5362}
5363
5364fn admin_roles(space_val: &serde_json::Value) -> HashMap<&str, bool> {
5367 space_val
5368 .get("roles")
5369 .and_then(|v| v.as_array())
5370 .into_iter()
5371 .flatten()
5372 .filter_map(|r| {
5373 let id = r.get("id")?.as_str()?;
5374 let admin = r
5375 .get("permissions")
5376 .and_then(|v| v.as_array())
5377 .into_iter()
5378 .flatten()
5379 .filter_map(|p| p.as_str())
5380 .any(grants_admin);
5381 Some((id, admin))
5382 })
5383 .collect()
5384}
5385
5386fn hierarchy_error(target_pos: u64, caller_highest: u64, op_label: &str) -> SetError {
5389 SetError::new(SetErrorType::Forbidden).with_description(format!(
5390 "{op_label}: target role position {target_pos} is not strictly less than \
5391 caller's highest role position {caller_highest} (role-position hierarchy, \
5392 draft §Space/set L1260, L1266)"
5393 ))
5394}
5395
5396fn caller_effective_permissions(
5406 space_val: &serde_json::Value,
5407 caller_id: &Id,
5408 everyone: &HashSet<ChatPermission>,
5409) -> Option<HashSet<ChatPermission>> {
5410 member_effective_permissions(space_val, caller_id.as_ref(), everyone)
5411}
5412
5413fn member_effective_permissions(
5417 space_val: &serde_json::Value,
5418 member_id: &str,
5419 everyone: &HashSet<ChatPermission>,
5420) -> Option<HashSet<ChatPermission>> {
5421 let members = space_val.get("members").and_then(|v| v.as_array())?;
5422 let member = members
5423 .iter()
5424 .find(|m| m.get("id").and_then(|v| v.as_str()) == Some(member_id))?;
5425 let role_ids: HashSet<String> = member
5426 .get("roleIds")
5427 .and_then(|v| v.as_array())
5428 .map(|arr| {
5429 arr.iter()
5430 .filter_map(|v| v.as_str().map(str::to_owned))
5431 .collect()
5432 })
5433 .unwrap_or_default();
5434 let mut perms = everyone.clone();
5435 if let Some(roles) = space_val.get("roles").and_then(|v| v.as_array()) {
5436 for role in roles {
5437 let Some(rid) = role.get("id").and_then(|v| v.as_str()) else {
5438 continue;
5439 };
5440 if !role_ids.contains(rid) {
5441 continue;
5442 }
5443 if let Some(role_perms) = role.get("permissions").and_then(|v| v.as_array()) {
5444 perms.extend(
5445 role_perms
5446 .iter()
5447 .filter_map(|p| serde_json::from_value(p.clone()).ok()),
5448 );
5449 }
5450 }
5451 }
5452 Some(perms)
5453}
5454
5455fn owner_channel_permissions(
5463 inner: &Inner,
5464 account_id: &Id,
5465 chat: &serde_json::Value,
5466) -> Option<HashSet<ChatPermission>> {
5467 use crate::permissions::resolve_channel_permissions;
5468 use jmap_chat_types::ChannelPermission;
5469
5470 let space_id = chat.get("spaceId").and_then(|v| v.as_str())?;
5471 let space = inner
5472 .objects_ref("Space", account_id.as_ref())?
5473 .get(&Id::from(space_id))?;
5474 let base = caller_effective_permissions(space, account_id, inner.everyone_in(space))?;
5475 let overrides: Vec<ChannelPermission> = match chat.get("permissionOverrides") {
5476 None | Some(serde_json::Value::Null) => Vec::new(),
5477 Some(v) => serde_json::from_value(v.clone()).ok()?,
5478 };
5479 let role_ids = member_role_ids(space, account_id.as_ref());
5480 Some(resolve_channel_permissions(
5481 base,
5482 space_id,
5483 account_id.as_ref(),
5484 &role_ids,
5485 &overrides,
5486 ))
5487}
5488
5489fn window_changes(
5494 relevant: &[&ChangeEntry],
5495 type_name: &str,
5496 mode: MetadataOnlyChanges,
5497) -> (Vec<Id>, Vec<Id>, Vec<Id>, ChangedProperties) {
5498 let (mut fates, mut order, mut window_props) = window_fates(relevant, type_name);
5499 fold_window_restores(relevant, &mut fates, &mut order, &mut window_props);
5500
5501 let mut created: Vec<Id> = Vec::new();
5502 let mut updated: Vec<Id> = Vec::new();
5503 let mut destroyed: Vec<Id> = Vec::new();
5504 for id in order {
5506 match fates.remove(&id) {
5507 Some(IdFate::Created) => created.push(id),
5508 Some(IdFate::Updated)
5512 if mode == MetadataOnlyChanges::Ignore
5513 && window_props.is_metadata_only(id.as_ref()) => {}
5514 Some(IdFate::Updated) => updated.push(id),
5515 Some(IdFate::Destroyed) => destroyed.push(id),
5516 None => {}
5517 }
5518 }
5519 (created, updated, destroyed, window_props)
5520}
5521
5522fn window_fates(
5530 relevant: &[&ChangeEntry],
5531 type_name: &str,
5532) -> (HashMap<Id, IdFate>, Vec<Id>, ChangedProperties) {
5533 let mut fates: HashMap<Id, IdFate> = HashMap::new();
5534 let mut order: Vec<Id> = Vec::new();
5535 let mut window_props = ChangedProperties::new();
5536 for entry in relevant {
5537 for id in &entry.created {
5538 if fates.insert(id.clone(), IdFate::Created).is_none() {
5539 order.push(id.clone());
5540 }
5541 }
5542 for id in &entry.updated {
5543 window_props.record(id.as_ref(), entry.updated_props.as_ref());
5544 let fate = match fates.get(id) {
5545 Some(IdFate::Created) => IdFate::Created,
5546 Some(IdFate::Destroyed) => IdFate::Destroyed,
5547 _ => IdFate::Updated,
5548 };
5549 if fates.insert(id.clone(), fate).is_none() {
5550 order.push(id.clone());
5551 }
5552 }
5553 for id in &entry.destroyed {
5554 if type_name != "Message" && matches!(fates.get(id), Some(IdFate::Created)) {
5562 fates.remove(id);
5563 } else if fates.insert(id.clone(), IdFate::Destroyed).is_none() {
5564 order.push(id.clone());
5565 }
5566 }
5567 }
5568 (fates, order, window_props)
5569}
5570
5571fn fold_window_restores(
5578 relevant: &[&ChangeEntry],
5579 fates: &mut HashMap<Id, IdFate>,
5580 order: &mut Vec<Id>,
5581 window_props: &mut ChangedProperties,
5582) {
5583 let mut events: HashMap<Id, Vec<ChangeEvent>> = HashMap::new();
5584 for entry in relevant {
5585 for (ids, event) in [
5586 (&entry.created, ChangeEvent::Created),
5587 (&entry.updated, ChangeEvent::Updated),
5588 (&entry.destroyed, ChangeEvent::Destroyed),
5589 (&entry.restored, ChangeEvent::Restored),
5590 ] {
5591 for id in ids {
5592 events.entry(id.clone()).or_default().push(event);
5593 }
5594 }
5595 }
5596 for (id, list) in &events {
5597 if !list.contains(&ChangeEvent::Restored) {
5598 continue;
5599 }
5600 let fate = match fold_restore(list) {
5601 Some(ChangeKind::Created) => IdFate::Created,
5602 Some(ChangeKind::Destroyed) => IdFate::Destroyed,
5603 Some(_) => {
5604 window_props.record(id.as_ref(), None);
5606 IdFate::Updated
5607 }
5608 None => {
5609 fates.remove(id);
5610 continue;
5611 }
5612 };
5613 if fates.insert(id.clone(), fate).is_none() {
5614 order.push(id.clone());
5615 }
5616 }
5617}
5618
5619fn message_listed(inner: &Inner, msg: Option<&serde_json::Value>, account_id: &Id) -> bool {
5623 msg.and_then(|obj| obj.get("chatId"))
5624 .and_then(|v| v.as_str())
5625 .is_none_or(|cid| owner_may_view_chat(inner, account_id, &Id::from(cid)))
5626}
5627
5628fn space_listed(space: &serde_json::Value, account_id: &Id, want_public: bool) -> bool {
5633 let flag = |k: &str| space.get(k).and_then(serde_json::Value::as_bool) == Some(true);
5634 let is_member = space
5635 .get("members")
5636 .and_then(|v| v.as_array())
5637 .is_some_and(|ms| {
5638 ms.iter()
5639 .any(|mm| mm.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref()))
5640 });
5641 is_member || (want_public && flag("isPublic") && flag("isPubliclyPreviewable"))
5642}
5643
5644fn owner_may_view_chat(inner: &Inner, account_id: &Id, chat_id: &Id) -> bool {
5648 let Some(chat) = inner
5649 .objects_ref("Chat", account_id.as_ref())
5650 .and_then(|m| m.get(chat_id))
5651 else {
5652 return true;
5653 };
5654 if chat.get("kind").and_then(|v| v.as_str()) != Some("channel") {
5655 return true;
5656 }
5657 owner_channel_permissions(inner, account_id, chat)
5658 .is_some_and(|perms| perms.contains(&ChatPermission::View))
5659}
5660
5661fn caller_highest_position(space_val: &serde_json::Value, caller_id: &Id) -> Option<u64> {
5671 let members = space_val.get("members").and_then(|v| v.as_array())?;
5672 let member = members
5673 .iter()
5674 .find(|m| m.get("id").and_then(|v| v.as_str()) == Some(caller_id.as_ref()))?;
5675 let role_ids: HashSet<String> = member
5676 .get("roleIds")
5677 .and_then(|v| v.as_array())
5678 .map(|arr| {
5679 arr.iter()
5680 .filter_map(|v| v.as_str().map(str::to_owned))
5681 .collect()
5682 })
5683 .unwrap_or_default();
5684 let mut max: u64 = 0;
5685 if let Some(roles) = space_val.get("roles").and_then(|v| v.as_array()) {
5686 for role in roles {
5687 let Some(rid) = role.get("id").and_then(|v| v.as_str()) else {
5688 continue;
5689 };
5690 if !role_ids.contains(rid) {
5691 continue;
5692 }
5693 let Some(pos) = role.get("position").and_then(|v| v.as_u64()) else {
5694 continue;
5695 };
5696 if pos > max {
5697 max = pos;
5698 }
5699 }
5700 }
5701 Some(max)
5702}
5703
5704fn member_role_ids<'a>(space_val: &'a serde_json::Value, member_id: &str) -> HashSet<&'a str> {
5708 space_val
5709 .get("members")
5710 .and_then(|v| v.as_array())
5711 .and_then(|ms| {
5712 ms.iter()
5713 .find(|m| m.get("id").and_then(|v| v.as_str()) == Some(member_id))
5714 })
5715 .and_then(|m| m.get("roleIds"))
5716 .and_then(|v| v.as_array())
5717 .map(|ids| ids.iter().filter_map(|v| v.as_str()).collect())
5718 .unwrap_or_default()
5719}
5720
5721fn role_position(space_val: &serde_json::Value, role_id: &str) -> Option<u64> {
5722 let roles = space_val.get("roles").and_then(|v| v.as_array())?;
5723 roles
5724 .iter()
5725 .find(|r| r.get("id").and_then(|v| v.as_str()) == Some(role_id))
5726 .and_then(|r| r.get("position").and_then(|v| v.as_u64()))
5727}
5728
5729fn broadcast_mention_matches_owner(
5740 bm: &serde_json::Value,
5741 owner_is_admin: impl FnOnce() -> bool,
5742) -> bool {
5743 match bm.get("scope").and_then(|v| v.as_str()) {
5744 Some("everyone") => true,
5745 Some("here") => true,
5746 Some("admins") => owner_is_admin(),
5747 _ => false, }
5749}
5750
5751fn owner_is_chat_admin(
5765 inner: &Inner,
5766 account_id: &Id,
5767 chat_id: Option<&serde_json::Value>,
5768) -> bool {
5769 let Some(chat) = chat_id.and_then(|v| v.as_str()).and_then(|id| {
5770 inner
5771 .objects_ref("Chat", account_id.as_ref())?
5772 .get(&Id::from(id))
5773 }) else {
5774 return false;
5775 };
5776 match chat.get("kind").and_then(|v| v.as_str()) {
5777 Some("group") => is_group_admin(chat, account_id),
5778 Some("channel") => chat
5779 .get("spaceId")
5780 .and_then(|v| v.as_str())
5781 .and_then(|sid| {
5782 inner
5783 .objects_ref("Space", account_id.as_ref())?
5784 .get(&Id::from(sid))
5785 })
5786 .and_then(|space| {
5787 caller_effective_permissions(space, account_id, inner.everyone_in(space))
5788 })
5789 .is_some_and(|perms| {
5790 perms.contains(&ChatPermission::ManageMembers)
5791 || perms.contains(&ChatPermission::ManageSpace)
5792 }),
5793 _ => false,
5794 }
5795}
5796
5797fn is_group_admin(chat: &serde_json::Value, member_id: &Id) -> bool {
5800 chat.get("members")
5801 .and_then(|v| v.as_array())
5802 .is_some_and(|members| {
5803 members.iter().any(|m| {
5804 m.get("id").and_then(|v| v.as_str()) == Some(member_id.as_ref())
5805 && m.get("role").and_then(|v| v.as_str()) == Some("admin")
5806 })
5807 })
5808}
5809
5810fn emoji_name_holder(
5817 inner: &Inner,
5818 account_id: &Id,
5819 emoji: &serde_json::Value,
5820 except: Option<&Id>,
5821) -> Option<Id> {
5822 let scope = |e: &serde_json::Value| e.get("spaceId").filter(|v| !v.is_null()).cloned();
5823 inner
5824 .objects_ref("CustomEmoji", account_id.as_ref())?
5825 .iter()
5826 .find(|(id, e)| {
5827 Some(*id) != except && e.get("name") == emoji.get("name") && scope(e) == scope(emoji)
5828 })
5829 .map(|(id, _)| id.clone())
5830}
5831
5832fn emoji_scope(emoji: &serde_json::Value) -> Option<serde_json::Value> {
5834 emoji.get("spaceId").filter(|v| !v.is_null()).cloned()
5835}
5836
5837fn emoji_count_in_space(inner: &Inner, account_id: &str, space: &serde_json::Value) -> u64 {
5840 inner.objects_ref("CustomEmoji", account_id).map_or(0, |m| {
5841 m.values()
5842 .filter(|e| emoji_scope(e).as_ref() == Some(space))
5843 .fold(0, |n, _| n.saturating_add(1))
5844 })
5845}
5846
5847fn emoji_blob_over_cap(
5853 inner: &Inner,
5854 account_id: &Id,
5855 emoji: &serde_json::Value,
5856 limits: &ChatLimits,
5857) -> bool {
5858 let (Some(max), Some(blob_id)) = (
5859 limits.max_custom_emoji_bytes,
5860 emoji.get("blobId").and_then(serde_json::Value::as_str),
5861 ) else {
5862 return false;
5863 };
5864 inner
5865 .attachment_blobs
5866 .get(&(account_id.as_ref().to_owned(), Id::from(blob_id)))
5867 .is_some_and(|b| b.size > max)
5868}
5869
5870fn over_quota_error(description: &str) -> BackendSetError<MemoryError> {
5872 BackendSetError::SetError(Box::new(
5873 SetError::new(SetErrorType::OverQuota).with_description(description),
5874 ))
5875}
5876
5877fn compare_by_sort(
5892 a: &serde_json::Value,
5893 b: &serde_json::Value,
5894 comparators: &[serde_json::Value],
5895) -> std::cmp::Ordering {
5896 use serde_json::Value;
5897 use std::cmp::Ordering;
5898 for c in comparators {
5899 let Some(property) = c.get("property").and_then(Value::as_str) else {
5900 continue;
5901 };
5902 let x = a.get(property).filter(|v| !v.is_null());
5903 let y = b.get(property).filter(|v| !v.is_null());
5904 let ord = match (x, y) {
5905 (None, None) => Ordering::Equal,
5906 (None, Some(_)) => Ordering::Greater,
5907 (Some(_), None) => Ordering::Less,
5908 (Some(x), Some(y)) => {
5909 let ord = match (x, y) {
5910 (Value::String(x), Value::String(y)) => {
5911 match (utc_date_key(x), utc_date_key(y)) {
5912 (Some(x), Some(y)) => x.cmp(&y),
5913 _ => x.cmp(y),
5914 }
5915 }
5916 (Value::Number(x), Value::Number(y)) => x
5917 .as_f64()
5918 .partial_cmp(&y.as_f64())
5919 .unwrap_or(Ordering::Equal),
5920 (Value::Bool(x), Value::Bool(y)) => x.cmp(y),
5921 _ => Ordering::Equal,
5922 };
5923 if c.get("isAscending").and_then(Value::as_bool) == Some(false) {
5924 ord.reverse()
5925 } else {
5926 ord
5927 }
5928 }
5929 };
5930 if ord != Ordering::Equal {
5931 return ord;
5932 }
5933 }
5934 Ordering::Equal
5935}
5936
5937fn utc_date_key(s: &str) -> Option<(i64, &str)> {
5942 let secs = jmap_types::UTCDate::from(s).to_epoch_seconds().ok()?;
5943 let frac = s
5944 .strip_suffix('Z')?
5945 .split_once('.')
5946 .map_or("", |(_, f)| f.trim_end_matches('0'));
5947 Some((secs, frac))
5948}
5949
5950fn filter_matches(
5954 inner: &Inner,
5955 type_name: &str,
5956 obj: &serde_json::Value,
5957 filter: &serde_json::Value,
5958 account_id: &Id,
5959) -> bool {
5960 let mut conditions = filter
5961 .get("conditions")
5962 .and_then(serde_json::Value::as_array)
5963 .into_iter()
5964 .flatten();
5965 let sub = |f: &serde_json::Value| filter_matches(inner, type_name, obj, f, account_id);
5966 match filter.get("operator").and_then(serde_json::Value::as_str) {
5970 Some("AND") => conditions.all(sub),
5971 Some("OR") => conditions.any(sub),
5972 Some("NOT") => !conditions.any(sub),
5973 _ => condition_matches(inner, type_name, obj, filter, account_id),
5974 }
5975}
5976
5977const METADATA_CONDITION_KEYS: [&str; 6] = [
5979 "metadataExists",
5980 "privateMetadataExists",
5981 "metadataTextContains",
5982 "privateMetadataTextContains",
5983 "metadataTextEquals",
5984 "privateMetadataTextEquals",
5985];
5986
5987fn check_metadata_filter(
5999 filter: &serde_json::Value,
6000 info: Option<&DataTypeMetadataInfo>,
6001) -> Result<(), BackendQueryError<MemoryError>> {
6002 let unsupported = |description: String| {
6003 let mut err = jmap_types::JmapError::unsupported_filter();
6004 err.description = Some(description);
6005 BackendQueryError::Method(err)
6006 };
6007 if filter.get("operator").is_some() {
6008 return filter
6009 .get("conditions")
6010 .and_then(serde_json::Value::as_array)
6011 .into_iter()
6012 .flatten()
6013 .try_for_each(|f| check_metadata_filter(f, info));
6014 }
6015 let Some(leaf) = filter.as_object() else {
6016 return Ok(());
6017 };
6018 if !METADATA_CONDITION_KEYS
6019 .iter()
6020 .any(|k| leaf.contains_key(*k))
6021 {
6022 return Ok(());
6023 }
6024 let Some(info) = info else {
6025 return Err(unsupported(
6026 "metadata filter conditions are not supported".to_owned(),
6027 ));
6028 };
6029 MetadataCondition::take_from(&mut leaf.clone(), info)
6030 .map(drop)
6031 .map_err(|e| match e {
6032 MetadataFilterError::InvalidArguments(d) => {
6033 BackendQueryError::Method(jmap_types::JmapError::invalid_arguments(d))
6034 }
6035 other => unsupported(other.to_string()),
6036 })
6037}
6038
6039fn metadata_leaf_matches(obj: &serde_json::Value, cond: &serde_json::Value) -> bool {
6046 <MetadataCondition as serde::Deserialize>::deserialize(cond)
6047 .is_ok_and(|c| c.matches(obj.get("metadata").and_then(|m| m.as_object()), None))
6048}
6049
6050fn has_is_public_true(filter: &serde_json::Value) -> bool {
6053 filter.get("isPublic") == Some(&serde_json::Value::Bool(true))
6054 || filter
6055 .get("conditions")
6056 .and_then(serde_json::Value::as_array)
6057 .is_some_and(|cs| cs.iter().any(has_is_public_true))
6058}
6059
6060fn condition_matches(
6076 inner: &Inner,
6077 type_name: &str,
6078 obj: &serde_json::Value,
6079 cond: &serde_json::Value,
6080 account_id: &Id,
6081) -> bool {
6082 let eq = |k: &str| cond.get(k).is_none_or(|want| obj.get(k) == Some(want));
6083 let flag_eq = |k: &str| {
6084 cond.get(k)
6085 .and_then(serde_json::Value::as_bool)
6086 .is_none_or(|want| {
6087 obj.get(k)
6088 .and_then(serde_json::Value::as_bool)
6089 .unwrap_or(false)
6090 == want
6091 })
6092 };
6093 match type_name {
6094 "Chat" => eq("kind") && flag_eq("muted") && metadata_leaf_matches(obj, cond),
6095 "ChatContact" => flag_eq("blocked") && eq("presence") && eq("identity"),
6096 "Message" => {
6097 message_matches_filter(inner, obj, cond, account_id)
6098 && metadata_leaf_matches(obj, cond)
6099 && message_where_matches(inner, obj, cond)
6100 }
6101 "Space" => {
6102 flag_eq("isPublic")
6103 && metadata_leaf_matches(obj, cond)
6104 && cond
6105 .get("name")
6106 .and_then(serde_json::Value::as_str)
6107 .is_none_or(|part| {
6108 obj.get("name")
6109 .and_then(serde_json::Value::as_str)
6110 .is_some_and(|name| name.contains(part))
6111 })
6112 }
6113 "CustomEmoji" => eq("spaceId"),
6114 _ => true,
6115 }
6116}
6117
6118fn message_matches_filter(
6132 inner: &Inner,
6133 obj: &serde_json::Value,
6134 filter: &serde_json::Value,
6135 account_id: &Id,
6136) -> bool {
6137 let eq = |k: &str| filter.get(k).is_none_or(|want| obj.get(k) == Some(want));
6142 if !(eq("chatId") && eq("threadRootId") && eq("topicId")) {
6143 return false;
6144 }
6145
6146 if let Some(want) = filter.get("hasAttachment").and_then(|v| v.as_bool()) {
6149 let has = obj
6150 .get("attachments")
6151 .and_then(|v| v.as_array())
6152 .is_some_and(|a| !a.is_empty());
6153 if has != want {
6154 return false;
6155 }
6156 }
6157
6158 if let Some(want) = filter.get("hasMention").and_then(|v| v.as_bool()) {
6162 let has_direct = obj
6163 .get("mentions")
6164 .and_then(|v| v.as_array())
6165 .is_some_and(|arr| {
6166 arr.iter()
6167 .any(|m| m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref()))
6168 });
6169 let has = has_direct
6170 || obj
6171 .get("broadcastMentions")
6172 .and_then(|v| v.as_array())
6173 .is_some_and(|arr| {
6174 arr.iter().any(|bm| {
6175 broadcast_mention_matches_owner(bm, || {
6176 owner_is_chat_admin(inner, account_id, obj.get("chatId"))
6177 })
6178 })
6179 });
6180 if has != want {
6181 return false;
6182 }
6183 }
6184
6185 true
6186}
6187
6188fn check_where(
6195 filter: &serde_json::Value,
6196 type_name: &str,
6197 search: Option<&jmap_search::SearchCapability>,
6198) -> Result<(), BackendQueryError<MemoryError>> {
6199 for w in jmap_search::where_values(filter) {
6200 let Some(cap) = search else {
6201 return Err(BackendQueryError::Method(
6202 jmap_types::JmapError::unsupported_filter(),
6203 ));
6204 };
6205 jmap_search::check_where(w, type_name, cap).map_err(BackendQueryError::Method)?;
6206 }
6207 Ok(())
6208}
6209
6210fn message_where_matches(inner: &Inner, obj: &serde_json::Value, cond: &serde_json::Value) -> bool {
6219 struct MessageCandidate(serde_json::Value);
6220 impl jmap_search::Candidate for MessageCandidate {
6221 fn field(&self, pointer: &str) -> Option<&serde_json::Value> {
6222 self.0.pointer(pointer)
6223 }
6224 fn matches_text(&self, text: &str) -> bool {
6225 let casemap = Some("i;unicode-casemap");
6226 self.0
6227 .get("body")
6228 .and_then(serde_json::Value::as_str)
6229 .is_some_and(|b| {
6230 jmap_search::collate(b, casemap).contains(&*jmap_search::collate(text, casemap))
6231 })
6232 }
6233 }
6234 let Some(w) = cond.get("where").filter(|w| !w.is_null()) else {
6235 return true;
6236 };
6237 let Ok(expr) = jmap_search::Expression::parse(w) else {
6238 return false;
6239 };
6240 let mut json = obj.clone();
6241 if !inner.retains_edit_history
6242 && let Some(m) = json.as_object_mut()
6243 {
6244 m.remove("editHistory");
6245 }
6246 expr.matches(&MessageCandidate(json))
6247}
6248
6249fn scan_messages_in_chat(inner: &Inner, account_id: &str, chat_id: &Id) -> Vec<Id> {
6251 let Some(msgs) = inner.objects_ref("Message", account_id) else {
6252 return Vec::new();
6253 };
6254 msgs.iter()
6255 .filter(|(_, v)| v.get("chatId").and_then(|c| c.as_str()) == Some(chat_id.as_ref()))
6256 .map(|(id, _)| id.clone())
6257 .collect()
6258}
6259
6260fn destroy_read_positions(inner: &mut Inner, account_id: &str, chat_ids: &[Id]) {
6267 let doomed: Vec<Id> = inner
6268 .objects_ref("ReadPosition", account_id)
6269 .map(|positions| {
6270 positions
6271 .iter()
6272 .filter(|(_, v)| {
6273 v.get("chatId")
6274 .and_then(|c| c.as_str())
6275 .is_some_and(|c| chat_ids.iter().any(|id| id.as_ref() == c))
6276 })
6277 .map(|(id, _)| id.clone())
6278 .collect()
6279 })
6280 .unwrap_or_default();
6281 if doomed.is_empty() {
6282 return;
6283 }
6284 let positions = inner.objects_mut("ReadPosition", account_id);
6285 for id in &doomed {
6286 positions.remove(id);
6287 }
6288 let new_state = inner.bump_state("ReadPosition", account_id);
6289 inner
6290 .change_log_mut("ReadPosition", account_id)
6291 .push(ChangeEntry {
6292 new_state,
6293 created: vec![],
6294 updated: vec![],
6295 destroyed: doomed,
6296 restored: vec![],
6297 updated_props: None,
6298 });
6299}
6300
6301fn channel_belongs_to_space(inner: &Inner, account_id: &str, chat_id: &Id, space_id: &Id) -> bool {
6304 inner
6305 .objects_ref("Chat", account_id)
6306 .and_then(|m| m.get(chat_id))
6307 .map(|v| {
6308 v.get("kind").and_then(|k| k.as_str()) == Some("channel")
6309 && v.get("spaceId").and_then(|s| s.as_str()) == Some(space_id.as_ref())
6310 })
6311 .unwrap_or(false)
6312}
6313
6314fn scan_channels_in_category(inner: &Inner, account_id: &str, target_id: &Id) -> Vec<Id> {
6316 let Some(chats) = inner.objects_ref("Chat", account_id) else {
6317 return Vec::new();
6318 };
6319 chats
6320 .iter()
6321 .filter(|(_, v)| {
6322 v.get("kind").and_then(|k| k.as_str()) == Some("channel")
6323 && v.get("categoryId").and_then(|c| c.as_str()) == Some(target_id.as_ref())
6324 })
6325 .map(|(id, _)| id.clone())
6326 .collect()
6327}
6328
6329fn remove_from_categories<S: AsRef<str>>(cats: &mut [serde_json::Value], ids: &[S]) {
6333 for cat in cats {
6334 if let Some(ch_ids) = cat.get_mut("channelIds").and_then(|v| v.as_array_mut()) {
6335 ch_ids.retain(|v| {
6336 v.as_str()
6337 .is_none_or(|s| !ids.iter().any(|id| id.as_ref() == s))
6338 });
6339 }
6340 }
6341}
6342
6343fn set_channel_category(inner: &mut Inner, account_id: &str, chat_id: &Id, new_cat: Option<&Id>) {
6347 let map = inner.objects_mut("Chat", account_id);
6348 let Some(chat_val) = map.get_mut(chat_id) else {
6349 return;
6350 };
6351 let obj = match chat_val {
6352 serde_json::Value::Object(o) => o,
6353 _ => return,
6354 };
6355 match new_cat {
6356 Some(cat_id) => {
6357 obj.insert(
6358 "categoryId".to_owned(),
6359 serde_json::Value::String(cat_id.as_ref().to_owned()),
6360 );
6361 }
6362 None => {
6363 obj.remove("categoryId");
6364 }
6365 }
6366}
6367
6368fn stub_description(op: &SpacePatchOp) -> String {
6378 let _ = op;
6379 "unknown SpacePatchOp variant (tracked under bd:JMAP-g7wu.2.4)".to_owned()
6380}
6381
6382fn variant_name(op: &SpacePatchOp) -> &'static str {
6383 match op {
6384 SpacePatchOp::AddRole(_) => "AddRole",
6385 SpacePatchOp::RemoveRole(_) => "RemoveRole",
6386 SpacePatchOp::UpdateRole { .. } => "UpdateRole",
6387 SpacePatchOp::AddMember(_) => "AddMember",
6388 SpacePatchOp::RemoveMember(_) => "RemoveMember",
6389 SpacePatchOp::UpdateMember { .. } => "UpdateMember",
6390 SpacePatchOp::AddChannel(_) => "AddChannel",
6391 SpacePatchOp::RemoveChannel(_) => "RemoveChannel",
6392 SpacePatchOp::UpdateChannel { .. } => "UpdateChannel",
6393 SpacePatchOp::AddCategory(_) => "AddCategory",
6394 SpacePatchOp::RemoveCategory(_) => "RemoveCategory",
6395 SpacePatchOp::UpdateCategory { .. } => "UpdateCategory",
6396 _ => "Unknown",
6397 }
6398}
6399
6400#[cfg(all(feature = "testkit", feature = "test-helpers"))]
6404macro_rules! conformance_backend {
6405 ($ctx:ty, $doc:literal, |$account:ident| $caller:expr) => {
6406 impl crate::testkit::ConformanceBackend for MemoryBackend<$ctx> {
6407 #[doc = $doc]
6408 fn caller(&self, $account: &Id) -> $ctx {
6409 $caller
6410 }
6411
6412 async fn add_account(&self, account_id: &Id, owner_user_id: &str) {
6413 self.register_account(account_id);
6414 self.set_owner_user_id_for_test(account_id, owner_user_id);
6415 }
6416
6417 async fn seed(
6421 &self,
6422 account_id: &Id,
6423 type_name: &'static str,
6424 object: serde_json::Value,
6425 ) {
6426 let id = object["id"]
6427 .as_str()
6428 .unwrap_or_else(|| {
6429 panic!("seed: {type_name} object has no `id` string: {object}")
6430 })
6431 .to_owned();
6432 self.insert_object_for_test(type_name, account_id.as_ref(), &id, object);
6433 }
6434
6435 fn take_outbound_events(&self) -> Option<Vec<crate::OutboundEvent>> {
6436 Some(self.take_outbound_events_for_test())
6437 }
6438 }
6439 };
6440}
6441
6442#[cfg(all(feature = "testkit", feature = "test-helpers"))]
6443conformance_backend!(
6444 (),
6445 "A caller without identity: every request acts as every account's owner.",
6446 |_account_id| ()
6447);
6448
6449#[cfg(all(feature = "testkit", feature = "test-helpers"))]
6450conformance_backend!(
6451 Id,
6452 "The account id: the owner's Space member id (draft-atwood-jmap-chat-00 §Terminology).",
6453 |account_id| account_id.clone()
6454);
6455
6456impl<C: MemoryCaller> ConditionalBackend for MemoryBackend<C> {
6469 async fn begin_set(
6470 &self,
6471 _caller: &C,
6472 request: SetScopeRequest<'_>,
6473 ) -> Result<Box<dyn SetScope>, BeginSetError<MemoryError>> {
6474 Ok(self.inner.open(request, final_state_failures).await)
6475 }
6476}
6477
6478fn final_state_failures(before: &Inner, after: &Inner) -> Vec<DeferredFailure> {
6492 let mut failures = Vec::new();
6493 let scope = |e: &serde_json::Value| e.get("spaceId").filter(|v| !v.is_null()).cloned();
6494 {
6495 let (type_name, property) = ("CustomEmoji", "name");
6496 for (account, objects) in after.objects.get(type_name).into_iter().flatten() {
6497 let old = before.objects_ref(type_name, account);
6498 for (id, obj) in objects {
6499 let op = match old.and_then(|o| o.get(id)) {
6500 None => SetOp::Create(id.clone()),
6501 Some(prev) if prev != obj => SetOp::Update(id.clone()),
6502 Some(_) => continue,
6503 };
6504 let clash = objects.iter().find(|(other, o)| {
6505 *other != id && o.get(property) == obj.get(property) && scope(o) == scope(obj)
6506 });
6507 if let Some((existing, _)) = clash {
6508 let error = match op {
6509 SetOp::Create(_) => SetError::new(SetErrorType::AlreadyExists)
6510 .with_existing_id(existing.clone()),
6511 _ => SetError::new(SetErrorType::InvalidProperties)
6512 .with_properties([property]),
6513 };
6514 failures.push(DeferredFailure::new(op, error));
6515 }
6516 }
6517 }
6518 }
6519 if let Some(max) = after
6520 .limits_override
6521 .unwrap_or_default()
6522 .max_custom_emoji_per_space
6523 {
6524 for (account, objects) in after.objects.get("CustomEmoji").into_iter().flatten() {
6525 let old = before.objects_ref("CustomEmoji", account);
6526 for (id, obj) in objects {
6527 let Some(space) = emoji_scope(obj) else {
6528 continue;
6529 };
6530 let created = old.is_none_or(|o| !o.contains_key(id));
6531 let reported = failures
6532 .iter()
6533 .any(|f| matches!(&f.op, SetOp::Create(c) if c == id));
6534 if created
6535 && !reported
6536 && emoji_count_in_space(after, account, &space) > u64::from(max)
6537 {
6538 failures.push(DeferredFailure::new(
6539 SetOp::Create(id.clone()),
6540 SetError::new(SetErrorType::OverQuota)
6541 .with_description(crate::emoji::TOO_MANY_EMOJI),
6542 ));
6543 }
6544 }
6545 }
6546 }
6547 if after.push_subscriptions.len() > MAX_PUSH_SUBSCRIPTIONS {
6548 for id in after.push_subscriptions.keys() {
6549 if !before.push_subscriptions.contains_key(id) {
6550 failures.push(DeferredFailure::new(
6551 SetOp::Create(id.clone()),
6552 SetError::new(SetErrorType::OverQuota).with_description(format!(
6553 "at most {MAX_PUSH_SUBSCRIPTIONS} push subscriptions per user"
6554 )),
6555 ));
6556 }
6557 }
6558 }
6559 failures
6560}
6561
6562#[cfg(test)]
6563mod tests {
6564 use super::*;
6565
6566 use jmap_chat_types::ChatContact;
6567 use std::collections::HashSet;
6568
6569 #[tokio::test]
6575 async fn get_changes_dedups_ids_across_window() {
6576 let backend = MemoryBackend::<()>::default();
6577 let id = |s: &str| Id::from(s);
6578 {
6579 let mut inner = backend.inner.lock_unscoped();
6580 let log = inner.change_log_mut(ChatContact::TYPE_NAME, "acc1");
6581 log.push(ChangeEntry {
6582 new_state: 1,
6583 created: vec![id("eph"), id("fresh")],
6584 updated: vec![],
6585 destroyed: vec![],
6586 restored: vec![],
6587 updated_props: None,
6588 });
6589 log.push(ChangeEntry {
6590 new_state: 2,
6591 created: vec![],
6592 updated: vec![id("fresh"), id("old"), id("doomed")],
6593 destroyed: vec![id("eph")],
6594 restored: vec![],
6595 updated_props: None,
6596 });
6597 log.push(ChangeEntry {
6598 new_state: 3,
6599 created: vec![],
6600 updated: vec![id("old")],
6601 destroyed: vec![id("doomed"), id("gone")],
6602 restored: vec![],
6603 updated_props: None,
6604 });
6605 }
6606
6607 let changes = backend
6608 .get_changes::<ChatContact>(
6609 &(),
6610 &id("acc1"),
6611 jmap_server::ChangesParams::new(&State::from("0")),
6612 )
6613 .await
6614 .expect("get_changes must succeed");
6615
6616 assert_eq!(changes.created, vec![id("fresh")]);
6617 assert_eq!(changes.updated, vec![id("old")]);
6618 assert_eq!(changes.destroyed, vec![id("doomed"), id("gone")]);
6619 }
6620
6621 #[tokio::test]
6627 async fn get_changes_lists_created_and_destroyed_message_in_destroyed() {
6628 let backend = MemoryBackend::<()>::default();
6629 let id = |s: &str| Id::from(s);
6630 {
6631 let mut inner = backend.inner.lock_unscoped();
6632 let log = inner.change_log_mut(jmap_chat_types::Message::TYPE_NAME, "acc1");
6633 log.push(ChangeEntry {
6634 new_state: 1,
6635 created: vec![id("burnt"), id("kept")],
6636 updated: vec![],
6637 destroyed: vec![],
6638 restored: vec![],
6639 updated_props: None,
6640 });
6641 log.push(ChangeEntry {
6642 new_state: 2,
6643 created: vec![],
6644 updated: vec![id("burnt")],
6645 destroyed: vec![],
6646 restored: vec![],
6647 updated_props: None,
6648 });
6649 log.push(ChangeEntry {
6650 new_state: 3,
6651 created: vec![],
6652 updated: vec![],
6653 destroyed: vec![id("burnt")],
6654 restored: vec![],
6655 updated_props: None,
6656 });
6657 }
6658
6659 let changes = backend
6660 .get_changes::<jmap_chat_types::Message>(
6661 &(),
6662 &id("acc1"),
6663 jmap_server::ChangesParams::new(&State::from("0")),
6664 )
6665 .await
6666 .expect("get_changes must succeed");
6667
6668 assert_eq!(changes.created, vec![id("kept")]);
6669 assert!(changes.updated.is_empty());
6670 assert_eq!(changes.destroyed, vec![id("burnt")]);
6671 }
6672
6673 #[test]
6677 fn compare_by_sort_orders_utc_dates_chronologically() {
6678 use serde_json::json;
6679 let comparators = [json!({ "property": "receivedAt", "isAscending": true })];
6680 let mut msgs = [
6681 json!({ "id": "c", "receivedAt": "2026-01-01T00:00:01.001Z" }),
6682 json!({ "id": "b", "receivedAt": "2026-01-01T00:00:01Z" }),
6683 json!({ "id": "a", "receivedAt": "2026-01-01T00:00:00.999Z" }),
6684 json!({ "id": "d", "receivedAt": "2026-01-01T00:00:01.01Z" }),
6685 ];
6686 msgs.sort_by(|x, y| compare_by_sort(x, y, &comparators));
6687 let ids: Vec<&str> = msgs.iter().map(|m| m["id"].as_str().unwrap()).collect();
6688 assert_eq!(ids, ["a", "b", "c", "d"]);
6689
6690 let descending = [json!({ "property": "receivedAt", "isAscending": false })];
6691 msgs.sort_by(|x, y| compare_by_sort(x, y, &descending));
6692 let ids: Vec<&str> = msgs.iter().map(|m| m["id"].as_str().unwrap()).collect();
6693 assert_eq!(ids, ["d", "c", "b", "a"]);
6694 }
6695
6696 #[tokio::test]
6710 async fn generate_invite_code_is_csprng() {
6711 let backend = MemoryBackend::<()>::default();
6712 const N: usize = 256;
6713 let mut codes: HashSet<String> = HashSet::with_capacity(N);
6714 for _ in 0..N {
6715 let code = backend
6716 .generate_invite_code(&(), &Id::from("acct"))
6717 .await
6718 .expect("OS CSPRNG available in tests");
6719 codes.insert(code);
6720 }
6721 assert_eq!(
6725 codes.len(),
6726 N,
6727 "expected {N} distinct invite codes; found {} duplicates",
6728 N - codes.len()
6729 );
6730 for c in &codes {
6732 assert_eq!(
6733 c.len(),
6734 32,
6735 "invite code must be 32 hex chars (16 random bytes); got len {} ({})",
6736 c.len(),
6737 c
6738 );
6739 assert!(
6740 c.chars().all(|ch| ch.is_ascii_hexdigit()),
6741 "invite code must be lowercase hex; got {c}"
6742 );
6743 }
6744 let sorted: Vec<&String> = {
6750 let mut v: Vec<&String> = codes.iter().collect();
6751 v.sort();
6752 v
6753 };
6754 let max_prefix: usize = sorted
6755 .windows(2)
6756 .map(|w| {
6757 w[0].as_bytes()
6758 .iter()
6759 .zip(w[1].as_bytes())
6760 .take_while(|(a, b)| a == b)
6761 .count()
6762 })
6763 .max()
6764 .unwrap_or(0);
6765 assert!(
6768 max_prefix < 10,
6769 "max shared prefix across sorted codes is {max_prefix}; >=10 suggests timestamp-derived output (bd:JMAP-sc1b.93 regression)"
6770 );
6771 }
6772
6773 #[test]
6776 fn base64url_unpadded_matches_rfc4648_vectors() {
6777 for (input, expected) in [
6778 ("", ""),
6779 ("f", "Zg"),
6780 ("fo", "Zm8"),
6781 ("foo", "Zm9v"),
6782 ("foob", "Zm9vYg"),
6783 ("fooba", "Zm9vYmE"),
6784 ("foobar", "Zm9vYmFy"),
6785 ] {
6786 assert_eq!(base64url_unpadded(input.as_bytes()), expected);
6787 }
6788 assert_eq!(base64url_unpadded(&[0xfb, 0xff, 0xbf]), "-_-_");
6789 }
6790
6791 }
6796
6797#[cfg(test)]
6798mod memory_error_tests {
6799 use super::MemoryError;
6800
6801 #[test]
6806 fn serde_error_display_omits_offending_value() {
6807 let canary = "alice@example.com";
6808 let e = serde_json::from_value::<u64>(serde_json::Value::String(canary.into()))
6809 .expect_err("a string is not a u64");
6810 assert!(
6811 e.to_string().contains(canary),
6812 "precondition: serde_json quotes the value"
6813 );
6814
6815 let shown = MemoryError::serde("decode", &e).to_string();
6816 assert!(!shown.contains(canary), "canary leaked: {shown}");
6817 assert!(
6818 shown.contains("decode") && shown.contains("Data"),
6819 "{shown}"
6820 );
6821 }
6822}
6823
6824#[cfg(test)]
6825mod clone_tests {
6826 use super::MemoryBackend;
6827 use jmap_types::Id;
6828
6829 #[test]
6833 fn clone_shares_store() {
6834 let a = MemoryBackend::<()>::default();
6835 let clone = a.clone();
6836 let fresh = MemoryBackend::<()>::default();
6837 a.register_account(&Id::from("acc"));
6838 let known = |b: &MemoryBackend<()>| b.inner.lock_unscoped().known_accounts.contains("acc");
6839 assert!(known(&clone), "a clone sees the original's writes");
6840 assert!(!known(&fresh), "a fresh backend does not");
6841 }
6842}
6843
6844#[cfg(test)]
6845mod fixture_helper_tests {
6846 use super::*;
6847 use serde_json::json;
6848
6849 #[tokio::test]
6853 async fn with_account_registers_account() {
6854 let acc = Id::from("acc1");
6855 let backend = MemoryBackend::<()>::default().with_account(&acc);
6856 assert!(backend.account_exists(&(), &acc).await.unwrap());
6857 assert!(
6858 !backend
6859 .account_exists(&(), &Id::from("acc2"))
6860 .await
6861 .unwrap()
6862 );
6863 }
6864
6865 #[tokio::test]
6868 async fn seed_object_is_readable_without_state_change() {
6869 let acc = Id::from("acc1");
6870 let backend = MemoryBackend::<()>::default();
6871 let before = backend
6872 .get_state::<jmap_chat_types::CustomEmoji>(&(), &acc)
6873 .await
6874 .unwrap();
6875 backend.seed_object(
6876 &acc,
6877 jmap_chat_types::CustomEmoji::TYPE_NAME,
6878 &Id::from("x1"),
6879 json!({"id": "x1", "name": "party", "blobId": "b1", "createdBy": "u1", "createdAt": "2026-01-01T00:00:00Z"}),
6880 );
6881 assert!(backend.account_exists(&(), &acc).await.unwrap());
6882 let (found, not_found) = backend
6883 .get_objects::<jmap_chat_types::CustomEmoji>(&(), &acc, Some(&[Id::from("x1")]), None)
6884 .await
6885 .unwrap();
6886 assert_eq!(found.len(), 1);
6887 assert!(not_found.is_empty());
6888 assert_eq!(
6889 backend
6890 .get_state::<jmap_chat_types::CustomEmoji>(&(), &acc)
6891 .await
6892 .unwrap(),
6893 before
6894 );
6895 }
6896
6897 #[test]
6898 #[should_panic(expected = "not one of the known")]
6899 fn seed_object_rejects_unknown_type_name() {
6900 MemoryBackend::<()>::default().seed_object(
6901 &Id::from("acc1"),
6902 "NoSuchType",
6903 &Id::from("x1"),
6904 json!({"id": "x1"}),
6905 );
6906 }
6907
6908 #[test]
6909 #[should_panic(expected = "does not match the `id` argument")]
6910 fn seed_object_rejects_id_mismatch() {
6911 MemoryBackend::<()>::default().seed_object(
6912 &Id::from("acc1"),
6913 jmap_chat_types::CustomEmoji::TYPE_NAME,
6914 &Id::from("x1"),
6915 json!({"id": "other"}),
6916 );
6917 }
6918}
6919
6920#[cfg(all(test, debug_assertions))]
6921mod empty_account_id_tests {
6922 use super::{Id, MemoryBackend};
6923
6924 #[test]
6927 #[should_panic(expected = "account_id must not be the empty string")]
6928 fn register_account_rejects_empty_id() {
6929 MemoryBackend::<()>::default().register_account(&Id::from(""));
6930 }
6931}
6932
6933#[cfg(test)]
6934mod max_changes_tests {
6935 use super::*;
6936 use jmap_chat_types::ChatContact as T;
6937
6938 const CALLER: () = ();
6939
6940 fn with_creates(states: &[&[&str]]) -> MemoryBackend<()> {
6943 let backend = MemoryBackend::<()>::default();
6944 let mut inner = backend.inner.lock_unscoped();
6945 for ids in states {
6946 let new_state = inner.bump_state(T::TYPE_NAME, "acc1");
6947 inner
6948 .change_log_mut(T::TYPE_NAME, "acc1")
6949 .push(ChangeEntry {
6950 new_state,
6951 created: ids.iter().map(|s| Id::from(*s)).collect(),
6952 updated: vec![],
6953 destroyed: vec![],
6954 restored: vec![],
6955 updated_props: None,
6956 });
6957 }
6958 drop(inner);
6959 backend
6960 }
6961
6962 #[tokio::test]
6970 async fn over_max_changes_pages_through_intermediate_state() {
6971 let backend = with_creates(&[&["a"], &["b"], &["c"]]);
6972
6973 let first = changes(&backend, "0", 2).await.expect("first page");
6974 assert_eq!(sorted(first.created), [Id::from("a"), Id::from("b")]);
6975 assert!(first.has_more_changes);
6976 assert_eq!(first.new_state.as_ref(), "2");
6977
6978 let rest = changes(&backend, "2", 2).await.expect("second page");
6979 assert_eq!(rest.created, [Id::from("c")]);
6980 assert!(!rest.has_more_changes);
6981 assert_eq!(rest.new_state.as_ref(), "3");
6982 }
6983
6984 #[tokio::test]
6989 async fn one_state_over_max_changes_cannot_calculate() {
6990 let backend = with_creates(&[&["a", "b", "c"]]);
6991 assert!(matches!(
6992 changes(&backend, "0", 2).await,
6993 Err(BackendChangesError::TooManyChanges { limit: 2 })
6994 ));
6995 }
6996
6997 fn sorted(mut ids: Vec<Id>) -> Vec<Id> {
6998 ids.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
6999 ids
7000 }
7001
7002 async fn changes(
7003 backend: &MemoryBackend<()>,
7004 since: &str,
7005 max: u64,
7006 ) -> Result<ChangesResult, BackendChangesError<<MemoryBackend<()> as JmapAccounts>::Error>>
7007 {
7008 backend
7009 .get_changes::<T>(
7010 &CALLER,
7011 &Id::from("acc1"),
7012 jmap_server::ChangesParams::new(&State::from(since)).max_changes(Some(max)),
7013 )
7014 .await
7015 }
7016}
7017
7018#[cfg(test)]
7027mod emoji_cap_tests {
7028 use super::*;
7029
7030 fn emoji(name: &str, space: &str) -> serde_json::Value {
7031 serde_json::json!({ "name": name, "blobId": "b", "spaceId": space })
7032 }
7033
7034 #[test]
7035 fn final_state_over_the_cap_fails_only_the_creates() {
7036 let mut before = Inner {
7037 limits_override: Some(ChatLimits::default().with_max_custom_emoji_per_space(Some(1))),
7038 ..Inner::default()
7039 };
7040 before
7041 .objects_mut("CustomEmoji", "acc1")
7042 .insert(Id::from("old"), emoji("old", "s1"));
7043 let mut after = before.clone();
7044 after
7045 .objects_mut("CustomEmoji", "acc1")
7046 .insert(Id::from("new"), emoji("new", "s1"));
7047 after
7048 .objects_mut("CustomEmoji", "acc1")
7049 .insert(Id::from("elsewhere"), emoji("new", "s2"));
7050
7051 let failures = final_state_failures(&before, &after);
7052 assert_eq!(failures.len(), 1, "{failures:?}");
7053 assert_eq!(failures[0].op, SetOp::Create(Id::from("new")));
7054 assert_eq!(failures[0].error.error_type, SetErrorType::OverQuota);
7055
7056 after
7058 .objects_mut("CustomEmoji", "acc1")
7059 .remove(&Id::from("old"));
7060 assert!(final_state_failures(&before, &after).is_empty());
7061 }
7062}