#![allow(async_fn_in_trait)]
#![deny(clippy::await_holding_lock)]
mod history;
use std::collections::{BTreeSet, HashMap, HashSet};
use std::marker::PhantomData;
use std::sync::{Arc, Mutex};
use crate::{
AttachmentBlob, ChatAccessPolicy, ChatEvents, ChatLimits, ChatMessageLifecycle, ChatModeration,
ChatResolvers, ChatRestrictions, ChatSettings, ChatSpaces, ChatStore, EmojiSetOp,
InviteJoinRefusal, OpResult, SlowModeError, SpacePatchOp, SpacePolicy,
strip_unsupported_chat_push, validate_chat_push,
};
use jmap_chat_types::{ChatPermission, ChatPushCapability};
use jmap_metadata_server::{
ChangedProperties, MetadataCondition, MetadataFilterError, MetadataOnlyChanges, SetKind,
changed_properties, check_metadata_depth, check_metadata_write, is_metadata_property,
};
use jmap_metadata_types::DataTypeMetadataInfo;
use jmap_object_history_server::{ChangeEvent, ChangeKind, fold_restore};
use jmap_server::{
AddedItem, BackendChangesError, BackendQueryError, BackendSetError, ChangesResult, GetObject,
JmapAccounts, JmapObject, JmapReads, MemoryCaller, QueryChangesParams, QueryChangesResult,
QueryObject, QueryParams, QueryResult, SetError, SetErrorType, SetObject,
};
use jmap_server::{
BeginSetError, ConditionalBackend, DeferredFailure, MergePatchError, PatchPathError,
PushSubscriptionBackend, ScopedState, SetOp, SetScope, SetScopeRequest, StoredPushSubscription,
apply_patch_object, check_patch_paths, json_merge_patch, limit_or_max, now_utc_string,
resolve_query_start,
};
use jmap_types::{Id, PushSubscription, State};
pub const MAX_PUSH_SUBSCRIPTIONS: usize = 50;
#[derive(Debug, Clone, Copy)]
enum IdFate {
Created,
Updated,
Destroyed,
}
#[derive(Clone, Debug)]
struct ChangeEntry {
new_state: u64,
created: Vec<Id>,
updated: Vec<Id>,
destroyed: Vec<Id>,
updated_props: Option<BTreeSet<String>>,
restored: Vec<Id>,
}
impl ChangeEntry {
fn is_metadata_only_update(&self) -> bool {
self.created.is_empty()
&& self.destroyed.is_empty()
&& self.updated_props.as_ref().is_some_and(|props| {
!props.is_empty() && props.iter().all(|p| is_metadata_property(p))
})
}
}
#[derive(Default, Clone)]
struct Inner {
objects: HashMap<&'static str, HashMap<String, HashMap<Id, serde_json::Value>>>,
states: HashMap<&'static str, HashMap<String, u64>>,
change_log: HashMap<&'static str, HashMap<String, Vec<ChangeEntry>>>,
change_log_floor: HashMap<&'static str, HashMap<String, u64>>,
change_log_limit: Option<usize>,
event_limit: Option<usize>,
known_accounts: HashSet<String>,
limits_override: Option<ChatLimits>,
attachment_blobs: HashMap<(String, Id), AttachmentBlob>,
retains_edit_history: bool,
maintains_unread_count: bool,
protect_last_admin: bool,
owner_user_ids: HashMap<String, String>,
push_subscriptions: HashMap<Id, StoredPushSubscription>,
chat_push_caps: HashMap<Id, ChatPushCapability>,
space_extension_properties: &'static [&'static str],
lifecycle_events: Vec<LifecycleEvent>,
outbound_events: Vec<crate::OutboundEvent>,
everyone_permissions: HashSet<ChatPermission>,
space_everyone_permissions: HashMap<String, HashSet<ChatPermission>>,
ids: Arc<Mutex<ulid::Generator>>,
metadata_info: HashMap<&'static str, DataTypeMetadataInfo>,
search: Option<jmap_search::SearchCapability>,
history: Option<jmap_object_history_server::HistoryStore>,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub enum LifecycleEvent {
ChatDestroyed(Id),
SpaceDestroyed(Id),
SpaceBanCreated(jmap_chat_types::SpaceBan),
}
impl Inner {
fn mint_id(&mut self) -> Id {
let ulid = self
.ids
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.generate()
.expect("80 random ULID bits cannot overflow within one millisecond in practice");
Id::from(ulid.to_string())
}
fn everyone_for(&self, space_id: &str) -> &HashSet<ChatPermission> {
self.space_everyone_permissions
.get(space_id)
.unwrap_or(&self.everyone_permissions)
}
fn everyone_in(&self, space_val: &serde_json::Value) -> &HashSet<ChatPermission> {
self.everyone_for(
space_val
.get("id")
.and_then(|v| v.as_str())
.unwrap_or_default(),
)
}
fn current_state(&self, type_name: &'static str, account_id: &str) -> u64 {
self.states
.get(type_name)
.and_then(|m| m.get(account_id))
.copied()
.unwrap_or(0)
}
fn bump_state(&mut self, type_name: &'static str, account_id: &str) -> u64 {
let entry = self
.states
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_insert(0);
*entry += 1;
*entry
}
fn objects_mut(
&mut self,
type_name: &'static str,
account_id: &str,
) -> &mut HashMap<Id, serde_json::Value> {
self.objects
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default()
}
fn require_account(&self, account_id: &str) -> Result<(), BackendSetError<MemoryError>> {
if self.known_accounts.contains(account_id) {
Ok(())
} else {
Err(BackendSetError::Other(MemoryError::new(format!(
"unknown account {account_id:?}"
))))
}
}
fn require_account_for_target(
&self,
account_id: &str,
) -> Result<(), BackendSetError<MemoryError>> {
if self.known_accounts.contains(account_id) {
Ok(())
} else {
Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))))
}
}
fn objects_ref(
&self,
type_name: &'static str,
account_id: &str,
) -> Option<&HashMap<Id, serde_json::Value>> {
self.objects.get(type_name).and_then(|m| m.get(account_id))
}
fn change_log_mut(
&mut self,
type_name: &'static str,
account_id: &str,
) -> &mut Vec<ChangeEntry> {
let limit = self.change_log_limit;
let log = self
.change_log
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default();
if let Some(limit) = limit
&& log.len() >= limit
{
let excess = log.len() + 1 - limit.max(1);
let n = excess.min(log.len());
let dropped_to = n.checked_sub(1).map(|i| log[i].new_state);
log.drain(..n);
if let Some(floor) = dropped_to {
let slot = self
.change_log_floor
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default();
*slot = (*slot).max(floor);
}
}
self.change_log
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default()
}
fn push_capped<T>(list: &mut Vec<T>, event: T, limit: Option<usize>) {
list.push(event);
if let Some(limit) = limit
&& list.len() > limit
{
let excess = list.len() - limit;
list.drain(..excess);
}
}
}
#[non_exhaustive]
pub struct MemoryBackend<C = Id> {
inner: ScopedState<Inner>,
caller: PhantomData<fn() -> C>,
}
impl<C> Clone for MemoryBackend<C> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
caller: PhantomData,
}
}
}
impl<C> Default for MemoryBackend<C> {
fn default() -> Self {
Self {
inner: ScopedState::new(Inner {
everyone_permissions: HashSet::from([ChatPermission::View, ChatPermission::Send]),
..Inner::default()
}),
caller: PhantomData,
}
}
}
impl MemoryBackend {
pub fn new() -> Self {
Self::default()
}
}
impl<C: MemoryCaller> MemoryBackend<C> {
#[must_use]
pub fn with_metadata_info(self, data_type: &str, info: DataTypeMetadataInfo) -> Self {
let type_name = metadata_type_name(data_type).unwrap_or_else(|| {
panic!(
"MemoryBackend supports metadata only on Chat, Message and Space, not {data_type:?}"
)
});
assert!(
!info.supports_private,
"MemoryBackend does not support privateMetadata (supportsPrivate must be false)"
);
self.inner
.lock_unscoped()
.metadata_info
.insert(type_name, info);
self
}
#[must_use]
pub fn with_search_capability(self, capability: jmap_search::SearchCapability) -> Self {
self.inner.lock_unscoped().search = Some(capability);
self
}
pub fn set_everyone_permissions(&self, permissions: HashSet<ChatPermission>) {
self.inner.lock_unscoped().everyone_permissions = permissions;
}
pub fn set_space_everyone_permissions(
&self,
space_id: &Id,
permissions: HashSet<ChatPermission>,
) {
self.inner
.lock_unscoped()
.space_everyone_permissions
.insert(space_id.to_string(), permissions);
}
#[doc(hidden)]
pub fn register_account(&self, account_id: &Id) {
debug_assert!(
!account_id.as_ref().is_empty(),
"register_account: account_id must not be the empty string \
(RFC 8620 §1.2, bd:JMAP-dx0s)"
);
let mut inner = self.inner.lock_unscoped();
inner.known_accounts.insert(account_id.as_ref().to_owned());
}
#[must_use]
pub fn with_account(self, account_id: &Id) -> Self {
self.register_account(account_id);
self
}
pub fn seed_object(
&self,
account_id: &Id,
type_name: &'static str,
id: &Id,
value: serde_json::Value,
) {
const KNOWN_TYPES: &[&str] = &[
jmap_chat_types::Chat::TYPE_NAME,
jmap_chat_types::Message::TYPE_NAME,
jmap_chat_types::Space::TYPE_NAME,
jmap_chat_types::ChatContact::TYPE_NAME,
jmap_chat_types::ReadPosition::TYPE_NAME,
jmap_chat_types::CustomEmoji::TYPE_NAME,
jmap_chat_types::SpaceInvite::TYPE_NAME,
jmap_chat_types::SpaceBan::TYPE_NAME,
jmap_chat_types::ChatBan::TYPE_NAME,
jmap_chat_types::PresenceStatus::TYPE_NAME,
];
assert!(
KNOWN_TYPES.contains(&type_name),
"seed_object: type_name {type_name:?} is not one of the known \
TYPE_NAME values {KNOWN_TYPES:?}"
);
let obj = value.as_object().unwrap_or_else(|| {
panic!("seed_object: value must be a JSON object with an `id` field, got {value:?}")
});
let value_id = obj
.get("id")
.and_then(serde_json::Value::as_str)
.unwrap_or_else(|| {
panic!(
"seed_object: value must contain an `id` string field; got value = {value:?}"
)
});
assert_eq!(
value_id,
id.as_ref(),
"seed_object: value's `id` field {value_id:?} does not match the \
`id` argument {id:?}"
);
let account = account_id.as_ref();
let mut inner = self.inner.lock_unscoped();
inner.known_accounts.insert(account.to_owned());
inner
.objects_mut(type_name, account)
.insert(id.clone(), value);
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_retains_edit_history_for_test(&self, retain: bool) {
let mut inner = self.inner.lock_unscoped();
inner.retains_edit_history = retain;
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_maintains_unread_count_for_test(&self, value: bool) {
let mut inner = self.inner.lock_unscoped();
inner.maintains_unread_count = value;
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_protect_last_admin_for_test(&self, value: bool) {
let mut inner = self.inner.lock_unscoped();
inner.protect_last_admin = value;
}
async fn record_lifecycle_event(&self, event: LifecycleEvent) {
let mut inner = self.inner.lock().await;
let limit = inner.event_limit;
Inner::push_capped(&mut inner.lifecycle_events, event, limit);
}
pub fn mint_id(&self) -> Id {
self.inner.lock_unscoped().mint_id()
}
pub async fn insert_object<O: SetObject + Send + Sync>(
&self,
account_id: &Id,
object: O,
) -> Result<O, BackendSetError<MemoryError>> {
let val = serde_json::to_value(&object)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
let id = object_id_of(&val)?;
let mut inner = self.inner.lock().await;
reject_taken_id(&inner, O::TYPE_NAME, account_id, &id)?;
let defer = self.inner.deferring();
insert_created(&mut inner, O::TYPE_NAME, account_id, &id, val, defer)?;
Ok(object)
}
pub async fn insert_message(
&self,
account_id: &Id,
message: jmap_chat_types::Message,
) -> Result<jmap_chat_types::Message, BackendSetError<MemoryError>> {
let val = serde_json::to_value(&message)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
let id = object_id_of(&val)?;
let mut inner = self.inner.lock().await;
reject_taken_id(&inner, "Message", account_id, &id)?;
let defer = self.inner.deferring();
insert_created(&mut inner, "Message", account_id, &id, val, defer)?;
let limit = inner.event_limit;
Inner::push_capped(
&mut inner.outbound_events,
crate::OutboundEvent::NewMessage {
chat_id: message.chat_id.clone(),
message_id: message.id.clone(),
sender_msg_id: message.sender_msg_id.clone(),
},
limit,
);
Ok(message)
}
#[must_use]
pub fn with_change_log_limit(self, limit: usize) -> Self {
self.inner.lock_unscoped().change_log_limit = Some(limit);
self
}
#[must_use]
pub fn with_event_limit(self, limit: usize) -> Self {
self.inner.lock_unscoped().event_limit = Some(limit);
self
}
pub fn drain_lifecycle_events(&self) -> Vec<LifecycleEvent> {
std::mem::take(&mut self.inner.lock_unscoped().lifecycle_events)
}
pub fn drain_outbound_events(&self) -> Vec<crate::OutboundEvent> {
std::mem::take(&mut self.inner.lock_unscoped().outbound_events)
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn take_lifecycle_events_for_test(&self) -> Vec<LifecycleEvent> {
std::mem::take(&mut self.inner.lock_unscoped().lifecycle_events)
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn take_outbound_events_for_test(&self) -> Vec<crate::OutboundEvent> {
std::mem::take(&mut self.inner.lock_unscoped().outbound_events)
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_space_extension_properties_for_test(&self, keys: &'static [&'static str]) {
let mut inner = self.inner.lock_unscoped();
inner.space_extension_properties = keys;
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_owner_user_id_for_test(&self, account_id: &Id, owner_user_id: &str) {
let mut inner = self.inner.lock_unscoped();
inner
.owner_user_ids
.insert(account_id.as_ref().to_owned(), owner_user_id.to_owned());
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_chat_push_capability_for_test(
&self,
account_id: &Id,
cap: Option<ChatPushCapability>,
) {
let mut inner = self.inner.lock_unscoped();
match cap {
Some(cap) => inner.chat_push_caps.insert(account_id.clone(), cap),
None => inner.chat_push_caps.remove(account_id),
};
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_limits_for_test(&self, limits: Option<ChatLimits>) {
let mut inner = self.inner.lock_unscoped();
inner.limits_override = limits;
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn set_attachment_blob_for_test(
&self,
account_id: &str,
blob_id: &str,
blob: Option<AttachmentBlob>,
) {
let mut inner = self.inner.lock_unscoped();
let key = (account_id.to_owned(), Id::from(blob_id));
match blob {
Some(b) => inner.attachment_blobs.insert(key, b),
None => inner.attachment_blobs.remove(&key),
};
}
#[doc(hidden)]
#[cfg(feature = "test-helpers")]
pub fn insert_object_for_test(
&self,
type_name: &'static str,
account_id: &str,
id: &str,
value: serde_json::Value,
) {
let mut inner = self.inner.lock_unscoped();
inner.known_accounts.insert(account_id.to_owned());
inner
.objects_mut(type_name, account_id)
.insert(Id::from(id), value);
}
#[doc(hidden)]
pub fn first_category_id(&self, space_id: &Id) -> Id {
let inner = self.inner.lock_unscoped();
for map in inner
.objects
.get("Space")
.into_iter()
.flat_map(HashMap::values)
{
if let Some(space) = map.get(space_id) {
let cats = space
.get("categories")
.and_then(|v| v.as_array())
.expect("Space.categories must be an array");
let id = cats
.first()
.and_then(|c| c.get("id"))
.and_then(|id| id.as_str())
.expect("Space has at least one category");
return Id::from(id);
}
}
panic!("Space {space_id} not found");
}
#[doc(hidden)]
pub fn peek_chat(&self, chat_id: &Id) -> serde_json::Value {
let inner = self.inner.lock_unscoped();
for map in inner
.objects
.get("Chat")
.into_iter()
.flat_map(HashMap::values)
{
if let Some(chat) = map.get(chat_id) {
return chat.clone();
}
}
panic!("Chat {chat_id} not found");
}
}
#[non_exhaustive]
#[derive(Debug)]
pub struct MemoryError {
description: String,
}
impl MemoryError {
pub fn new(description: impl Into<String>) -> Self {
Self {
description: description.into(),
}
}
pub fn description(&self) -> &str {
&self.description
}
pub(crate) fn serde(context: impl std::fmt::Display, e: &serde_json::Error) -> Self {
Self::new(format!("{context}: serde_json {:?} error", e.classify()))
}
}
impl std::fmt::Display for MemoryError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "MemoryBackend error: {}", self.description)
}
}
impl std::error::Error for MemoryError {}
impl<C: MemoryCaller> JmapAccounts for MemoryBackend<C> {
type Error = MemoryError;
type CallerCtx = C;
fn principal_id(caller: &C) -> Option<&Id> {
caller.principal()
}
fn metadata_info<O: JmapObject>(
&self,
_caller: &C,
_account_id: &Id,
) -> Option<DataTypeMetadataInfo> {
self.inner
.lock_unscoped()
.metadata_info
.get(O::TYPE_NAME)
.cloned()
}
async fn account_exists(&self, _caller: &C, account_id: &Id) -> Result<bool, Self::Error> {
let inner = self.inner.lock().await;
Ok(inner.known_accounts.contains(account_id.as_ref()))
}
}
impl<C: MemoryCaller> JmapReads for MemoryBackend<C> {
async fn get_objects<O: GetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
ids: Option<&[Id]>,
_properties: Option<&[String]>,
) -> Result<(Vec<O>, Vec<Id>), Self::Error> {
let inner = self.inner.lock().await;
let map = inner.objects_ref(O::TYPE_NAME, account_id.as_ref());
match ids {
None => {
let mut list = Vec::new();
if let Some(m) = map {
for val in m.values() {
match O::deserialize(val) {
Ok(obj) => list.push(obj),
Err(e) => {
return Err(MemoryError::serde(
format_args!("deserialize {}", O::TYPE_NAME),
&e,
));
}
}
}
}
Ok((list, vec![]))
}
Some(id_slice) => {
let mut found = Vec::new();
let mut not_found = Vec::new();
for id in id_slice {
match map.and_then(|m| m.get(id)) {
Some(val) => match O::deserialize(val) {
Ok(obj) => found.push(obj),
Err(e) => {
return Err(MemoryError::serde(
format_args!("deserialize {}", O::TYPE_NAME),
&e,
));
}
},
None => not_found.push(id.clone()),
}
}
Ok((found, not_found))
}
}
}
async fn get_state<O: JmapObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
) -> Result<State, Self::Error> {
let inner = self.inner.lock().await;
let n = inner.current_state(O::TYPE_NAME, account_id.as_ref());
Ok(State::from(n.to_string()))
}
async fn get_changes<O: JmapObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
params: jmap_server::ChangesParams<'_>,
) -> Result<ChangesResult, BackendChangesError<Self::Error>> {
let since_state = params.since_state;
let max_changes = params.max_changes;
let mode = if params.ignore_metadata_only_changes {
MetadataOnlyChanges::Ignore
} else {
MetadataOnlyChanges::Report
};
let inner = self.inner.lock().await;
let since_n: u64 = since_state
.as_ref()
.parse()
.map_err(|_| BackendChangesError::CannotCalculate)?;
if inner
.change_log_floor
.get(O::TYPE_NAME)
.and_then(|m| m.get(account_id.as_ref()))
.is_some_and(|&floor| since_n < floor)
{
return Err(BackendChangesError::CannotCalculate);
}
let log = inner
.change_log
.get(O::TYPE_NAME)
.and_then(|m| m.get(account_id.as_ref()))
.map(Vec::as_slice)
.unwrap_or(&[]);
let mut relevant: Vec<&ChangeEntry> =
log.iter().filter(|e| e.new_state > since_n).collect();
let current_state = inner.current_state(O::TYPE_NAME, account_id.as_ref());
let mut has_more = false;
if let Some(max) = max_changes {
let mut ids = 0u64;
if let Some(cut) = relevant.iter().position(|e| {
if !(mode == MetadataOnlyChanges::Ignore && e.is_metadata_only_update()) {
ids +=
(e.created.len() + e.updated.len() + e.destroyed.len() + e.restored.len())
as u64;
}
ids > max
}) {
if cut == 0 {
return Err(BackendChangesError::TooManyChanges { limit: max });
}
relevant.truncate(cut);
has_more = true;
}
}
let new_state = match relevant.last() {
Some(e) if has_more => e.new_state,
_ => current_state,
};
let mut fates: HashMap<Id, IdFate> = HashMap::new();
let mut order: Vec<Id> = Vec::new();
let mut window_props = ChangedProperties::new();
for entry in &relevant {
for id in &entry.created {
if fates.insert(id.clone(), IdFate::Created).is_none() {
order.push(id.clone());
}
}
for id in &entry.updated {
window_props.record(id.as_ref(), entry.updated_props.as_ref());
let fate = match fates.get(id) {
Some(IdFate::Created) => IdFate::Created,
Some(IdFate::Destroyed) => IdFate::Destroyed,
_ => IdFate::Updated,
};
if fates.insert(id.clone(), fate).is_none() {
order.push(id.clone());
}
}
for id in &entry.destroyed {
if O::TYPE_NAME != "Message" && matches!(fates.get(id), Some(IdFate::Created)) {
fates.remove(id);
} else if fates.insert(id.clone(), IdFate::Destroyed).is_none() {
order.push(id.clone());
}
}
}
let mut created: Vec<Id> = Vec::new();
let mut updated: Vec<Id> = Vec::new();
let mut destroyed: Vec<Id> = Vec::new();
let mut events: HashMap<Id, Vec<ChangeEvent>> = HashMap::new();
for entry in &relevant {
for (ids, event) in [
(&entry.created, ChangeEvent::Created),
(&entry.updated, ChangeEvent::Updated),
(&entry.destroyed, ChangeEvent::Destroyed),
(&entry.restored, ChangeEvent::Restored),
] {
for id in ids {
events.entry(id.clone()).or_default().push(event);
}
}
}
for (id, list) in &events {
if !list.contains(&ChangeEvent::Restored) {
continue;
}
let fate = match fold_restore(list) {
Some(ChangeKind::Created) => IdFate::Created,
Some(ChangeKind::Destroyed) => IdFate::Destroyed,
Some(_) => {
window_props.record(id.as_ref(), None);
IdFate::Updated
}
None => {
fates.remove(id);
continue;
}
};
if fates.insert(id.clone(), fate).is_none() {
order.push(id.clone());
}
}
for id in order {
match fates.remove(&id) {
Some(IdFate::Created) => created.push(id),
Some(IdFate::Updated)
if mode == MetadataOnlyChanges::Ignore
&& window_props.is_metadata_only(id.as_ref()) => {}
Some(IdFate::Updated) => updated.push(id),
Some(IdFate::Destroyed) => destroyed.push(id),
None => {}
}
}
let updated_properties = window_props.updated_properties(&updated, mode, &[]);
Ok(ChangesResult::new(
created,
updated,
destroyed,
has_more,
State::from(new_state.to_string()),
)
.with_updated_properties(updated_properties))
}
async fn query_objects<O: QueryObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
params: QueryParams<'_, O>,
) -> Result<QueryResult, BackendQueryError<Self::Error>> {
let QueryParams {
filter,
sort,
limit,
position,
anchor,
anchor_offset,
..
} = params;
let inner = self.inner.lock().await;
let filter_val: Option<serde_json::Value> =
filter.and_then(|f| serde_json::to_value(f).ok());
let sort_val: Option<serde_json::Value> = sort.and_then(|s| serde_json::to_value(s).ok());
if let Some(fv) = &filter_val {
check_metadata_filter(fv, inner.metadata_info.get(O::TYPE_NAME))?;
check_where(fv, O::TYPE_NAME, inner.search.as_ref())?;
}
let mut ids: Vec<Id> = inner
.objects_ref(O::TYPE_NAME, account_id.as_ref())
.map(|m| {
let mut keys: Vec<Id> = m.keys().cloned().collect();
if let Some(ref fv) = filter_val {
keys.retain(|id| filter_matches(&inner, O::TYPE_NAME, &m[id], fv, account_id));
}
if O::TYPE_NAME == "Message" {
keys.retain(|id| {
m.get(id)
.and_then(|obj| obj.get("chatId"))
.and_then(|v| v.as_str())
.is_none_or(|cid| {
owner_may_view_chat(&inner, account_id, &Id::from(cid))
})
});
}
if O::TYPE_NAME == "Space" {
let want_public = filter_val.as_ref().is_some_and(has_is_public_true);
keys.retain(|id| {
let space = &m[id];
let flag = |k: &str| {
space.get(k).and_then(serde_json::Value::as_bool) == Some(true)
};
let is_member = space
.get("members")
.and_then(|v| v.as_array())
.is_some_and(|ms| {
ms.iter().any(|mm| {
mm.get("id").and_then(|v| v.as_str())
== Some(account_id.as_ref())
})
});
is_member
|| (want_public && flag("isPublic") && flag("isPubliclyPreviewable"))
});
}
keys.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
if let Some(comparators) = sort_val.as_ref().and_then(|v| v.as_array()) {
keys.sort_by(|a, b| compare_by_sort(&m[a], &m[b], comparators));
}
keys
})
.unwrap_or_default();
let total = ids.len() as u64;
let query_state = State::from(
inner
.current_state(O::TYPE_NAME, account_id.as_ref())
.to_string(),
);
let start = resolve_query_start(&ids, position, anchor, anchor_offset)
.map_err(BackendQueryError::Method)?;
ids = ids[start..]
.iter()
.take(limit_or_max(limit))
.cloned()
.collect();
Ok(QueryResult::new(
ids,
start as u64,
Some(total),
query_state,
true,
))
}
async fn query_changes<O: QueryObject + Send + Sync>(
&self,
caller: &C,
account_id: &Id,
params: QueryChangesParams<'_, O>,
) -> Result<QueryChangesResult, BackendChangesError<Self::Error>> {
let QueryChangesParams {
since_query_state,
filter,
sort,
max_changes,
..
} = params;
let changes = self
.get_changes::<O>(
caller,
account_id,
jmap_server::ChangesParams::new(since_query_state).max_changes(max_changes),
)
.await?;
let current = self
.query_objects::<O>(
caller,
account_id,
QueryParams::new().filter(filter).sort(sort),
)
.await
.map_err(|e| match e {
BackendQueryError::Other(e) => BackendChangesError::Other(e),
_ => BackendChangesError::CannotCalculate,
})?;
let created_set: HashSet<&Id> = changes.created.iter().collect();
let updated_set: HashSet<&Id> = changes.updated.iter().collect();
let mut removed: Vec<Id> = changes
.destroyed
.iter()
.chain(changes.updated.iter())
.cloned()
.collect();
removed.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
removed.dedup();
let added: Vec<AddedItem> = current
.ids
.iter()
.enumerate()
.filter(|(_, id)| created_set.contains(id) || updated_set.contains(id))
.map(|(pos, id)| AddedItem::new(id.clone(), pos as u64))
.collect();
Ok(QueryChangesResult::new(
since_query_state.clone(),
changes.new_state,
current.total,
removed,
added,
))
}
}
impl<C: MemoryCaller> ChatStore for MemoryBackend<C> {
async fn create_object<O, F>(
&self,
_caller: &C,
account_id: &Id,
_create_id: &str,
build: F,
) -> Result<(Id, O), BackendSetError<Self::Error>>
where
O: SetObject + Send + Sync,
F: FnOnce(&Id) -> O + Send,
{
let server_id = self.inner.lock().await.mint_id();
let stored_obj = build(&server_id);
let val = serde_json::to_value(&stored_obj)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
let mut inner = self.inner.lock().await;
let defer = self.inner.deferring();
insert_created(&mut inner, O::TYPE_NAME, account_id, &server_id, val, defer)?;
Ok((server_id, stored_obj))
}
async fn create_message<F>(
&self,
_caller: &C,
account_id: &Id,
_create_id: &str,
build: F,
) -> Result<(Id, jmap_chat_types::Message), BackendSetError<Self::Error>>
where
F: FnOnce(&Id) -> jmap_chat_types::Message + Send,
{
let mut inner = self.inner.lock().await;
let server_id = inner.mint_id();
let message = build(&server_id);
let val = serde_json::to_value(&message)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
let defer = self.inner.deferring();
insert_created(&mut inner, "Message", account_id, &server_id, val, defer)?;
let limit = inner.event_limit;
Inner::push_capped(
&mut inner.outbound_events,
crate::OutboundEvent::NewMessage {
chat_id: message.chat_id.clone(),
message_id: message.id.clone(),
sender_msg_id: message.sender_msg_id.clone(),
},
limit,
);
Ok((server_id, message))
}
async fn update_object<O: SetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
id: &Id,
patch: O::Patch,
) -> Result<Option<O>, BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().await;
inner.require_account_for_target(account_id.as_ref())?;
let (current, changed) = patched_copy::<O>(&mut inner, account_id.as_ref(), id, &patch)?;
if O::TYPE_NAME == "CustomEmoji"
&& !self.inner.deferring()
&& emoji_name_holder(&inner, account_id, ¤t, Some(id)).is_some()
{
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidProperties).with_properties(["name"]),
)));
}
if O::TYPE_NAME == "CustomEmoji" {
let stored_blob = inner
.objects_ref(O::TYPE_NAME, account_id.as_ref())
.and_then(|m| m.get(id))
.and_then(|e| e.get("blobId"));
let limits = inner.limits_override.unwrap_or_default();
if current.get("blobId") != stored_blob
&& emoji_blob_over_cap(&inner, account_id, ¤t, &limits)
{
return Err(over_quota_error(crate::emoji::EMOJI_TOO_LARGE));
}
}
let unread_changed = if O::TYPE_NAME == "ReadPosition" {
let old = inner
.objects_ref(O::TYPE_NAME, account_id.as_ref())
.and_then(|m| m.get(id))
.cloned()
.unwrap_or_default();
roots_with_unread_change(&inner, account_id.as_ref(), &old, ¤t)
} else {
Vec::new()
};
let previous = inner
.objects_ref(O::TYPE_NAME, account_id.as_ref())
.and_then(|m| m.get(id))
.cloned();
if O::TYPE_NAME == "Message" && current.get("deletedAt").is_some_and(|v| !v.is_null()) {
inner.purge_message_history(account_id, id);
} else if let (Some(h), Some(previous)) = (inner.history.as_mut(), previous) {
h.record_replace(O::TYPE_NAME, account_id, id, previous);
}
let new_state = inner.bump_state(O::TYPE_NAME, account_id.as_ref());
inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.insert(id.clone(), current);
inner
.change_log_mut(O::TYPE_NAME, account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![id.clone()],
destroyed: vec![],
restored: vec![],
updated_props: Some(changed),
});
record_thread_count_changes(&mut inner, account_id.as_ref(), unread_changed);
Ok(None)
}
async fn destroy_object<O: SetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
id: &Id,
) -> Result<(), BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().await;
inner.require_account_for_target(account_id.as_ref())?;
if O::TYPE_NAME == "Space"
&& let Some(space_val) = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(id))
{
let caller_perms =
caller_effective_permissions(space_val, account_id, inner.everyone_in(space_val))
.unwrap_or_default();
if !caller_perms.contains(&ChatPermission::ManageSpace) {
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::Forbidden).with_description(
"caller lacks required permission `manage_space` to destroy the Space",
),
)));
}
}
let space_chats: Vec<Id> = if O::TYPE_NAME == "Space" {
inner
.objects_ref("Chat", account_id.as_ref())
.map(|chats| {
chats
.iter()
.filter(|(_, c)| {
c.get("spaceId").and_then(|v| v.as_str()) == Some(id.as_ref())
})
.map(|(k, _)| k.clone())
.collect()
})
.unwrap_or_default()
} else {
Vec::new()
};
let removed = if O::TYPE_NAME == "Message" {
hard_delete_message(&mut inner, account_id.as_ref(), id)
} else {
let last = inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.remove(id);
if let Some(last) = &last
&& O::TYPE_NAME != "Space"
&& let Some(h) = inner.history.as_mut()
{
h.record_destroy(O::TYPE_NAME, account_id, id, last.clone());
}
last.is_some()
};
if !removed {
return Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))));
}
let new_state = inner.bump_state(O::TYPE_NAME, account_id.as_ref());
inner
.change_log_mut(O::TYPE_NAME, account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: vec![id.clone()],
restored: vec![],
updated_props: None,
});
if O::TYPE_NAME == "Space" {
destroy_space_channels(&mut inner, account_id.as_ref(), id);
inner.purge_space_history(account_id, id, &space_chats);
}
if O::TYPE_NAME == "Chat" {
destroy_read_positions(&mut inner, account_id.as_ref(), std::slice::from_ref(id));
}
Ok(())
}
fn supports_type<O: JmapObject>(&self, _caller: &C, _account_id: &jmap_types::Id) -> bool {
true
}
}
impl<C: MemoryCaller> ChatSpaces for MemoryBackend<C> {
async fn generate_invite_code(
&self,
_caller: &C,
_account_id: &Id,
) -> Result<String, MemoryError> {
let mut bytes = [0u8; 16];
getrandom::fill(&mut bytes)
.map_err(|e| MemoryError::new(format!("OS CSPRNG unavailable: {e}")))?;
let mut out = String::with_capacity(bytes.len() * 2);
for byte in bytes {
use std::fmt::Write as _;
let _ = write!(out, "{byte:02x}");
}
Ok(out)
}
async fn join_space_with_invite(
&self,
_caller: &C,
account_id: &Id,
invite_id: &Id,
joined_at: &jmap_types::UTCDate,
) -> Result<Result<(), InviteJoinRefusal>, Self::Error> {
let mut inner = self.inner.lock().await;
let acct = account_id.as_ref();
let Some(stored) = inner
.objects_ref("SpaceInvite", acct)
.and_then(|m| m.get(invite_id))
else {
return Ok(Err(InviteJoinRefusal::NotFound));
};
let invite: jmap_chat_types::SpaceInvite = serde_json::from_value(stored.clone())
.map_err(|e| MemoryError::serde("stored SpaceInvite", &e))?;
if invite.max_uses.is_some_and(|max| invite.uses >= max) {
return Ok(Err(InviteJoinRefusal::Exhausted));
}
let Some(space) = inner
.objects_mut("Space", acct)
.get_mut(&invite.space_id)
.and_then(serde_json::Value::as_object_mut)
else {
return Ok(Err(InviteJoinRefusal::NotFound));
};
let Some(members) = space
.entry("members")
.or_insert_with(|| serde_json::json!([]))
.as_array_mut()
else {
return Err(MemoryError::new("stored Space members is not an array"));
};
if members
.iter()
.any(|m| m.get("id").and_then(|v| v.as_str()) == Some(acct))
{
return Ok(Err(InviteJoinRefusal::AlreadyMember));
}
members.push(serde_json::json!({
"id": acct,
"roleIds": [],
"joinedAt": joined_at,
}));
if let Some(stored) = inner
.objects_mut("SpaceInvite", acct)
.get_mut(invite_id)
.and_then(serde_json::Value::as_object_mut)
{
stored.insert(
"uses".to_owned(),
serde_json::json!(invite.uses.saturating_add(1)),
);
}
for (type_name, id) in [("Space", &invite.space_id), ("SpaceInvite", invite_id)] {
let new_state = inner.bump_state(type_name, acct);
inner.change_log_mut(type_name, acct).push(ChangeEntry {
new_state,
created: vec![],
updated: vec![id.clone()],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
Ok(Ok(()))
}
fn protect_last_admin(&self, _caller: &C, _account_id: &Id) -> bool {
let inner = self.inner.lock_unscoped();
inner.protect_last_admin
}
fn space_extension_properties(&self, _caller: &C, _account_id: &Id) -> &'static [&'static str] {
let inner = self.inner.lock_unscoped();
inner.space_extension_properties
}
async fn apply_space_patch(
&self,
_caller: &C,
account_id: &Id,
space_id: &Id,
ops: Vec<SpacePatchOp>,
) -> Result<Vec<OpResult>, BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().await;
apply_space_patch_impl(&mut inner, account_id, space_id, ops)
}
async fn apply_space_metadata_patch(
&self,
_caller: &C,
account_id: &Id,
space_id: &Id,
patch: jmap_chat_types::SpaceMetadataPatch,
) -> Result<Option<jmap_chat_types::Space>, BackendSetError<Self::Error>> {
let patch_map = space_metadata_patch_to_map(patch).map_err(BackendSetError::Other)?;
let mut inner = self.inner.lock().await;
apply_space_metadata_patch_impl(&mut inner, account_id, space_id, patch_map)
}
async fn everyone_permissions(
&self,
_caller: &C,
_account_id: &Id,
space: &jmap_chat_types::Space,
) -> Result<HashSet<ChatPermission>, Self::Error> {
Ok(self
.inner
.lock()
.await
.everyone_for(space.id.as_ref())
.clone())
}
}
impl<C: MemoryCaller> SpacePolicy for MemoryBackend<C> {
async fn may_set_custom_emoji(
&self,
_caller: &C,
_account_id: &Id,
_target_space_id: Option<&Id>,
_op: EmojiSetOp,
) -> Result<Result<(), SetError>, Self::Error> {
Ok(Ok(()))
}
async fn may_set_space_ban(
&self,
_caller: &C,
account_id: &Id,
space_id: &Id,
) -> Result<Result<(), SetError>, Self::Error> {
let inner = self.inner.lock().await;
let Some(space) = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(space_id))
else {
return Ok(Ok(()));
};
Ok(
if caller_effective_permissions(space, account_id, inner.everyone_in(space))
.is_some_and(|perms| perms.contains(&ChatPermission::Ban))
{
Ok(())
} else {
Err(SetError::new(SetErrorType::Forbidden)
.with_description("caller lacks required permission `ban` in this Space"))
},
)
}
async fn may_set_space_invite(
&self,
_caller: &C,
account_id: &Id,
space_id: &Id,
created_by: Option<&Id>,
) -> Result<Result<(), SetError>, Self::Error> {
if created_by == Some(account_id) {
return Ok(Ok(()));
}
let inner = self.inner.lock().await;
let Some(space) = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(space_id))
else {
return Ok(Ok(()));
};
Ok(
if caller_effective_permissions(space, account_id, inner.everyone_in(space))
.is_some_and(|perms| perms.contains(&ChatPermission::ManageMembers))
{
Ok(())
} else {
Err(SetError::new(SetErrorType::Forbidden).with_description(
"caller lacks required permission `manage_members` in this Space",
))
},
)
}
async fn may_get_space_invite(
&self,
_caller: &C,
account_id: &Id,
invite: &jmap_chat_types::SpaceInvite,
) -> Result<bool, Self::Error> {
let inner = self.inner.lock().await;
let Some(space) = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(&invite.space_id))
else {
return Ok(true);
};
Ok(
caller_effective_permissions(space, account_id, inner.everyone_in(space)).is_some_and(
|p| p.contains(&ChatPermission::ManageMembers) || invite.created_by == *account_id,
),
)
}
async fn may_get_space_ban(
&self,
_caller: &C,
account_id: &Id,
ban: &jmap_chat_types::SpaceBan,
) -> Result<bool, Self::Error> {
if ban.user_id == *account_id {
return Ok(true);
}
let inner = self.inner.lock().await;
let Some(space) = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(&ban.space_id))
else {
return Ok(true);
};
Ok(
caller_effective_permissions(space, account_id, inner.everyone_in(space))
.is_some_and(|p| p.contains(&ChatPermission::Ban)),
)
}
}
impl<C: MemoryCaller> ChatAccessPolicy for MemoryBackend<C> {
async fn may_broadcast_mention(
&self,
_caller: &C,
account_id: &Id,
space_id: &Id,
chat_id: &Id,
) -> Result<Result<(), SetError>, Self::Error> {
let inner = self.inner.lock().await;
let space_exists = inner
.objects_ref("Space", account_id.as_ref())
.is_some_and(|m| m.contains_key(space_id));
let Some(chat) = inner
.objects_ref("Chat", account_id.as_ref())
.and_then(|m| m.get(chat_id))
.filter(|_| space_exists)
else {
return Ok(Ok(()));
};
Ok(
if owner_channel_permissions(&inner, account_id, chat)
.is_some_and(|perms| perms.contains(&ChatPermission::MentionBroadcast))
{
Ok(())
} else {
Err(SetError::new(SetErrorType::Forbidden).with_description(
"caller lacks required permission `mention_broadcast` in this channel",
))
},
)
}
async fn may_send_message(
&self,
_caller: &C,
account_id: &Id,
chat_id: &Id,
) -> Result<Result<(), SetError>, Self::Error> {
let inner = self.inner.lock().await;
let Some(chat) = inner
.objects_ref("Chat", account_id.as_ref())
.and_then(|m| m.get(chat_id))
else {
return Ok(Ok(()));
};
let denied = match chat.get("kind").and_then(|v| v.as_str()) {
Some("group") => {
let is_member =
chat.get("members")
.and_then(|v| v.as_array())
.is_some_and(|members| {
members.iter().any(|m| {
m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref())
})
});
(!is_member).then_some("sender is not a member of this Chat")
}
Some("channel") => match owner_channel_permissions(&inner, account_id, chat) {
None => Some("sender is not a member of the containing Space"),
Some(perms) if !perms.contains(&ChatPermission::Send) => {
Some("sender lacks required permission `send` in this channel")
}
Some(_) => None,
},
_ => None,
};
Ok(match denied {
Some(desc) => Err(SetError::new(SetErrorType::Forbidden).with_description(desc)),
None => Ok(()),
})
}
async fn may_view_chat(
&self,
_caller: &C,
account_id: &Id,
chat_id: &Id,
) -> Result<bool, Self::Error> {
let inner = self.inner.lock().await;
Ok(owner_may_view_chat(&inner, account_id, chat_id))
}
async fn may_set_pinned_messages(
&self,
_caller: &C,
account_id: &Id,
chat_id: &Id,
) -> Result<Result<(), SetError>, Self::Error> {
let inner = self.inner.lock().await;
let Some(chat) = inner
.objects_ref("Chat", account_id.as_ref())
.and_then(|m| m.get(chat_id))
else {
return Ok(Ok(()));
};
let denied = match chat.get("kind").and_then(|v| v.as_str()) {
Some("direct") => None,
Some("group") => (!is_group_admin(chat, account_id))
.then_some("only group chat admins may modify pinnedMessageIds"),
Some("channel") => {
let has_pin = owner_channel_permissions(&inner, account_id, chat)
.is_some_and(|perms| perms.contains(&ChatPermission::Pin));
(!has_pin).then_some("caller lacks required permission `pin` in this channel")
}
_ => Some("internal: Chat has no recognized kind"),
};
Ok(match denied {
Some(desc) => Err(SetError::new(SetErrorType::Forbidden).with_description(desc)),
None => Ok(()),
})
}
async fn slow_mode_check(
&self,
_caller: &C,
_account_id: &Id,
_chat_id: &Id,
) -> Result<(), SlowModeError> {
Ok(())
}
}
impl<C: MemoryCaller> ChatRestrictions for MemoryBackend<C> {}
impl<C: MemoryCaller> ChatModeration for MemoryBackend<C> {}
impl<C: MemoryCaller> ChatMessageLifecycle for MemoryBackend<C> {
async fn expire_message(
&self,
_caller: &C,
account_id: &Id,
message_id: &Id,
) -> Result<(), Self::Error> {
let mut inner = self.inner.lock().await;
if hard_delete_message(&mut inner, account_id.as_ref(), message_id) {
let new_state = inner.bump_state("Message", account_id.as_ref());
inner
.change_log_mut("Message", account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: vec![message_id.clone()],
restored: vec![],
updated_props: None,
});
}
Ok(())
}
async fn read_and_burn_message(
&self,
_caller: &C,
account_id: &Id,
message_id: &Id,
patch: jmap_types::PatchObject,
) -> Result<(), BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().await;
let acct = account_id.as_ref();
patched_copy::<jmap_chat_types::Message>(&mut inner, acct, message_id, &patch)?;
hard_delete_message(&mut inner, acct, message_id);
let new_state = inner.bump_state("Message", acct);
inner.change_log_mut("Message", acct).push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: vec![message_id.clone()],
restored: vec![],
updated_props: None,
});
Ok(())
}
}
impl<C: MemoryCaller> ChatEvents for MemoryBackend<C> {
fn on_chat_destroyed(
&self,
_caller: &C,
_account_id: &Id,
chat_id: &Id,
) -> impl std::future::Future<Output = ()> + Send {
self.record_lifecycle_event(LifecycleEvent::ChatDestroyed(chat_id.clone()))
}
fn on_space_destroyed(
&self,
_caller: &C,
_account_id: &Id,
space_id: &Id,
) -> impl std::future::Future<Output = ()> + Send {
self.record_lifecycle_event(LifecycleEvent::SpaceDestroyed(space_id.clone()))
}
fn on_space_ban_created(
&self,
_caller: &C,
_account_id: &Id,
ban: &jmap_chat_types::SpaceBan,
) -> impl std::future::Future<Output = ()> + Send {
self.record_lifecycle_event(LifecycleEvent::SpaceBanCreated(ban.clone()))
}
fn on_outbound_event(
&self,
_caller: &C,
_account_id: &Id,
event: &crate::OutboundEvent,
) -> impl std::future::Future<Output = ()> + Send {
let event = event.clone();
async move {
let mut inner = self.inner.lock().await;
let limit = inner.event_limit;
Inner::push_capped(&mut inner.outbound_events, event, limit);
}
}
}
impl<C: MemoryCaller> ChatSettings for MemoryBackend<C> {
fn limits(&self, _caller: &C, _account_id: &Id) -> ChatLimits {
let inner = self.inner.lock_unscoped();
inner.limits_override.unwrap_or_default()
}
fn retains_edit_history(&self) -> bool {
let inner = self.inner.lock_unscoped();
inner.retains_edit_history
}
fn maintains_unread_count(&self) -> bool {
let inner = self.inner.lock_unscoped();
inner.maintains_unread_count
}
async fn owner_user_id(
&self,
_caller: &C,
account_id: &Id,
) -> Result<Option<String>, Self::Error> {
let inner = self.inner.lock().await;
Ok(inner.owner_user_ids.get(account_id.as_ref()).cloned())
}
async fn search_capability(
&self,
_caller: &C,
_account_id: &Id,
) -> Result<Option<jmap_search::SearchCapability>, Self::Error> {
Ok(self.inner.lock().await.search.clone())
}
}
impl<C: MemoryCaller> ChatResolvers for MemoryBackend<C> {
async fn attachment_blob(
&self,
_caller: &C,
account_id: &Id,
blob_id: &Id,
) -> Result<Result<Option<AttachmentBlob>, SetError>, Self::Error> {
let inner = self.inner.lock().await;
Ok(Ok(inner
.attachment_blobs
.get(&(account_id.as_ref().to_owned(), blob_id.clone()))
.copied()))
}
}
impl<C: MemoryCaller> PushSubscriptionBackend for MemoryBackend<C> {
const PUSH_SUBSCRIPTION_EXTENSION_PROPERTIES: &'static [&'static str] =
&[crate::push::CHAT_PUSH];
async fn list_push_subscriptions(
&self,
_caller: &C,
) -> Result<Vec<StoredPushSubscription>, MemoryError> {
let inner = self.inner.lock().await;
Ok(inner
.push_subscriptions
.values()
.cloned()
.map(|mut stored| {
strip_unsupported_chat_push(&mut stored.subscription.extra, &inner.chat_push_caps);
stored
})
.collect())
}
async fn create_push_subscription(
&self,
_caller: &C,
mut new: PushSubscription,
) -> Result<StoredPushSubscription, BackendSetError<MemoryError>> {
let expected_code = random_base64url_code();
let mut inner = self.inner.lock().await;
validate_chat_push(&new.extra, &inner.chat_push_caps).map_err(BackendSetError::SetError)?;
if !self.inner.deferring() && inner.push_subscriptions.len() >= MAX_PUSH_SUBSCRIPTIONS {
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::OverQuota).with_description(format!(
"at most {MAX_PUSH_SUBSCRIPTIONS} push subscriptions per user"
)),
)));
}
let id = inner.mint_id();
new.id = Some(id.clone());
let stored = StoredPushSubscription {
subscription: new,
expected_code,
};
inner.push_subscriptions.insert(id, stored.clone());
Ok(stored)
}
async fn update_push_subscription(
&self,
_caller: &C,
sub: PushSubscription,
) -> Result<PushSubscription, BackendSetError<MemoryError>> {
let mut inner = self.inner.lock().await;
validate_chat_push(&sub.extra, &inner.chat_push_caps).map_err(BackendSetError::SetError)?;
let stored = sub
.id
.as_ref()
.and_then(|id| inner.push_subscriptions.get_mut(id))
.ok_or_else(|| {
BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
})?;
stored.subscription = sub.clone();
Ok(sub)
}
async fn destroy_push_subscription(
&self,
_caller: &C,
id: &Id,
) -> Result<(), BackendSetError<MemoryError>> {
let mut inner = self.inner.lock().await;
inner
.push_subscriptions
.remove(id)
.map(|_| ())
.ok_or_else(|| {
BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
})
}
}
fn random_base64url_code() -> String {
let mut bytes = [0u8; 16];
getrandom::fill(&mut bytes).expect("OS CSPRNG must be available for push verification codes");
base64url_unpadded(&bytes)
}
fn base64url_unpadded(bytes: &[u8]) -> String {
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
for chunk in bytes.chunks(3) {
let n = chunk
.iter()
.enumerate()
.fold(0u32, |n, (i, &b)| n | u32::from(b) << (16 - 8 * i));
for i in 0..=chunk.len() {
out.push(char::from(ALPHABET[(n >> (18 - 6 * i)) as usize & 63]));
}
}
out
}
fn patched_copy<O: SetObject>(
inner: &mut Inner,
account_id: &str,
id: &Id,
patch: &O::Patch,
) -> Result<(serde_json::Value, BTreeSet<String>), BackendSetError<MemoryError>> {
let invalid_patch = |e: PatchPathError| {
BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
))
};
let patch_val = serde_json::to_value(patch)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize patch", &e)))?;
let no_patch = serde_json::Map::new();
let patch_map = patch_val.as_object().unwrap_or(&no_patch);
check_patch_paths(patch_map).map_err(invalid_patch)?;
let existing = inner.objects_mut(O::TYPE_NAME, account_id).get(id).cloned();
let mut current = match existing {
Some(v) => v,
None => {
return Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))));
}
};
let mut changed = BTreeSet::new();
if let serde_json::Value::Object(base) = &mut current {
let metadata_info = if metadata_type_name(O::TYPE_NAME).is_some() {
inner.check_metadata_set(O::TYPE_NAME, SetKind::Update, patch_map, Some(base))?
} else {
None
};
if metadata_info.is_some() {
base.entry("metadata")
.or_insert_with(|| serde_json::Value::Object(serde_json::Map::new()));
}
let before = base.clone();
apply_patch_object(base, patch_map).map_err(invalid_patch)?;
if let Some(info) = &metadata_info {
for property in ["metadata", "privateMetadata"] {
if patch_map
.get(property)
.is_some_and(serde_json::Value::is_null)
{
base.insert(
property.to_owned(),
serde_json::Value::Object(serde_json::Map::new()),
);
}
}
check_metadata_depth(patch_map, base, info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
}
changed = changed_properties(&before, base);
}
if let Err(e) = O::deserialize(¤t) {
let mut props: Vec<String> = patch_map
.keys()
.map(|k| {
let top = k.split('/').next().unwrap_or(k);
top.replace("~1", "/").replace("~0", "~")
})
.collect();
props.sort();
props.dedup();
let mut err = SetError::new(SetErrorType::InvalidProperties)
.with_description(format!("patched {} is invalid: {e}", O::TYPE_NAME));
if props.len() == 1 {
err = err.with_properties(props);
}
return Err(BackendSetError::SetError(Box::new(err)));
}
Ok((current, changed))
}
fn metadata_type_name(data_type: &str) -> Option<&'static str> {
[
jmap_chat_types::Chat::TYPE_NAME,
jmap_chat_types::Message::TYPE_NAME,
jmap_chat_types::Space::TYPE_NAME,
]
.into_iter()
.find(|t| *t == data_type)
}
fn invalid_metadata_property(property: &str, description: &str) -> BackendSetError<MemoryError> {
BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties([property])
.with_description(description),
))
}
impl Inner {
fn check_metadata_set(
&self,
type_name: &'static str,
kind: SetKind,
entry: &serde_json::Map<String, serde_json::Value>,
stored: Option<&serde_json::Map<String, serde_json::Value>>,
) -> Result<Option<DataTypeMetadataInfo>, BackendSetError<MemoryError>> {
let Some(first) = entry.keys().find(|k| crate::helpers::is_metadata_key(k)) else {
return Ok(None);
};
let Some(info) = self.metadata_info.get(type_name) else {
return Err(invalid_metadata_property(
first,
"metadata is not supported on this data type",
));
};
check_metadata_write(kind, entry, stored, info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
Ok(Some(info.clone()))
}
}
fn object_id_of(val: &serde_json::Value) -> Result<Id, BackendSetError<MemoryError>> {
match val.get("id").and_then(serde_json::Value::as_str) {
Some(id) if !id.is_empty() => Ok(Id::from(id)),
_ => Err(BackendSetError::Other(MemoryError::new(
"insert_object: object has no non-empty `id` string",
))),
}
}
fn reject_taken_id(
inner: &Inner,
type_name: &'static str,
account_id: &Id,
id: &Id,
) -> Result<(), BackendSetError<MemoryError>> {
if inner
.objects_ref(type_name, account_id.as_ref())
.is_some_and(|m| m.contains_key(id))
{
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::AlreadyExists).with_existing_id(id.clone()),
)));
}
Ok(())
}
fn insert_created(
inner: &mut Inner,
type_name: &'static str,
account_id: &Id,
server_id: &Id,
val: serde_json::Value,
defer: bool,
) -> Result<(), BackendSetError<MemoryError>> {
check_metadata_create(inner, type_name, &val)?;
if type_name == "ChatContact" {
let existing = inner
.objects_ref(type_name, account_id.as_ref())
.and_then(|m| {
m.iter()
.find(|(_, c)| c.get("identity") == val.get("identity"))
})
.map(|(id, _)| id.clone());
if let Some(existing) = existing {
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::AlreadyExists).with_existing_id(existing),
)));
}
}
if type_name == "CustomEmoji"
&& !defer
&& let Some(existing) = emoji_name_holder(inner, account_id, &val, None)
{
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::AlreadyExists).with_existing_id(existing),
)));
}
if type_name == "CustomEmoji" {
let limits = inner.limits_override.unwrap_or_default();
let space_full = !defer
&& limits.max_custom_emoji_per_space.is_some_and(|max| {
emoji_scope(&val).is_some_and(|space| {
emoji_count_in_space(inner, account_id.as_ref(), &space) >= u64::from(max)
})
});
if space_full {
return Err(over_quota_error(crate::emoji::TOO_MANY_EMOJI));
}
if emoji_blob_over_cap(inner, account_id, &val, &limits) {
return Err(over_quota_error(crate::emoji::EMOJI_TOO_LARGE));
}
}
let reply_parent = if type_name == "Message" {
stored_reply_parent(inner, account_id.as_ref(), &val)
} else {
None
};
inner.require_account(account_id.as_ref())?;
let new_state = inner.bump_state(type_name, account_id.as_ref());
inner
.objects_mut(type_name, account_id.as_ref())
.insert(server_id.clone(), val);
inner
.change_log_mut(type_name, account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![server_id.clone()],
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
record_thread_count_changes(
inner,
account_id.as_ref(),
reply_parent.into_iter().collect(),
);
Ok(())
}
fn check_metadata_create(
inner: &Inner,
type_name: &'static str,
val: &serde_json::Value,
) -> Result<(), BackendSetError<MemoryError>> {
let (Some(type_name), Some(obj)) = (metadata_type_name(type_name), val.as_object()) else {
return Ok(());
};
let entry: serde_json::Map<String, serde_json::Value> = obj
.iter()
.filter(|(k, _)| is_metadata_property(k))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
if let Some(info) = inner.check_metadata_set(type_name, SetKind::Create, &entry, None)? {
check_metadata_depth(&entry, obj, &info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
}
Ok(())
}
fn hard_delete_message(inner: &mut Inner, account_id: &str, id: &Id) -> bool {
inner.purge_message_history(&Id::from(account_id), id);
let Some(msg) = inner.objects_mut("Message", account_id).remove(id) else {
return false;
};
let reply_parent = stored_reply_parent(inner, account_id, &msg);
record_thread_count_changes(inner, account_id, reply_parent.into_iter().collect());
let Some(chat_id) = msg.get("chatId").and_then(|v| v.as_str()).map(Id::from) else {
return true;
};
let unpinned = inner
.objects_mut("Chat", account_id)
.get_mut(&chat_id)
.and_then(|chat| chat.get_mut("pinnedMessageIds")?.as_array_mut())
.is_some_and(|pins| {
let before = pins.len();
pins.retain(|v| v.as_str() != Some(id.as_ref()));
pins.len() != before
});
if unpinned {
let new_state = inner.bump_state("Chat", account_id);
inner.change_log_mut("Chat", account_id).push(ChangeEntry {
new_state,
created: vec![],
updated: vec![chat_id],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
true
}
fn stored_reply_parent(inner: &Inner, account_id: &str, msg: &serde_json::Value) -> Option<Id> {
let parent = Id::from(msg.get("replyTo")?.as_str()?);
inner
.objects_ref("Message", account_id)?
.contains_key(&parent)
.then_some(parent)
}
fn roots_with_unread_change(
inner: &Inner,
account_id: &str,
old: &serde_json::Value,
new: &serde_json::Value,
) -> Vec<Id> {
let last_read = |rp: &serde_json::Value| {
rp.get("lastReadMessageId")
.and_then(|v| v.as_str())
.map(str::to_owned)
};
let (old_read, new_read) = (last_read(old), last_read(new));
if old_read == new_read {
return Vec::new();
}
let chat_id = new.get("chatId");
let Some(msgs) = inner.objects_ref("Message", account_id) else {
return Vec::new();
};
let unread = |read: &Option<String>, id: &str| read.as_deref().is_none_or(|l| id > l);
let mut roots: Vec<Id> = Vec::new();
for (id, reply) in msgs {
if reply.get("chatId") != chat_id
|| reply.get("senderId").and_then(|v| v.as_str()) == Some(account_id)
|| unread(&old_read, id.as_ref()) == unread(&new_read, id.as_ref())
{
continue;
}
let Some(parent) = reply.get("replyTo").and_then(|v| v.as_str()).map(Id::from) else {
continue;
};
let is_root = msgs
.get(&parent)
.is_some_and(|p| p.get("threadRootId").is_none_or(serde_json::Value::is_null));
if is_root && !roots.contains(&parent) {
roots.push(parent);
}
}
roots
}
fn record_thread_count_changes(inner: &mut Inner, account_id: &str, ids: Vec<Id>) {
if ids.is_empty() || !inner.limits_override.unwrap_or_default().supports_threads {
return;
}
let new_state = inner.bump_state("Message", account_id);
inner
.change_log_mut("Message", account_id)
.push(ChangeEntry {
new_state,
created: vec![],
updated: ids,
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
fn destroy_space_channels(inner: &mut Inner, account_id: &str, space_id: &Id) {
let chat_ids: Vec<Id> = inner
.objects_ref("Chat", account_id)
.map(|chats| {
chats
.keys()
.filter(|id| channel_belongs_to_space(inner, account_id, id, space_id))
.cloned()
.collect()
})
.unwrap_or_default();
if chat_ids.is_empty() {
return;
}
let message_ids: Vec<Id> = chat_ids
.iter()
.flat_map(|chat_id| scan_messages_in_chat(inner, account_id, chat_id))
.collect();
let msgs = inner.objects_mut("Message", account_id);
for msg_id in &message_ids {
msgs.remove(msg_id);
}
let chats = inner.objects_mut("Chat", account_id);
for chat_id in &chat_ids {
chats.remove(chat_id);
}
destroy_read_positions(inner, account_id, &chat_ids);
let new_state = inner.bump_state("Chat", account_id);
inner.change_log_mut("Chat", account_id).push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: chat_ids,
restored: vec![],
updated_props: None,
});
if !message_ids.is_empty() {
let new_state = inner.bump_state("Message", account_id);
inner
.change_log_mut("Message", account_id)
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: message_ids,
restored: vec![],
updated_props: None,
});
}
}
fn apply_space_patch_impl(
inner: &mut Inner,
account_id: &Id,
space_id: &Id,
ops: Vec<SpacePatchOp>,
) -> Result<Vec<OpResult>, BackendSetError<MemoryError>> {
if !inner
.objects_ref("Space", account_id.as_ref())
.is_some_and(|m| m.contains_key(space_id))
{
return Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))));
}
let protect_last_admin = inner.protect_last_admin;
let space_snapshot = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| {
BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
})?;
let everyone = inner.everyone_in(&space_snapshot).clone();
if let Err(e) = validate_space_patch_ops(
&space_snapshot,
account_id,
&ops,
protect_last_admin,
&everyone,
) {
return Err(BackendSetError::SetError(e));
}
let limits = inner.limits_override.unwrap_or_default();
if let Some(set_err) = check_count_caps(&space_snapshot, &ops, &limits) {
return Err(BackendSetError::SetError(Box::new(set_err)));
}
let mut results = Vec::with_capacity(ops.len());
let mut space_mutated = false;
let mut chats_created: Vec<Id> = Vec::new();
let mut chats_updated: HashSet<Id> = HashSet::new();
let mut chats_destroyed: Vec<Id> = Vec::new();
let mut messages_destroyed: Vec<Id> = Vec::new();
let leaving_space_manager = ops
.iter()
.any(|op| matches!(op, SpacePatchOp::RemoveMember(id) if id == account_id))
&& member_effective_permissions(&space_snapshot, account_id.as_ref(), &everyone)
.is_some_and(|p| p.contains(&ChatPermission::ManageSpace));
for (op_index, op) in ops.into_iter().enumerate() {
let outcome = match &op {
SpacePatchOp::AddRole(_) => {
apply_add_role(inner, account_id.as_ref(), space_id, op, &mut space_mutated)
}
SpacePatchOp::RemoveRole(_) => apply_remove_role(
inner,
account_id.as_ref(),
space_id,
op,
&mut chats_updated,
&mut space_mutated,
),
SpacePatchOp::UpdateRole { .. } => {
apply_update_role(inner, account_id.as_ref(), space_id, op, &mut space_mutated)
}
SpacePatchOp::AddMember(_) => {
apply_add_member(inner, account_id.as_ref(), space_id, op, &mut space_mutated)
}
SpacePatchOp::RemoveMember(_) => {
apply_remove_member(inner, account_id.as_ref(), space_id, op, &mut space_mutated)
}
SpacePatchOp::UpdateMember { .. } => {
apply_update_member(inner, account_id.as_ref(), space_id, op, &mut space_mutated)
}
SpacePatchOp::AddCategory(_)
| SpacePatchOp::RemoveCategory(_)
| SpacePatchOp::UpdateCategory { .. } => apply_category_op(
inner,
account_id.as_ref(),
space_id,
op,
&mut chats_updated,
&mut space_mutated,
),
SpacePatchOp::AddChannel(_) => apply_add_channel(
inner,
account_id.as_ref(),
space_id,
op,
&mut chats_created,
&mut space_mutated,
),
SpacePatchOp::RemoveChannel(_) => apply_remove_channel(
inner,
account_id.as_ref(),
space_id,
op,
&mut chats_destroyed,
&mut messages_destroyed,
&mut space_mutated,
),
SpacePatchOp::UpdateChannel { .. } => apply_update_channel(
inner,
account_id.as_ref(),
space_id,
op,
&mut chats_updated,
&mut space_mutated,
),
_ => Err(Box::new(
SetError::new(SetErrorType::Forbidden).with_description(stub_description(&op)),
)),
};
results.push(OpResult {
op_index,
outcome: outcome.map_err(|e| *e),
});
}
if leaving_space_manager
&& let Some(space) = inner
.objects_mut("Space", account_id.as_ref())
.get_mut(space_id)
{
let member_ids: Vec<&str> = space
.get("members")
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|m| m["id"].as_str()).collect())
.unwrap_or_default();
let closes = space.get("closedAt").is_none()
&& !member_ids.is_empty()
&& !member_ids.contains(&account_id.as_ref())
&& member_ids.iter().all(|m| {
!member_effective_permissions(space, m, &everyone)
.is_some_and(|p| p.contains(&ChatPermission::ManageSpace))
});
if closes {
space["closedAt"] = serde_json::Value::String(now_utc_string().into_inner());
space_mutated = true;
}
}
if space_mutated {
let new_state = inner.bump_state("Space", account_id.as_ref());
inner
.change_log_mut("Space", account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![space_id.clone()],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
destroy_read_positions(inner, account_id.as_ref(), &chats_destroyed);
if !chats_created.is_empty() || !chats_updated.is_empty() || !chats_destroyed.is_empty() {
let new_state = inner.bump_state("Chat", account_id.as_ref());
let mut updated: Vec<Id> = chats_updated
.into_iter()
.filter(|id| !chats_created.contains(id) && !chats_destroyed.contains(id))
.collect();
updated.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
inner
.change_log_mut("Chat", account_id.as_ref())
.push(ChangeEntry {
new_state,
created: chats_created,
updated,
destroyed: chats_destroyed,
restored: vec![],
updated_props: None,
});
}
if !messages_destroyed.is_empty() {
let new_state = inner.bump_state("Message", account_id.as_ref());
inner
.change_log_mut("Message", account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: messages_destroyed,
restored: vec![],
updated_props: None,
});
}
Ok(results)
}
fn space_metadata_patch_to_map(
patch: jmap_chat_types::SpaceMetadataPatch,
) -> Result<serde_json::Map<String, serde_json::Value>, MemoryError> {
let value = jmap_server::serialize_value(&patch)
.map_err(|_| MemoryError::new("SpaceMetadataPatch serialization failed"))?;
Ok(match value {
serde_json::Value::Object(map) => map,
_ => serde_json::Map::new(),
})
}
fn apply_space_metadata_patch_impl(
inner: &mut Inner,
account_id: &Id,
space_id: &Id,
patch_map: serde_json::Map<String, serde_json::Value>,
) -> Result<Option<jmap_chat_types::Space>, BackendSetError<MemoryError>> {
let space_val = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| {
BackendSetError::SetError(Box::new(SetError::new(SetErrorType::NotFound)))
})?;
let caller_perms =
caller_effective_permissions(&space_val, account_id, inner.everyone_in(&space_val))
.unwrap_or_default();
if !caller_perms.contains(&ChatPermission::ManageSpace) {
return Err(BackendSetError::SetError(
Box::new(SetError::new(SetErrorType::Forbidden).with_description(
"caller lacks required permission `manage_space` to mutate Space top-level metadata",
)),
));
}
if patch_map.is_empty() {
return Ok(None);
}
let mut current = space_val;
if let Err(MergePatchError::DepthExceeded) =
json_merge_patch(&mut current, serde_json::Value::Object(patch_map))
{
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidPatch)
.with_description("patch nesting exceeds server limit"),
)));
}
let new_state = inner.bump_state("Space", account_id.as_ref());
inner
.objects_mut("Space", account_id.as_ref())
.insert(space_id.clone(), current);
inner
.change_log_mut("Space", account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![space_id.clone()],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
Ok(None)
}
fn apply_category_op(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
chats_updated: &mut HashSet<Id>,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
use jmap_chat_types::Category;
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let categories: &mut Vec<serde_json::Value> = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
let assigned_id = match op {
SpacePatchOp::AddCategory(cat) => {
let new_id = inner.mint_id();
let position = cat.position.unwrap_or_else(|| {
categories
.iter()
.filter_map(|c| c.get("position").and_then(serde_json::Value::as_u64))
.max()
.map_or(0, |max| max.saturating_add(1))
});
for ch_id in &cat.channel_ids {
if !channel_belongs_to_space(inner, account_id, ch_id, space_id) {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["channelIds".to_owned()])
.with_description(format!(
"channelId {} is not a channel of this Space",
ch_id.as_ref()
)),
));
}
}
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let owned_channel_ids: Vec<Id> = cat.channel_ids.clone();
for ch_id in &owned_channel_ids {
set_channel_category(inner, account_id, ch_id, Some(&new_id));
chats_updated.insert(ch_id.clone());
}
if let Some(unc) = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
{
unc.retain(|v| {
v.as_str()
.is_none_or(|s| !owned_channel_ids.iter().any(|id| id.as_ref() == s))
});
}
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
remove_from_categories(cats, &owned_channel_ids);
let channel_ids = owned_channel_ids
.iter()
.map(|id| serde_json::Value::from(id.as_ref()))
.collect();
let mut stored = cat.extra;
stored.insert("id".to_owned(), serde_json::Value::from(new_id.as_ref()));
stored.insert("name".to_owned(), serde_json::Value::String(cat.name));
stored.insert("position".to_owned(), serde_json::Value::from(position));
stored.insert(
"channelIds".to_owned(),
serde_json::Value::Array(channel_ids),
);
cats.push(serde_json::Value::Object(stored));
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Some(new_id)
}
SpacePatchOp::RemoveCategory(target_id) => {
let pos = categories
.iter()
.position(|v| v.get("id").and_then(|s| s.as_str()) == Some(target_id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("category {} not found", target_id.as_ref())),
));
};
let scanned: Vec<Id> = scan_channels_in_category(inner, account_id, &target_id);
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
cats.remove(pos);
let unc = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.uncategorizedChannelIds not an array")
})?;
for ch_id in &scanned {
unc.push(serde_json::Value::String(ch_id.as_ref().to_owned()));
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
for ch_id in &scanned {
set_channel_category(inner, account_id, ch_id, None);
chats_updated.insert(ch_id.clone());
}
*space_mutated = true;
None
}
SpacePatchOp::UpdateCategory { id, patch } => {
let pos = categories
.iter()
.position(|v| v.get("id").and_then(|s| s.as_str()) == Some(id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("category {} not found", id.as_ref())),
));
};
let mut cat: Category =
serde_json::from_value(categories[pos].clone()).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: deserialize Category: {e}"))
})?;
if let Some(name) = patch.name {
cat.name = name;
}
if let Some(position) = patch.position {
cat.position = position;
}
let channel_ids_changed = patch.channel_ids.is_some();
let new_channel_ids: Option<Vec<Id>> = patch.channel_ids;
if let Some(new_ids) = &new_channel_ids {
for ch_id in new_ids {
if !channel_belongs_to_space(inner, account_id, ch_id, space_id) {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["channelIds".to_owned()])
.with_description(format!(
"channelId {} is not a channel of this Space",
ch_id.as_ref()
)),
));
}
}
}
if channel_ids_changed {
let new_ids = new_channel_ids.expect("checked above");
let old_ids = cat.channel_ids.clone();
let removed: Vec<&Id> = old_ids.iter().filter(|o| !new_ids.contains(o)).collect();
let added: Vec<&Id> = new_ids.iter().filter(|n| !old_ids.contains(n)).collect();
cat.channel_ids = new_ids.clone();
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
if let Some(unc) = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
{
for ch_id in &removed {
unc.push(serde_json::Value::String(ch_id.as_ref().to_owned()));
}
unc.retain(|v| {
v.as_str()
.is_none_or(|s| !added.iter().any(|id| id.as_ref() == s))
});
}
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
remove_from_categories(cats, &added);
cats[pos] = serde_json::to_value(&cat).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: serialize Category: {e}"))
})?;
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
for ch_id in &removed {
set_channel_category(inner, account_id, ch_id, None);
chats_updated.insert((*ch_id).clone());
}
for ch_id in &added {
set_channel_category(inner, account_id, ch_id, Some(&id));
chats_updated.insert((*ch_id).clone());
}
} else {
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
cats[pos] = serde_json::to_value(&cat).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: serialize Category: {e}"))
})?;
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
}
*space_mutated = true;
None
}
_ => unreachable!("apply_category_op called with non-category variant"),
};
Ok(assigned_id)
}
fn apply_add_channel(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
chats_created: &mut Vec<Id>,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
use jmap_chat_types::ChannelCreate;
let create: ChannelCreate = match op {
SpacePatchOp::AddChannel(c) => c,
_ => unreachable!("apply_add_channel called with non-AddChannel variant"),
};
if let Some(cat_id) = &create.category_id {
let space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let exists = space_val
.get("categories")
.and_then(|v| v.as_array())
.is_some_and(|cats| {
cats.iter()
.any(|c| c.get("id").and_then(|s| s.as_str()) == Some(cat_id.as_ref()))
});
if !exists {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["categoryId".to_owned()])
.with_description(format!(
"categoryId {} does not refer to a category of this Space",
cat_id.as_ref()
)),
));
}
}
let new_id = inner.mint_id();
let now = now_utc_string();
let mut chat_obj = serde_json::Map::new();
chat_obj.insert(
"id".to_owned(),
serde_json::Value::String(new_id.as_ref().to_owned()),
);
chat_obj.insert(
"kind".to_owned(),
serde_json::Value::String("channel".to_owned()),
);
chat_obj.insert(
"createdAt".to_owned(),
serde_json::Value::String(now.into_inner()),
);
chat_obj.insert("unreadCount".to_owned(), serde_json::Value::from(0u64));
chat_obj.insert(
"pinnedMessageIds".to_owned(),
serde_json::Value::Array(vec![]),
);
chat_obj.insert("muted".to_owned(), serde_json::Value::Bool(false));
chat_obj.insert(
"receiveTypingIndicators".to_owned(),
serde_json::Value::Bool(true),
);
chat_obj.insert(
"spaceId".to_owned(),
serde_json::Value::String(space_id.as_ref().to_owned()),
);
chat_obj.insert("name".to_owned(), serde_json::Value::String(create.name));
if let Some(cat_id) = &create.category_id {
chat_obj.insert(
"categoryId".to_owned(),
serde_json::Value::String(cat_id.as_ref().to_owned()),
);
}
if let Some(pos) = create.position {
chat_obj.insert("position".to_owned(), serde_json::Value::from(pos));
}
if let Some(topic) = create.topic {
chat_obj.insert("topic".to_owned(), serde_json::Value::String(topic));
}
inner
.objects_mut("Chat", account_id)
.insert(new_id.clone(), serde_json::Value::Object(chat_obj));
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
if let Some(cat_id) = &create.category_id {
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
for cat in cats.iter_mut() {
if cat.get("id").and_then(|s| s.as_str()) == Some(cat_id.as_ref()) {
let ch_ids = cat
.get_mut("channelIds")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Category.channelIds not an array")
})?;
ch_ids.push(serde_json::Value::String(new_id.as_ref().to_owned()));
break;
}
}
} else {
let unc = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.uncategorizedChannelIds not an array")
})?;
unc.push(serde_json::Value::String(new_id.as_ref().to_owned()));
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
chats_created.push(new_id.clone());
*space_mutated = true;
Ok(Some(new_id))
}
fn apply_remove_channel(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
chats_destroyed: &mut Vec<Id>,
messages_destroyed: &mut Vec<Id>,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
let target_id: Id = match op {
SpacePatchOp::RemoveChannel(id) => id,
_ => unreachable!("apply_remove_channel called with non-RemoveChannel variant"),
};
if !channel_belongs_to_space(inner, account_id, &target_id, space_id) {
return Err(Box::new(
SetError::new(SetErrorType::NotFound).with_description(format!(
"channel {} is not a channel of this Space",
target_id.as_ref()
)),
));
}
let cascade_ids = scan_messages_in_chat(inner, account_id, &target_id);
if !cascade_ids.is_empty() {
let msg_map = inner.objects_mut("Message", account_id);
for msg_id in &cascade_ids {
msg_map.remove(msg_id);
}
messages_destroyed.extend(cascade_ids);
}
inner.objects_mut("Chat", account_id).remove(&target_id);
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
if let Some(unc) = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
{
unc.retain(|v| v.as_str() != Some(target_id.as_ref()));
}
if let Some(cats) = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
{
for cat in cats.iter_mut() {
if let Some(ch_ids) = cat.get_mut("channelIds").and_then(|v| v.as_array_mut()) {
ch_ids.retain(|v| v.as_str() != Some(target_id.as_ref()));
}
}
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
chats_destroyed.push(target_id);
*space_mutated = true;
Ok(None)
}
fn apply_update_channel(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
chats_updated: &mut HashSet<Id>,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
use jmap_chat_types::ChannelPatch;
use jmap_chat_types::Clearable;
let (id, patch): (Id, ChannelPatch) = match op {
SpacePatchOp::UpdateChannel { id, patch } => (id, patch),
_ => unreachable!("apply_update_channel called with non-UpdateChannel variant"),
};
if !channel_belongs_to_space(inner, account_id, &id, space_id) {
return Err(Box::new(
SetError::new(SetErrorType::NotFound).with_description(format!(
"channel {} is not a channel of this Space",
id.as_ref()
)),
));
}
if let Some(Clearable::Set(new_cat)) = &patch.category_id {
let space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let exists = space_val
.get("categories")
.and_then(|v| v.as_array())
.is_some_and(|cats| {
cats.iter()
.any(|c| c.get("id").and_then(|s| s.as_str()) == Some(new_cat.as_ref()))
});
if !exists {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["categoryId".to_owned()])
.with_description(format!(
"categoryId {} does not refer to a category of this Space",
new_cat.as_ref()
)),
));
}
}
let old_category_id: Option<Id> = inner
.objects_ref("Chat", account_id)
.and_then(|m| m.get(&id))
.and_then(|v| v.get("categoryId"))
.and_then(|c| c.as_str())
.map(Id::from);
{
let chat_map = inner.objects_mut("Chat", account_id);
let Some(chat_val) = chat_map.get_mut(&id) else {
return Err(Box::new(SetError::new(SetErrorType::NotFound)));
};
let serde_json::Value::Object(obj) = chat_val else {
return Err(Box::new(
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Chat record not a JSON object"),
));
};
if let Some(name) = patch.name {
obj.insert("name".to_owned(), serde_json::Value::String(name));
}
if let Some(pos) = patch.position {
obj.insert("position".to_owned(), serde_json::Value::from(pos));
}
match patch.topic {
Some(Clearable::Set(t)) => {
obj.insert("topic".to_owned(), serde_json::Value::String(t));
}
Some(Clearable::Clear) => {
obj.remove("topic");
}
None => {}
}
match &patch.category_id {
Some(Clearable::Set(c)) => {
obj.insert(
"categoryId".to_owned(),
serde_json::Value::String(c.as_ref().to_owned()),
);
}
Some(Clearable::Clear) => {
obj.remove("categoryId");
}
None => {}
}
match patch.slow_mode_seconds {
Some(Clearable::Set(s)) => {
obj.insert("slowModeSeconds".to_owned(), serde_json::Value::from(s));
}
Some(Clearable::Clear) => {
obj.remove("slowModeSeconds");
}
None => {}
}
match patch.permission_overrides {
Some(Clearable::Set(po)) => {
let val = serde_json::to_value(&po).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: serialize permissionOverrides: {e}"))
})?;
obj.insert("permissionOverrides".to_owned(), val);
}
Some(Clearable::Clear) => {
obj.remove("permissionOverrides");
}
None => {}
}
}
let category_changed = patch.category_id.is_some();
if category_changed {
let new_category_id: Option<Id> = match &patch.category_id {
Some(Clearable::Set(c)) => Some(c.clone()),
Some(Clearable::Clear) => None,
None => unreachable!(),
};
if old_category_id != new_category_id {
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
match &old_category_id {
Some(prev_cat) => {
if let Some(cats) = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
{
for cat in cats.iter_mut() {
if cat.get("id").and_then(|s| s.as_str()) == Some(prev_cat.as_ref()) {
if let Some(ch_ids) =
cat.get_mut("channelIds").and_then(|v| v.as_array_mut())
{
ch_ids.retain(|v| v.as_str() != Some(id.as_ref()));
}
break;
}
}
}
}
None => {
if let Some(unc) = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
{
unc.retain(|v| v.as_str() != Some(id.as_ref()));
}
}
}
if let Some(new_cat) = &new_category_id {
let cats = space_val
.get_mut("categories")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.categories not an array")
})?;
for cat in cats.iter_mut() {
if cat.get("id").and_then(|s| s.as_str()) == Some(new_cat.as_ref()) {
let ch_ids = cat
.get_mut("channelIds")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Category.channelIds not an array")
})?;
ch_ids.push(serde_json::Value::String(id.as_ref().to_owned()));
break;
}
}
} else {
let unc = space_val
.get_mut("uncategorizedChannelIds")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden).with_description(
"internal: Space.uncategorizedChannelIds not an array",
)
})?;
unc.push(serde_json::Value::String(id.as_ref().to_owned()));
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
}
}
chats_updated.insert(id);
Ok(None)
}
fn apply_add_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
let role = match op {
SpacePatchOp::AddRole(r) => r,
_ => unreachable!("apply_add_role called with non-AddRole variant"),
};
let new_id = inner.mint_id();
let mut stored = serde_json::to_value(&role).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: serialize RoleCreate: {e}"))
})?;
if let Some(fields) = stored.as_object_mut() {
fields.insert("id".to_owned(), serde_json::Value::from(new_id.as_ref()));
}
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let roles = space_val
.get_mut("roles")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.roles not an array")
})?;
roles.push(stored);
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Ok(Some(new_id))
}
fn apply_remove_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
chats_updated: &mut HashSet<Id>,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
let target_id = match op {
SpacePatchOp::RemoveRole(id) => id,
_ => unreachable!("apply_remove_role called with non-RemoveRole variant"),
};
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let roles = space_val
.get_mut("roles")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.roles not an array")
})?;
let pos = roles
.iter()
.position(|v| v.get("id").and_then(|s| s.as_str()) == Some(target_id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("role {} not found", target_id.as_ref())),
));
};
roles.remove(pos);
if let Some(members) = space_val.get_mut("members").and_then(|v| v.as_array_mut()) {
for member in members.iter_mut() {
if let Some(role_ids) = member.get_mut("roleIds").and_then(|v| v.as_array_mut()) {
role_ids.retain(|v| v.as_str() != Some(target_id.as_ref()));
}
}
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
for (chat_id, chat) in inner.objects_mut("Chat", account_id).iter_mut() {
if chat.get("kind").and_then(|k| k.as_str()) != Some("channel")
|| chat.get("spaceId").and_then(|s| s.as_str()) != Some(space_id.as_ref())
{
continue;
}
let Some(overrides) = chat
.get_mut("permissionOverrides")
.and_then(|v| v.as_array_mut())
else {
continue;
};
let before = overrides.len();
overrides.retain(|o| {
o.get("targetType").and_then(|t| t.as_str()) != Some("role")
|| o.get("targetId").and_then(|t| t.as_str()) != Some(target_id.as_ref())
});
if overrides.len() != before {
chats_updated.insert(chat_id.clone());
}
}
Ok(None)
}
fn apply_update_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
use jmap_chat_types::Clearable;
use jmap_chat_types::SpaceRole;
let (target_id, patch) = match op {
SpacePatchOp::UpdateRole { id, patch } => (id, patch),
_ => unreachable!("apply_update_role called with non-UpdateRole variant"),
};
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let roles = space_val
.get_mut("roles")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.roles not an array")
})?;
let pos = roles
.iter()
.position(|v| v.get("id").and_then(|s| s.as_str()) == Some(target_id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("role {} not found", target_id.as_ref())),
));
};
let mut role: SpaceRole = serde_json::from_value(roles[pos].clone()).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: deserialize SpaceRole: {e}"))
})?;
if let Some(name) = patch.name {
role.name = name;
}
match patch.color {
Some(Clearable::Set(c)) => role.color = Some(c),
Some(Clearable::Clear) => role.color = None,
None => {}
}
if let Some(permissions) = patch.permissions {
role.permissions = permissions;
}
if let Some(position) = patch.position {
role.position = position;
}
roles[pos] = serde_json::to_value(&role).map_err(|e| {
SetError::new(SetErrorType::Forbidden)
.with_description(format!("internal: serialize SpaceRole: {e}"))
})?;
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Ok(None)
}
fn apply_add_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
let (user_id, role_ids) = match op {
SpacePatchOp::AddMember(create) => (create.user_id, create.role_ids),
_ => unreachable!("apply_add_member called with non-AddMember variant"),
};
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
if space_val
.get("members")
.and_then(|v| v.as_array())
.is_some_and(|members| {
members
.iter()
.any(|m| m.get("id").and_then(|v| v.as_str()) == Some(user_id.as_ref()))
})
{
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["userId".to_owned()])
.with_description(format!(
"member {} is already a member of this Space",
user_id.as_ref()
)),
));
}
if !role_ids.is_empty() {
let existing: HashSet<String> = space_val
.get("roles")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|r| r.get("id").and_then(|v| v.as_str()).map(str::to_owned))
.collect()
})
.unwrap_or_default();
for rid in &role_ids {
if !existing.contains(rid.as_ref()) {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["roleIds".to_owned()])
.with_description(format!(
"role {} does not exist in this Space",
rid.as_ref()
)),
));
}
}
}
let mut member_obj = serde_json::Map::new();
member_obj.insert(
"id".to_owned(),
serde_json::Value::String(user_id.as_ref().to_owned()),
);
member_obj.insert(
"roleIds".to_owned(),
serde_json::Value::Array(
role_ids
.iter()
.map(|id| serde_json::Value::String(id.as_ref().to_owned()))
.collect(),
),
);
member_obj.insert(
"joinedAt".to_owned(),
serde_json::Value::String(now_utc_string().into_inner()),
);
let members = space_val
.get_mut("members")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.members not an array")
})?;
members.push(serde_json::Value::Object(member_obj));
let new_count = members.len() as u64;
if let Some(count_field) = space_val.get_mut("memberCount") {
*count_field = serde_json::Value::from(new_count);
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Ok(None)
}
fn apply_remove_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
let target_id = match op {
SpacePatchOp::RemoveMember(id) => id,
_ => unreachable!("apply_remove_member called with non-RemoveMember variant"),
};
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
let members = space_val
.get_mut("members")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.members not an array")
})?;
let pos = members
.iter()
.position(|m| m.get("id").and_then(|v| v.as_str()) == Some(target_id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("member {} not found", target_id.as_ref())),
));
};
members.remove(pos);
let new_count = members.len() as u64;
if let Some(count_field) = space_val.get_mut("memberCount") {
*count_field = serde_json::Value::from(new_count);
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Ok(None)
}
fn apply_update_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, Box<SetError>> {
use jmap_chat_types::Clearable;
let (user_id, patch) = match op {
SpacePatchOp::UpdateMember { user_id, patch } => (user_id, patch),
_ => unreachable!("apply_update_member called with non-UpdateMember variant"),
};
let mut space_val = inner
.objects_ref("Space", account_id)
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| SetError::new(SetErrorType::NotFound))?;
if let Some(role_ids) = &patch.role_ids {
let existing: HashSet<String> = space_val
.get("roles")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|r| r.get("id").and_then(|v| v.as_str()).map(str::to_owned))
.collect()
})
.unwrap_or_default();
for rid in role_ids {
if !existing.contains(rid.as_ref()) {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["roleIds".to_owned()])
.with_description(format!(
"role {} does not exist in this Space",
rid.as_ref()
)),
));
}
}
}
let members = space_val
.get_mut("members")
.and_then(|v| v.as_array_mut())
.ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: Space.members not an array")
})?;
let pos = members
.iter()
.position(|m| m.get("id").and_then(|v| v.as_str()) == Some(user_id.as_ref()));
let Some(pos) = pos else {
return Err(Box::new(
SetError::new(SetErrorType::NotFound)
.with_description(format!("member {} not found", user_id.as_ref())),
));
};
let member_obj = members[pos].as_object_mut().ok_or_else(|| {
SetError::new(SetErrorType::Forbidden)
.with_description("internal: SpaceMember not a JSON object")
})?;
if let Some(role_ids) = patch.role_ids {
member_obj.insert(
"roleIds".to_owned(),
serde_json::Value::Array(
role_ids
.iter()
.map(|id| serde_json::Value::String(id.as_ref().to_owned()))
.collect(),
),
);
}
match patch.nick {
Some(Clearable::Set(s)) => {
member_obj.insert("nick".to_owned(), serde_json::Value::String(s));
}
Some(Clearable::Clear) => {
member_obj.remove("nick");
}
None => {}
}
inner
.objects_mut("Space", account_id)
.insert(space_id.clone(), space_val);
*space_mutated = true;
Ok(None)
}
fn check_count_caps(
space_val: &serde_json::Value,
ops: &[SpacePatchOp],
limits: &ChatLimits,
) -> Option<SetError> {
let (add_roles, add_members, add_channels, add_categories) = crate::helpers::count_add_ops(ops);
if add_roles == 0 && add_members == 0 && add_channels == 0 && add_categories == 0 {
return None;
}
let count_array = |key: &str| -> u32 {
space_val
.get(key)
.and_then(|v| v.as_array())
.map(|a| u32::try_from(a.len()).unwrap_or(u32::MAX))
.unwrap_or(0)
};
let cur_roles = count_array("roles");
let cur_members = count_array("members");
let cur_categories = count_array("categories");
let uncategorized = space_val
.get("uncategorizedChannelIds")
.and_then(|v| v.as_array())
.map(|a| a.len())
.unwrap_or(0);
let categorized: usize = space_val
.get("categories")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.map(|c| {
c.get("channelIds")
.and_then(|v| v.as_array())
.map(|a| a.len())
.unwrap_or(0)
})
.sum()
})
.unwrap_or(0);
let cur_channels = u32::try_from(uncategorized + categorized).unwrap_or(u32::MAX);
let exceeded =
|description: &'static str, current: u32, add: u32, cap: u32| -> Option<SetError> {
if add == 0 {
return None;
}
if current.saturating_add(add) > cap {
Some(SetError::new(SetErrorType::OverQuota).with_description(description))
} else {
None
}
};
[
(
"too many roles",
cur_roles,
add_roles,
limits.max_roles_per_space,
),
(
"too many members",
cur_members,
add_members,
limits.max_space_members,
),
(
"too many channels",
cur_channels,
add_channels,
limits.max_channels_per_space,
),
(
"too many categories",
cur_categories,
add_categories,
limits.max_categories_per_space,
),
]
.into_iter()
.find_map(|(description, current, add, cap)| exceeded(description, current, add, cap))
}
fn validate_space_patch_ops(
space_val: &serde_json::Value,
account_id: &Id,
ops: &[SpacePatchOp],
protect_last_admin: bool,
everyone: &HashSet<ChatPermission>,
) -> Result<(), Box<SetError>> {
use crate::permissions::{RequiredPermissions, required_permissions_for_op};
let mut removed = ops.iter().filter_map(|op| match op {
SpacePatchOp::RemoveMember(id) => Some(id),
_ => None,
});
let self_removal =
matches!((removed.next(), removed.next()), (Some(id), None) if id == account_id);
let mut updated = ops.iter().filter_map(|op| match op {
SpacePatchOp::UpdateMember { user_id, patch } => Some((user_id, patch)),
_ => None,
});
let self_nick = match (updated.next(), updated.next()) {
(Some((id, patch)), None) => {
id == account_id
&& patch.nick.is_some()
&& patch.role_ids.is_none()
&& patch.extra.is_empty()
}
_ => false,
};
let caller_perms =
caller_effective_permissions(space_val, account_id, everyone).unwrap_or_default();
let caller_highest = caller_highest_position(space_val, account_id).unwrap_or(0);
for op in ops {
let required = match required_permissions_for_op(op) {
RequiredPermissions::Known(slice) => slice,
RequiredPermissions::UnknownOp => {
return Err(Box::new(
SetError::new(SetErrorType::Forbidden).with_description(format!(
"unknown SpacePatchOp variant `{}`; this version of \
the kit cannot determine its permission requirement, \
rejecting fail-closed",
variant_name(op)
)),
));
}
};
let required = if (self_removal && matches!(op, SpacePatchOp::RemoveMember(_)))
|| (self_nick && matches!(op, SpacePatchOp::UpdateMember { .. }))
{
&[]
} else {
required
};
for req in required {
if !caller_perms.contains(req) {
return Err(Box::new(
SetError::new(SetErrorType::Forbidden).with_description(format!(
"caller lacks required permission `{}` for {}",
req,
variant_name(op)
)),
));
}
}
match op {
SpacePatchOp::AddRole(role) if role.position >= caller_highest => {
return Err(Box::new(hierarchy_error(
role.position,
caller_highest,
"AddRole",
)));
}
SpacePatchOp::RemoveRole(target_id) => {
if let Some(pos) = role_position(space_val, target_id.as_ref())
&& pos >= caller_highest
{
return Err(Box::new(hierarchy_error(pos, caller_highest, "RemoveRole")));
}
}
SpacePatchOp::UpdateRole { id, patch } => {
if let Some(pos) = role_position(space_val, id.as_ref())
&& pos >= caller_highest
{
return Err(Box::new(hierarchy_error(pos, caller_highest, "UpdateRole")));
}
if let Some(new_pos) = patch.position
&& new_pos >= caller_highest
{
return Err(Box::new(hierarchy_error(
new_pos,
caller_highest,
"UpdateRole (new position)",
)));
}
}
SpacePatchOp::AddMember(create) => {
for rid in &create.role_ids {
if let Some(pos) = role_position(space_val, rid.as_ref())
&& pos >= caller_highest
{
return Err(Box::new(hierarchy_error(pos, caller_highest, "AddMember")));
}
}
}
SpacePatchOp::UpdateMember { user_id, patch } => {
if let Some(role_ids) = &patch.role_ids {
let current = member_role_ids(space_val, user_id.as_ref());
let new: HashSet<&str> = role_ids.iter().map(|r| r.as_ref()).collect();
for rid in current.symmetric_difference(&new) {
if let Some(pos) = role_position(space_val, rid)
&& pos >= caller_highest
{
return Err(Box::new(hierarchy_error(
pos,
caller_highest,
"UpdateMember",
)));
}
}
}
}
SpacePatchOp::RemoveMember(_) => {
}
_ => {}
}
}
if protect_last_admin && let Some(keys) = last_admin_patch_keys(space_val, ops, self_removal) {
return Err(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(keys)
.with_description(
"this patch would leave the Space with no \
`manage_members`/`manage_space` holder (last-admin protection)",
),
));
}
Ok(())
}
fn last_admin_patch_keys(
space_val: &serde_json::Value,
ops: &[SpacePatchOp],
self_removal: bool,
) -> Option<Vec<&'static str>> {
let grants_admin = |p: &str| {
p == ChatPermission::ManageMembers.as_str() || p == ChatPermission::ManageSpace.as_str()
};
let pre_roles: HashMap<&str, bool> = space_val
.get("roles")
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|r| {
let id = r.get("id")?.as_str()?;
let admin = r
.get("permissions")
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|p| p.as_str())
.any(grants_admin);
Some((id, admin))
})
.collect();
let pre_members: HashMap<&str, HashSet<&str>> = space_val
.get("members")
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|m| {
let id = m.get("id")?.as_str()?;
Some((id, member_role_ids(space_val, id)))
})
.collect();
let is_admin = |roles: &HashMap<&str, bool>, role_ids: &HashSet<&str>| {
role_ids
.iter()
.any(|r| roles.get(r).copied().unwrap_or(false))
};
if !pre_members.values().any(|ids| is_admin(&pre_roles, ids)) {
return None;
}
let mut roles = pre_roles.clone();
let mut members = pre_members.clone();
let mut flagged = [false; 4];
const KEYS: [&str; 4] = [
"removeRoles",
"updateRoles",
"removeMembers",
"updateMembers",
];
for op in ops {
match op {
SpacePatchOp::RemoveRole(id) => {
flagged[0] |= pre_roles.get(id.as_ref()).copied().unwrap_or(false);
roles.remove(id.as_ref());
}
SpacePatchOp::UpdateRole { id, patch } => {
if let (Some(perms), Some(admin)) = (&patch.permissions, roles.get_mut(id.as_ref()))
{
*admin = perms.iter().any(|p| grants_admin(p.as_str()));
flagged[1] |= pre_roles[id.as_ref()] && !*admin;
}
}
SpacePatchOp::RemoveMember(id) if !self_removal => {
if let Some(ids) = pre_members.get(id.as_ref()) {
flagged[2] |= is_admin(&pre_roles, ids);
}
members.remove(id.as_ref());
}
SpacePatchOp::UpdateMember { user_id, patch } => {
if let (Some(new), Some(cur)) = (&patch.role_ids, members.get_mut(user_id.as_ref()))
{
*cur = new.iter().map(|r| r.as_ref()).collect();
flagged[3] |= pre_members
.get(user_id.as_ref())
.is_some_and(|pre| is_admin(&pre_roles, pre))
&& !is_admin(&pre_roles, cur);
}
}
SpacePatchOp::AddMember(create) => {
members.insert(
create.user_id.as_ref(),
create.role_ids.iter().map(|r| r.as_ref()).collect(),
);
}
_ => {}
}
}
if members.values().any(|ids| is_admin(&roles, ids)) {
return None;
}
Some(
KEYS.iter()
.zip(flagged)
.filter_map(|(k, f)| f.then_some(*k))
.collect(),
)
}
fn hierarchy_error(target_pos: u64, caller_highest: u64, op_label: &str) -> SetError {
SetError::new(SetErrorType::Forbidden).with_description(format!(
"{op_label}: target role position {target_pos} is not strictly less than \
caller's highest role position {caller_highest} (role-position hierarchy, \
draft §Space/set L1260, L1266)"
))
}
fn caller_effective_permissions(
space_val: &serde_json::Value,
caller_id: &Id,
everyone: &HashSet<ChatPermission>,
) -> Option<HashSet<ChatPermission>> {
member_effective_permissions(space_val, caller_id.as_ref(), everyone)
}
fn member_effective_permissions(
space_val: &serde_json::Value,
member_id: &str,
everyone: &HashSet<ChatPermission>,
) -> Option<HashSet<ChatPermission>> {
let members = space_val.get("members").and_then(|v| v.as_array())?;
let member = members
.iter()
.find(|m| m.get("id").and_then(|v| v.as_str()) == Some(member_id))?;
let role_ids: HashSet<String> = member
.get("roleIds")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default();
let mut perms = everyone.clone();
if let Some(roles) = space_val.get("roles").and_then(|v| v.as_array()) {
for role in roles {
let Some(rid) = role.get("id").and_then(|v| v.as_str()) else {
continue;
};
if !role_ids.contains(rid) {
continue;
}
if let Some(role_perms) = role.get("permissions").and_then(|v| v.as_array()) {
perms.extend(
role_perms
.iter()
.filter_map(|p| serde_json::from_value(p.clone()).ok()),
);
}
}
}
Some(perms)
}
fn owner_channel_permissions(
inner: &Inner,
account_id: &Id,
chat: &serde_json::Value,
) -> Option<HashSet<ChatPermission>> {
use crate::permissions::resolve_channel_permissions;
use jmap_chat_types::ChannelPermission;
let space_id = chat.get("spaceId").and_then(|v| v.as_str())?;
let space = inner
.objects_ref("Space", account_id.as_ref())?
.get(&Id::from(space_id))?;
let base = caller_effective_permissions(space, account_id, inner.everyone_in(space))?;
let overrides: Vec<ChannelPermission> = match chat.get("permissionOverrides") {
None | Some(serde_json::Value::Null) => Vec::new(),
Some(v) => serde_json::from_value(v.clone()).ok()?,
};
let role_ids = member_role_ids(space, account_id.as_ref());
Some(resolve_channel_permissions(
base,
space_id,
account_id.as_ref(),
&role_ids,
&overrides,
))
}
fn owner_may_view_chat(inner: &Inner, account_id: &Id, chat_id: &Id) -> bool {
let Some(chat) = inner
.objects_ref("Chat", account_id.as_ref())
.and_then(|m| m.get(chat_id))
else {
return true;
};
if chat.get("kind").and_then(|v| v.as_str()) != Some("channel") {
return true;
}
owner_channel_permissions(inner, account_id, chat)
.is_some_and(|perms| perms.contains(&ChatPermission::View))
}
fn caller_highest_position(space_val: &serde_json::Value, caller_id: &Id) -> Option<u64> {
let members = space_val.get("members").and_then(|v| v.as_array())?;
let member = members
.iter()
.find(|m| m.get("id").and_then(|v| v.as_str()) == Some(caller_id.as_ref()))?;
let role_ids: HashSet<String> = member
.get("roleIds")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default();
let mut max: u64 = 0;
if let Some(roles) = space_val.get("roles").and_then(|v| v.as_array()) {
for role in roles {
let Some(rid) = role.get("id").and_then(|v| v.as_str()) else {
continue;
};
if !role_ids.contains(rid) {
continue;
}
let Some(pos) = role.get("position").and_then(|v| v.as_u64()) else {
continue;
};
if pos > max {
max = pos;
}
}
}
Some(max)
}
fn member_role_ids<'a>(space_val: &'a serde_json::Value, member_id: &str) -> HashSet<&'a str> {
space_val
.get("members")
.and_then(|v| v.as_array())
.and_then(|ms| {
ms.iter()
.find(|m| m.get("id").and_then(|v| v.as_str()) == Some(member_id))
})
.and_then(|m| m.get("roleIds"))
.and_then(|v| v.as_array())
.map(|ids| ids.iter().filter_map(|v| v.as_str()).collect())
.unwrap_or_default()
}
fn role_position(space_val: &serde_json::Value, role_id: &str) -> Option<u64> {
let roles = space_val.get("roles").and_then(|v| v.as_array())?;
roles
.iter()
.find(|r| r.get("id").and_then(|v| v.as_str()) == Some(role_id))
.and_then(|r| r.get("position").and_then(|v| v.as_u64()))
}
fn broadcast_mention_matches_owner(
bm: &serde_json::Value,
owner_is_admin: impl FnOnce() -> bool,
) -> bool {
match bm.get("scope").and_then(|v| v.as_str()) {
Some("everyone") => true,
Some("here") => true,
Some("admins") => owner_is_admin(),
_ => false, }
}
fn owner_is_chat_admin(
inner: &Inner,
account_id: &Id,
chat_id: Option<&serde_json::Value>,
) -> bool {
let Some(chat) = chat_id.and_then(|v| v.as_str()).and_then(|id| {
inner
.objects_ref("Chat", account_id.as_ref())?
.get(&Id::from(id))
}) else {
return false;
};
match chat.get("kind").and_then(|v| v.as_str()) {
Some("group") => is_group_admin(chat, account_id),
Some("channel") => chat
.get("spaceId")
.and_then(|v| v.as_str())
.and_then(|sid| {
inner
.objects_ref("Space", account_id.as_ref())?
.get(&Id::from(sid))
})
.and_then(|space| {
caller_effective_permissions(space, account_id, inner.everyone_in(space))
})
.is_some_and(|perms| {
perms.contains(&ChatPermission::ManageMembers)
|| perms.contains(&ChatPermission::ManageSpace)
}),
_ => false,
}
}
fn is_group_admin(chat: &serde_json::Value, member_id: &Id) -> bool {
chat.get("members")
.and_then(|v| v.as_array())
.is_some_and(|members| {
members.iter().any(|m| {
m.get("id").and_then(|v| v.as_str()) == Some(member_id.as_ref())
&& m.get("role").and_then(|v| v.as_str()) == Some("admin")
})
})
}
fn emoji_name_holder(
inner: &Inner,
account_id: &Id,
emoji: &serde_json::Value,
except: Option<&Id>,
) -> Option<Id> {
let scope = |e: &serde_json::Value| e.get("spaceId").filter(|v| !v.is_null()).cloned();
inner
.objects_ref("CustomEmoji", account_id.as_ref())?
.iter()
.find(|(id, e)| {
Some(*id) != except && e.get("name") == emoji.get("name") && scope(e) == scope(emoji)
})
.map(|(id, _)| id.clone())
}
fn emoji_scope(emoji: &serde_json::Value) -> Option<serde_json::Value> {
emoji.get("spaceId").filter(|v| !v.is_null()).cloned()
}
fn emoji_count_in_space(inner: &Inner, account_id: &str, space: &serde_json::Value) -> u64 {
inner.objects_ref("CustomEmoji", account_id).map_or(0, |m| {
m.values()
.filter(|e| emoji_scope(e).as_ref() == Some(space))
.fold(0, |n, _| n.saturating_add(1))
})
}
fn emoji_blob_over_cap(
inner: &Inner,
account_id: &Id,
emoji: &serde_json::Value,
limits: &ChatLimits,
) -> bool {
let (Some(max), Some(blob_id)) = (
limits.max_custom_emoji_bytes,
emoji.get("blobId").and_then(serde_json::Value::as_str),
) else {
return false;
};
inner
.attachment_blobs
.get(&(account_id.as_ref().to_owned(), Id::from(blob_id)))
.is_some_and(|b| b.size > max)
}
fn over_quota_error(description: &str) -> BackendSetError<MemoryError> {
BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::OverQuota).with_description(description),
))
}
fn compare_by_sort(
a: &serde_json::Value,
b: &serde_json::Value,
comparators: &[serde_json::Value],
) -> std::cmp::Ordering {
use serde_json::Value;
use std::cmp::Ordering;
for c in comparators {
let Some(property) = c.get("property").and_then(Value::as_str) else {
continue;
};
let x = a.get(property).filter(|v| !v.is_null());
let y = b.get(property).filter(|v| !v.is_null());
let ord = match (x, y) {
(None, None) => Ordering::Equal,
(None, Some(_)) => Ordering::Greater,
(Some(_), None) => Ordering::Less,
(Some(x), Some(y)) => {
let ord = match (x, y) {
(Value::String(x), Value::String(y)) => {
match (utc_date_key(x), utc_date_key(y)) {
(Some(x), Some(y)) => x.cmp(&y),
_ => x.cmp(y),
}
}
(Value::Number(x), Value::Number(y)) => x
.as_f64()
.partial_cmp(&y.as_f64())
.unwrap_or(Ordering::Equal),
(Value::Bool(x), Value::Bool(y)) => x.cmp(y),
_ => Ordering::Equal,
};
if c.get("isAscending").and_then(Value::as_bool) == Some(false) {
ord.reverse()
} else {
ord
}
}
};
if ord != Ordering::Equal {
return ord;
}
}
Ordering::Equal
}
fn utc_date_key(s: &str) -> Option<(i64, &str)> {
let secs = jmap_types::UTCDate::from(s).to_epoch_seconds().ok()?;
let frac = s
.strip_suffix('Z')?
.split_once('.')
.map_or("", |(_, f)| f.trim_end_matches('0'));
Some((secs, frac))
}
fn filter_matches(
inner: &Inner,
type_name: &str,
obj: &serde_json::Value,
filter: &serde_json::Value,
account_id: &Id,
) -> bool {
let mut conditions = filter
.get("conditions")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten();
let sub = |f: &serde_json::Value| filter_matches(inner, type_name, obj, f, account_id);
match filter.get("operator").and_then(serde_json::Value::as_str) {
Some("AND") => conditions.all(sub),
Some("OR") => conditions.any(sub),
Some("NOT") => !conditions.any(sub),
_ => condition_matches(inner, type_name, obj, filter, account_id),
}
}
const METADATA_CONDITION_KEYS: [&str; 6] = [
"metadataExists",
"privateMetadataExists",
"metadataTextContains",
"privateMetadataTextContains",
"metadataTextEquals",
"privateMetadataTextEquals",
];
fn check_metadata_filter(
filter: &serde_json::Value,
info: Option<&DataTypeMetadataInfo>,
) -> Result<(), BackendQueryError<MemoryError>> {
let unsupported = |description: String| {
let mut err = jmap_types::JmapError::unsupported_filter();
err.description = Some(description);
BackendQueryError::Method(err)
};
if filter.get("operator").is_some() {
return filter
.get("conditions")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
.try_for_each(|f| check_metadata_filter(f, info));
}
let Some(leaf) = filter.as_object() else {
return Ok(());
};
if !METADATA_CONDITION_KEYS
.iter()
.any(|k| leaf.contains_key(*k))
{
return Ok(());
}
let Some(info) = info else {
return Err(unsupported(
"metadata filter conditions are not supported".to_owned(),
));
};
MetadataCondition::take_from(&mut leaf.clone(), info)
.map(drop)
.map_err(|e| match e {
MetadataFilterError::InvalidArguments(d) => {
BackendQueryError::Method(jmap_types::JmapError::invalid_arguments(d))
}
other => unsupported(other.to_string()),
})
}
fn metadata_leaf_matches(obj: &serde_json::Value, cond: &serde_json::Value) -> bool {
<MetadataCondition as serde::Deserialize>::deserialize(cond)
.is_ok_and(|c| c.matches(obj.get("metadata").and_then(|m| m.as_object()), None))
}
fn has_is_public_true(filter: &serde_json::Value) -> bool {
filter.get("isPublic") == Some(&serde_json::Value::Bool(true))
|| filter
.get("conditions")
.and_then(serde_json::Value::as_array)
.is_some_and(|cs| cs.iter().any(has_is_public_true))
}
fn condition_matches(
inner: &Inner,
type_name: &str,
obj: &serde_json::Value,
cond: &serde_json::Value,
account_id: &Id,
) -> bool {
let eq = |k: &str| cond.get(k).is_none_or(|want| obj.get(k) == Some(want));
let flag_eq = |k: &str| {
cond.get(k)
.and_then(serde_json::Value::as_bool)
.is_none_or(|want| {
obj.get(k)
.and_then(serde_json::Value::as_bool)
.unwrap_or(false)
== want
})
};
match type_name {
"Chat" => eq("kind") && flag_eq("muted") && metadata_leaf_matches(obj, cond),
"ChatContact" => flag_eq("blocked") && eq("presence") && eq("identity"),
"Message" => {
message_matches_filter(inner, obj, cond, account_id)
&& metadata_leaf_matches(obj, cond)
&& message_where_matches(inner, obj, cond)
}
"Space" => {
flag_eq("isPublic")
&& metadata_leaf_matches(obj, cond)
&& cond
.get("name")
.and_then(serde_json::Value::as_str)
.is_none_or(|part| {
obj.get("name")
.and_then(serde_json::Value::as_str)
.is_some_and(|name| name.contains(part))
})
}
"CustomEmoji" => eq("spaceId"),
_ => true,
}
}
fn message_matches_filter(
inner: &Inner,
obj: &serde_json::Value,
filter: &serde_json::Value,
account_id: &Id,
) -> bool {
let eq = |k: &str| filter.get(k).is_none_or(|want| obj.get(k) == Some(want));
if !(eq("chatId") && eq("threadRootId") && eq("topicId")) {
return false;
}
if let Some(want) = filter.get("hasAttachment").and_then(|v| v.as_bool()) {
let has = obj
.get("attachments")
.and_then(|v| v.as_array())
.is_some_and(|a| !a.is_empty());
if has != want {
return false;
}
}
if let Some(want) = filter.get("hasMention").and_then(|v| v.as_bool()) {
let has_direct = obj
.get("mentions")
.and_then(|v| v.as_array())
.is_some_and(|arr| {
arr.iter()
.any(|m| m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref()))
});
let has = has_direct
|| obj
.get("broadcastMentions")
.and_then(|v| v.as_array())
.is_some_and(|arr| {
arr.iter().any(|bm| {
broadcast_mention_matches_owner(bm, || {
owner_is_chat_admin(inner, account_id, obj.get("chatId"))
})
})
});
if has != want {
return false;
}
}
true
}
fn check_where(
filter: &serde_json::Value,
type_name: &str,
search: Option<&jmap_search::SearchCapability>,
) -> Result<(), BackendQueryError<MemoryError>> {
for w in jmap_search::where_values(filter) {
let Some(cap) = search else {
return Err(BackendQueryError::Method(
jmap_types::JmapError::unsupported_filter(),
));
};
jmap_search::check_where(w, type_name, cap).map_err(BackendQueryError::Method)?;
}
Ok(())
}
fn message_where_matches(inner: &Inner, obj: &serde_json::Value, cond: &serde_json::Value) -> bool {
struct MessageCandidate(serde_json::Value);
impl jmap_search::Candidate for MessageCandidate {
fn field(&self, pointer: &str) -> Option<&serde_json::Value> {
self.0.pointer(pointer)
}
fn matches_text(&self, text: &str) -> bool {
let casemap = Some("i;unicode-casemap");
self.0
.get("body")
.and_then(serde_json::Value::as_str)
.is_some_and(|b| {
jmap_search::collate(b, casemap).contains(&*jmap_search::collate(text, casemap))
})
}
}
let Some(w) = cond.get("where").filter(|w| !w.is_null()) else {
return true;
};
let Ok(expr) = jmap_search::Expression::parse(w) else {
return false;
};
let mut json = obj.clone();
if !inner.retains_edit_history
&& let Some(m) = json.as_object_mut()
{
m.remove("editHistory");
}
expr.matches(&MessageCandidate(json))
}
fn scan_messages_in_chat(inner: &Inner, account_id: &str, chat_id: &Id) -> Vec<Id> {
let Some(msgs) = inner.objects_ref("Message", account_id) else {
return Vec::new();
};
msgs.iter()
.filter(|(_, v)| v.get("chatId").and_then(|c| c.as_str()) == Some(chat_id.as_ref()))
.map(|(id, _)| id.clone())
.collect()
}
fn destroy_read_positions(inner: &mut Inner, account_id: &str, chat_ids: &[Id]) {
let doomed: Vec<Id> = inner
.objects_ref("ReadPosition", account_id)
.map(|positions| {
positions
.iter()
.filter(|(_, v)| {
v.get("chatId")
.and_then(|c| c.as_str())
.is_some_and(|c| chat_ids.iter().any(|id| id.as_ref() == c))
})
.map(|(id, _)| id.clone())
.collect()
})
.unwrap_or_default();
if doomed.is_empty() {
return;
}
let positions = inner.objects_mut("ReadPosition", account_id);
for id in &doomed {
positions.remove(id);
}
let new_state = inner.bump_state("ReadPosition", account_id);
inner
.change_log_mut("ReadPosition", account_id)
.push(ChangeEntry {
new_state,
created: vec![],
updated: vec![],
destroyed: doomed,
restored: vec![],
updated_props: None,
});
}
fn channel_belongs_to_space(inner: &Inner, account_id: &str, chat_id: &Id, space_id: &Id) -> bool {
inner
.objects_ref("Chat", account_id)
.and_then(|m| m.get(chat_id))
.map(|v| {
v.get("kind").and_then(|k| k.as_str()) == Some("channel")
&& v.get("spaceId").and_then(|s| s.as_str()) == Some(space_id.as_ref())
})
.unwrap_or(false)
}
fn scan_channels_in_category(inner: &Inner, account_id: &str, target_id: &Id) -> Vec<Id> {
let Some(chats) = inner.objects_ref("Chat", account_id) else {
return Vec::new();
};
chats
.iter()
.filter(|(_, v)| {
v.get("kind").and_then(|k| k.as_str()) == Some("channel")
&& v.get("categoryId").and_then(|c| c.as_str()) == Some(target_id.as_ref())
})
.map(|(id, _)| id.clone())
.collect()
}
fn remove_from_categories<S: AsRef<str>>(cats: &mut [serde_json::Value], ids: &[S]) {
for cat in cats {
if let Some(ch_ids) = cat.get_mut("channelIds").and_then(|v| v.as_array_mut()) {
ch_ids.retain(|v| {
v.as_str()
.is_none_or(|s| !ids.iter().any(|id| id.as_ref() == s))
});
}
}
}
fn set_channel_category(inner: &mut Inner, account_id: &str, chat_id: &Id, new_cat: Option<&Id>) {
let map = inner.objects_mut("Chat", account_id);
let Some(chat_val) = map.get_mut(chat_id) else {
return;
};
let obj = match chat_val {
serde_json::Value::Object(o) => o,
_ => return,
};
match new_cat {
Some(cat_id) => {
obj.insert(
"categoryId".to_owned(),
serde_json::Value::String(cat_id.as_ref().to_owned()),
);
}
None => {
obj.remove("categoryId");
}
}
}
fn stub_description(op: &SpacePatchOp) -> String {
let _ = op;
"unknown SpacePatchOp variant (tracked under bd:JMAP-g7wu.2.4)".to_owned()
}
fn variant_name(op: &SpacePatchOp) -> &'static str {
match op {
SpacePatchOp::AddRole(_) => "AddRole",
SpacePatchOp::RemoveRole(_) => "RemoveRole",
SpacePatchOp::UpdateRole { .. } => "UpdateRole",
SpacePatchOp::AddMember(_) => "AddMember",
SpacePatchOp::RemoveMember(_) => "RemoveMember",
SpacePatchOp::UpdateMember { .. } => "UpdateMember",
SpacePatchOp::AddChannel(_) => "AddChannel",
SpacePatchOp::RemoveChannel(_) => "RemoveChannel",
SpacePatchOp::UpdateChannel { .. } => "UpdateChannel",
SpacePatchOp::AddCategory(_) => "AddCategory",
SpacePatchOp::RemoveCategory(_) => "RemoveCategory",
SpacePatchOp::UpdateCategory { .. } => "UpdateCategory",
_ => "Unknown",
}
}
#[cfg(all(feature = "testkit", feature = "test-helpers"))]
macro_rules! conformance_backend {
($ctx:ty, $doc:literal, |$account:ident| $caller:expr) => {
impl crate::testkit::ConformanceBackend for MemoryBackend<$ctx> {
#[doc = $doc]
fn caller(&self, $account: &Id) -> $ctx {
$caller
}
async fn add_account(&self, account_id: &Id, owner_user_id: &str) {
self.register_account(account_id);
self.set_owner_user_id_for_test(account_id, owner_user_id);
}
async fn seed(
&self,
account_id: &Id,
type_name: &'static str,
object: serde_json::Value,
) {
let id = object["id"]
.as_str()
.unwrap_or_else(|| {
panic!("seed: {type_name} object has no `id` string: {object}")
})
.to_owned();
self.insert_object_for_test(type_name, account_id.as_ref(), &id, object);
}
fn take_outbound_events(&self) -> Option<Vec<crate::OutboundEvent>> {
Some(self.take_outbound_events_for_test())
}
}
};
}
#[cfg(all(feature = "testkit", feature = "test-helpers"))]
conformance_backend!(
(),
"A caller without identity: every request acts as every account's owner.",
|_account_id| ()
);
#[cfg(all(feature = "testkit", feature = "test-helpers"))]
conformance_backend!(
Id,
"The account id: the owner's Space member id (draft-atwood-jmap-chat-00 §Terminology).",
|account_id| account_id.clone()
);
impl<C: MemoryCaller> ConditionalBackend for MemoryBackend<C> {
async fn begin_set(
&self,
_caller: &C,
request: SetScopeRequest<'_>,
) -> Result<Box<dyn SetScope>, BeginSetError<MemoryError>> {
Ok(self.inner.open(request, final_state_failures).await)
}
}
fn final_state_failures(before: &Inner, after: &Inner) -> Vec<DeferredFailure> {
let mut failures = Vec::new();
let scope = |e: &serde_json::Value| e.get("spaceId").filter(|v| !v.is_null()).cloned();
{
let (type_name, property) = ("CustomEmoji", "name");
for (account, objects) in after.objects.get(type_name).into_iter().flatten() {
let old = before.objects_ref(type_name, account);
for (id, obj) in objects {
let op = match old.and_then(|o| o.get(id)) {
None => SetOp::Create(id.clone()),
Some(prev) if prev != obj => SetOp::Update(id.clone()),
Some(_) => continue,
};
let clash = objects.iter().find(|(other, o)| {
*other != id && o.get(property) == obj.get(property) && scope(o) == scope(obj)
});
if let Some((existing, _)) = clash {
let error = match op {
SetOp::Create(_) => SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(existing.clone()),
_ => SetError::new(SetErrorType::InvalidProperties)
.with_properties([property]),
};
failures.push(DeferredFailure::new(op, error));
}
}
}
}
if let Some(max) = after
.limits_override
.unwrap_or_default()
.max_custom_emoji_per_space
{
for (account, objects) in after.objects.get("CustomEmoji").into_iter().flatten() {
let old = before.objects_ref("CustomEmoji", account);
for (id, obj) in objects {
let Some(space) = emoji_scope(obj) else {
continue;
};
let created = old.is_none_or(|o| !o.contains_key(id));
let reported = failures
.iter()
.any(|f| matches!(&f.op, SetOp::Create(c) if c == id));
if created
&& !reported
&& emoji_count_in_space(after, account, &space) > u64::from(max)
{
failures.push(DeferredFailure::new(
SetOp::Create(id.clone()),
SetError::new(SetErrorType::OverQuota)
.with_description(crate::emoji::TOO_MANY_EMOJI),
));
}
}
}
}
if after.push_subscriptions.len() > MAX_PUSH_SUBSCRIPTIONS {
for id in after.push_subscriptions.keys() {
if !before.push_subscriptions.contains_key(id) {
failures.push(DeferredFailure::new(
SetOp::Create(id.clone()),
SetError::new(SetErrorType::OverQuota).with_description(format!(
"at most {MAX_PUSH_SUBSCRIPTIONS} push subscriptions per user"
)),
));
}
}
}
failures
}
#[cfg(test)]
mod tests {
use super::*;
use jmap_chat_types::ChatContact;
use std::collections::HashSet;
#[tokio::test]
async fn get_changes_dedups_ids_across_window() {
let backend = MemoryBackend::<()>::default();
let id = |s: &str| Id::from(s);
{
let mut inner = backend.inner.lock_unscoped();
let log = inner.change_log_mut(ChatContact::TYPE_NAME, "acc1");
log.push(ChangeEntry {
new_state: 1,
created: vec![id("eph"), id("fresh")],
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 2,
created: vec![],
updated: vec![id("fresh"), id("old"), id("doomed")],
destroyed: vec![id("eph")],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 3,
created: vec![],
updated: vec![id("old")],
destroyed: vec![id("doomed"), id("gone")],
restored: vec![],
updated_props: None,
});
}
let changes = backend
.get_changes::<ChatContact>(
&(),
&id("acc1"),
jmap_server::ChangesParams::new(&State::from("0")),
)
.await
.expect("get_changes must succeed");
assert_eq!(changes.created, vec![id("fresh")]);
assert_eq!(changes.updated, vec![id("old")]);
assert_eq!(changes.destroyed, vec![id("doomed"), id("gone")]);
}
#[tokio::test]
async fn get_changes_lists_created_and_destroyed_message_in_destroyed() {
let backend = MemoryBackend::<()>::default();
let id = |s: &str| Id::from(s);
{
let mut inner = backend.inner.lock_unscoped();
let log = inner.change_log_mut(jmap_chat_types::Message::TYPE_NAME, "acc1");
log.push(ChangeEntry {
new_state: 1,
created: vec![id("burnt"), id("kept")],
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 2,
created: vec![],
updated: vec![id("burnt")],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 3,
created: vec![],
updated: vec![],
destroyed: vec![id("burnt")],
restored: vec![],
updated_props: None,
});
}
let changes = backend
.get_changes::<jmap_chat_types::Message>(
&(),
&id("acc1"),
jmap_server::ChangesParams::new(&State::from("0")),
)
.await
.expect("get_changes must succeed");
assert_eq!(changes.created, vec![id("kept")]);
assert!(changes.updated.is_empty());
assert_eq!(changes.destroyed, vec![id("burnt")]);
}
#[test]
fn compare_by_sort_orders_utc_dates_chronologically() {
use serde_json::json;
let comparators = [json!({ "property": "receivedAt", "isAscending": true })];
let mut msgs = [
json!({ "id": "c", "receivedAt": "2026-01-01T00:00:01.001Z" }),
json!({ "id": "b", "receivedAt": "2026-01-01T00:00:01Z" }),
json!({ "id": "a", "receivedAt": "2026-01-01T00:00:00.999Z" }),
json!({ "id": "d", "receivedAt": "2026-01-01T00:00:01.01Z" }),
];
msgs.sort_by(|x, y| compare_by_sort(x, y, &comparators));
let ids: Vec<&str> = msgs.iter().map(|m| m["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["a", "b", "c", "d"]);
let descending = [json!({ "property": "receivedAt", "isAscending": false })];
msgs.sort_by(|x, y| compare_by_sort(x, y, &descending));
let ids: Vec<&str> = msgs.iter().map(|m| m["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["d", "c", "b", "a"]);
}
#[tokio::test]
async fn generate_invite_code_is_csprng() {
let backend = MemoryBackend::<()>::default();
const N: usize = 256;
let mut codes: HashSet<String> = HashSet::with_capacity(N);
for _ in 0..N {
let code = backend
.generate_invite_code(&(), &Id::from("acct"))
.await
.expect("OS CSPRNG available in tests");
codes.insert(code);
}
assert_eq!(
codes.len(),
N,
"expected {N} distinct invite codes; found {} duplicates",
N - codes.len()
);
for c in &codes {
assert_eq!(
c.len(),
32,
"invite code must be 32 hex chars (16 random bytes); got len {} ({})",
c.len(),
c
);
assert!(
c.chars().all(|ch| ch.is_ascii_hexdigit()),
"invite code must be lowercase hex; got {c}"
);
}
let sorted: Vec<&String> = {
let mut v: Vec<&String> = codes.iter().collect();
v.sort();
v
};
let max_prefix: usize = sorted
.windows(2)
.map(|w| {
w[0].as_bytes()
.iter()
.zip(w[1].as_bytes())
.take_while(|(a, b)| a == b)
.count()
})
.max()
.unwrap_or(0);
assert!(
max_prefix < 10,
"max shared prefix across sorted codes is {max_prefix}; >=10 suggests timestamp-derived output (bd:JMAP-sc1b.93 regression)"
);
}
#[test]
fn base64url_unpadded_matches_rfc4648_vectors() {
for (input, expected) in [
("", ""),
("f", "Zg"),
("fo", "Zm8"),
("foo", "Zm9v"),
("foob", "Zm9vYg"),
("fooba", "Zm9vYmE"),
("foobar", "Zm9vYmFy"),
] {
assert_eq!(base64url_unpadded(input.as_bytes()), expected);
}
assert_eq!(base64url_unpadded(&[0xfb, 0xff, 0xbf]), "-_-_");
}
}
#[cfg(test)]
mod memory_error_tests {
use super::MemoryError;
#[test]
fn serde_error_display_omits_offending_value() {
let canary = "alice@example.com";
let e = serde_json::from_value::<u64>(serde_json::Value::String(canary.into()))
.expect_err("a string is not a u64");
assert!(
e.to_string().contains(canary),
"precondition: serde_json quotes the value"
);
let shown = MemoryError::serde("decode", &e).to_string();
assert!(!shown.contains(canary), "canary leaked: {shown}");
assert!(
shown.contains("decode") && shown.contains("Data"),
"{shown}"
);
}
}
#[cfg(test)]
mod clone_tests {
use super::MemoryBackend;
use jmap_types::Id;
#[test]
fn clone_shares_store() {
let a = MemoryBackend::<()>::default();
let clone = a.clone();
let fresh = MemoryBackend::<()>::default();
a.register_account(&Id::from("acc"));
let known = |b: &MemoryBackend<()>| b.inner.lock_unscoped().known_accounts.contains("acc");
assert!(known(&clone), "a clone sees the original's writes");
assert!(!known(&fresh), "a fresh backend does not");
}
}
#[cfg(test)]
mod fixture_helper_tests {
use super::*;
use serde_json::json;
#[tokio::test]
async fn with_account_registers_account() {
let acc = Id::from("acc1");
let backend = MemoryBackend::<()>::default().with_account(&acc);
assert!(backend.account_exists(&(), &acc).await.unwrap());
assert!(
!backend
.account_exists(&(), &Id::from("acc2"))
.await
.unwrap()
);
}
#[tokio::test]
async fn seed_object_is_readable_without_state_change() {
let acc = Id::from("acc1");
let backend = MemoryBackend::<()>::default();
let before = backend
.get_state::<jmap_chat_types::CustomEmoji>(&(), &acc)
.await
.unwrap();
backend.seed_object(
&acc,
jmap_chat_types::CustomEmoji::TYPE_NAME,
&Id::from("x1"),
json!({"id": "x1", "name": "party", "blobId": "b1", "createdBy": "u1", "createdAt": "2026-01-01T00:00:00Z"}),
);
assert!(backend.account_exists(&(), &acc).await.unwrap());
let (found, not_found) = backend
.get_objects::<jmap_chat_types::CustomEmoji>(&(), &acc, Some(&[Id::from("x1")]), None)
.await
.unwrap();
assert_eq!(found.len(), 1);
assert!(not_found.is_empty());
assert_eq!(
backend
.get_state::<jmap_chat_types::CustomEmoji>(&(), &acc)
.await
.unwrap(),
before
);
}
#[test]
#[should_panic(expected = "not one of the known")]
fn seed_object_rejects_unknown_type_name() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
"NoSuchType",
&Id::from("x1"),
json!({"id": "x1"}),
);
}
#[test]
#[should_panic(expected = "does not match the `id` argument")]
fn seed_object_rejects_id_mismatch() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
jmap_chat_types::CustomEmoji::TYPE_NAME,
&Id::from("x1"),
json!({"id": "other"}),
);
}
}
#[cfg(all(test, debug_assertions))]
mod empty_account_id_tests {
use super::{Id, MemoryBackend};
#[test]
#[should_panic(expected = "account_id must not be the empty string")]
fn register_account_rejects_empty_id() {
MemoryBackend::<()>::default().register_account(&Id::from(""));
}
}
#[cfg(test)]
mod max_changes_tests {
use super::*;
use jmap_chat_types::ChatContact as T;
const CALLER: () = ();
fn with_creates(states: &[&[&str]]) -> MemoryBackend<()> {
let backend = MemoryBackend::<()>::default();
let mut inner = backend.inner.lock_unscoped();
for ids in states {
let new_state = inner.bump_state(T::TYPE_NAME, "acc1");
inner
.change_log_mut(T::TYPE_NAME, "acc1")
.push(ChangeEntry {
new_state,
created: ids.iter().map(|s| Id::from(*s)).collect(),
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
drop(inner);
backend
}
#[tokio::test]
async fn over_max_changes_pages_through_intermediate_state() {
let backend = with_creates(&[&["a"], &["b"], &["c"]]);
let first = changes(&backend, "0", 2).await.expect("first page");
assert_eq!(sorted(first.created), [Id::from("a"), Id::from("b")]);
assert!(first.has_more_changes);
assert_eq!(first.new_state.as_ref(), "2");
let rest = changes(&backend, "2", 2).await.expect("second page");
assert_eq!(rest.created, [Id::from("c")]);
assert!(!rest.has_more_changes);
assert_eq!(rest.new_state.as_ref(), "3");
}
#[tokio::test]
async fn one_state_over_max_changes_cannot_calculate() {
let backend = with_creates(&[&["a", "b", "c"]]);
assert!(matches!(
changes(&backend, "0", 2).await,
Err(BackendChangesError::TooManyChanges { limit: 2 })
));
}
fn sorted(mut ids: Vec<Id>) -> Vec<Id> {
ids.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
ids
}
async fn changes(
backend: &MemoryBackend<()>,
since: &str,
max: u64,
) -> Result<ChangesResult, BackendChangesError<<MemoryBackend<()> as JmapAccounts>::Error>>
{
backend
.get_changes::<T>(
&CALLER,
&Id::from("acc1"),
jmap_server::ChangesParams::new(&State::from(since)).max_changes(Some(max)),
)
.await
}
}
#[cfg(test)]
mod emoji_cap_tests {
use super::*;
fn emoji(name: &str, space: &str) -> serde_json::Value {
serde_json::json!({ "name": name, "blobId": "b", "spaceId": space })
}
#[test]
fn final_state_over_the_cap_fails_only_the_creates() {
let mut before = Inner {
limits_override: Some(ChatLimits::default().with_max_custom_emoji_per_space(Some(1))),
..Inner::default()
};
before
.objects_mut("CustomEmoji", "acc1")
.insert(Id::from("old"), emoji("old", "s1"));
let mut after = before.clone();
after
.objects_mut("CustomEmoji", "acc1")
.insert(Id::from("new"), emoji("new", "s1"));
after
.objects_mut("CustomEmoji", "acc1")
.insert(Id::from("elsewhere"), emoji("new", "s2"));
let failures = final_state_failures(&before, &after);
assert_eq!(failures.len(), 1, "{failures:?}");
assert_eq!(failures[0].op, SetOp::Create(Id::from("new")));
assert_eq!(failures[0].error.error_type, SetErrorType::OverQuota);
after
.objects_mut("CustomEmoji", "acc1")
.remove(&Id::from("old"));
assert!(final_state_failures(&before, &after).is_empty());
}
}