#![allow(async_fn_in_trait)]
#![deny(clippy::await_holding_lock)]
use std::collections::{HashMap, HashSet};
use std::sync::{Arc, Mutex};
use crate::{
AddedItem, BackendChangesError, BackendSetError, ChangesResult, ChatBackend, ChatLimits,
EmojiSetOp, GetObject, JmapBackend, JmapObject, OpResult, QueryChangesResult, QueryObject,
QueryResult, SetError, SetErrorType, SetObject, SlowModeError, SpacePatchOp,
};
use jmap_server::{json_merge_patch, now_utc_string, resolve_query_offset, MergePatchError};
use jmap_types::{Id, State};
#[derive(Clone, Debug)]
struct ChangeEntry {
new_state: u64,
created: Vec<Id>,
updated: Vec<Id>,
destroyed: Vec<Id>,
}
#[derive(Default)]
struct Inner {
objects: HashMap<(&'static str, String), HashMap<Id, serde_json::Value>>,
states: HashMap<(&'static str, String), u64>,
change_log: HashMap<(&'static str, String), Vec<ChangeEntry>>,
known_accounts: HashSet<String>,
limits_override: Option<ChatLimits>,
retains_edit_history: bool,
protect_last_admin: bool,
}
impl Inner {
fn current_state(&self, type_name: &'static str, account_id: &str) -> u64 {
self.states
.get(&(type_name, account_id.to_owned()))
.copied()
.unwrap_or(0)
}
fn bump_state(&mut self, type_name: &'static str, account_id: &str) -> u64 {
let entry = self
.states
.entry((type_name, 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.known_accounts.insert(account_id.to_owned());
self.objects
.entry((type_name, account_id.to_owned()))
.or_default()
}
fn objects_ref(
&self,
type_name: &'static str,
account_id: &str,
) -> Option<&HashMap<Id, serde_json::Value>> {
self.objects.get(&(type_name, account_id.to_owned()))
}
fn change_log_mut(
&mut self,
type_name: &'static str,
account_id: &str,
) -> &mut Vec<ChangeEntry> {
self.change_log
.entry((type_name, account_id.to_owned()))
.or_default()
}
}
#[derive(Clone, Default)]
pub struct MemoryBackend {
inner: Arc<Mutex<Inner>>,
}
impl MemoryBackend {
pub fn new() -> Self {
Self::default()
}
#[doc(hidden)]
pub fn register_account(&self, account_id: &Id) {
let mut inner = self.inner.lock().unwrap();
inner.known_accounts.insert(account_id.as_ref().to_owned());
}
fn demo_next_id(inner: &mut Inner, type_name: &'static str, account_id: &str) -> Id {
#[cfg(feature = "realistic-demo-ids")]
{
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::OnceLock;
use std::time::{SystemTime, UNIX_EPOCH};
let _ = inner;
let _ = type_name;
let _ = account_id;
static COUNTER: AtomicU64 = AtomicU64::new(0);
static BASE: OnceLock<u64> = OnceLock::new();
let base = *BASE.get_or_init(|| {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.ok()
.and_then(|d| u64::try_from(d.as_nanos()).ok())
.unwrap_or(1_000_000_000)
});
let n = base.wrapping_add(COUNTER.fetch_add(1, Ordering::Relaxed));
Id::from(format!("{n:016x}"))
}
#[cfg(not(feature = "realistic-demo-ids"))]
{
let n = inner
.objects_ref(type_name, account_id)
.map_or(0, |m| m.len());
let new_id = Id::from(format!("{}{:016x}", type_name.to_ascii_lowercase(), n + 1));
debug_assert!(
!inner
.objects_ref(type_name, account_id)
.is_some_and(|m| m.contains_key(&new_id)),
"MemoryBackend demo_next_id collision: deterministic mode uses a len()-based \
counter that cannot survive deletes. This is the demo impl — production \
backends must use ULIDs."
);
new_id
}
}
#[doc(hidden)]
pub fn set_retains_edit_history_for_test(&self, retain: bool) {
let mut inner = self.inner.lock().unwrap();
inner.retains_edit_history = retain;
}
#[doc(hidden)]
pub fn set_protect_last_admin_for_test(&self, value: bool) {
let mut inner = self.inner.lock().unwrap();
inner.protect_last_admin = value;
}
#[doc(hidden)]
#[allow(clippy::result_large_err)]
pub fn apply_space_patch_with_caller_id(
&self,
caller_id: Option<&Id>,
account_id: &Id,
space_id: &Id,
ops: Vec<SpacePatchOp>,
) -> Result<Vec<OpResult>, BackendSetError<MemoryError>> {
let mut inner = self.inner.lock().unwrap();
apply_space_patch_impl(&mut inner, caller_id, account_id, space_id, ops)
}
#[doc(hidden)]
#[allow(clippy::result_large_err)]
pub fn apply_space_metadata_patch_with_caller_id(
&self,
caller_id: Option<&Id>,
account_id: &Id,
space_id: &Id,
patch: jmap_chat_types::SpaceMetadataPatch,
) -> Result<Option<jmap_chat_types::Space>, BackendSetError<MemoryError>> {
let patch_map = space_metadata_patch_to_map(patch);
let mut inner = self.inner.lock().unwrap();
apply_space_metadata_patch_impl(&mut inner, caller_id, account_id, space_id, patch_map)
}
#[doc(hidden)]
pub fn set_limits_for_test(&self, limits: Option<ChatLimits>) {
let mut inner = self.inner.lock().unwrap();
inner.limits_override = limits;
}
#[doc(hidden)]
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().unwrap();
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().unwrap();
for ((type_name, _account), map) in &inner.objects {
if *type_name != "Space" {
continue;
}
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().unwrap();
for ((type_name, _account), map) in &inner.objects {
if *type_name != "Chat" {
continue;
}
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
}
}
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 JmapBackend for MemoryBackend {
type Error = MemoryError;
type CallerCtx = ();
async fn account_exists(&self, _caller: &(), account_id: &Id) -> Result<bool, Self::Error> {
let inner = self.inner.lock().unwrap();
Ok(inner.known_accounts.contains(account_id.as_ref()))
}
async fn get_objects<O: GetObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
ids: Option<&[Id]>,
_properties: Option<&[String]>,
) -> Result<(Vec<O>, Vec<Id>), Self::Error> {
let inner = self.inner.lock().unwrap();
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::new(format!(
"deserialize {}: {e}",
O::TYPE_NAME
)))
}
}
}
}
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::new(format!(
"deserialize {}: {e}",
O::TYPE_NAME
)))
}
},
None => not_found.push(id.clone()),
}
}
Ok((found, not_found))
}
}
}
async fn get_state<O: JmapObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
) -> Result<State, Self::Error> {
let inner = self.inner.lock().unwrap();
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: &(),
account_id: &Id,
since_state: &State,
max_changes: Option<u64>,
) -> Result<ChangesResult, BackendChangesError<Self::Error>> {
let inner = self.inner.lock().unwrap();
let since_n: u64 = since_state
.as_ref()
.parse()
.map_err(|_| BackendChangesError::CannotCalculate)?;
let log = inner
.change_log
.get(&(O::TYPE_NAME, account_id.as_ref().to_owned()))
.map(Vec::as_slice)
.unwrap_or(&[]);
let 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());
if let Some(max) = max_changes {
if relevant.len() as u64 > max {
return Err(BackendChangesError::TooManyChanges { limit: max });
}
}
let mut created: Vec<Id> = Vec::new();
let mut updated: Vec<Id> = Vec::new();
let mut destroyed: Vec<Id> = Vec::new();
for entry in &relevant {
for id in &entry.created {
if !destroyed.contains(id) && !created.contains(id) {
created.push(id.clone());
}
}
for id in &entry.updated {
if !destroyed.contains(id) && !created.contains(id) && !updated.contains(id) {
updated.push(id.clone());
}
}
for id in &entry.destroyed {
created.retain(|c| c != id);
updated.retain(|u| u != id);
if !destroyed.contains(id) {
destroyed.push(id.clone());
}
}
}
Ok(ChangesResult::new(
created,
updated,
destroyed,
false,
State::from(current_state.to_string()),
))
}
async fn query_objects<O: QueryObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
_filter: Option<&O::Filter>,
_sort: Option<&[O::Comparator]>,
limit: Option<u64>,
position: i64,
) -> Result<QueryResult, Self::Error> {
let inner = self.inner.lock().unwrap();
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();
keys.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
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_offset(position, ids.len());
ids = ids[start..]
.iter()
.take(limit.map_or(usize::MAX, |n| n.min(usize::MAX as u64) as usize))
.cloned()
.collect();
Ok(QueryResult::new(
ids,
start as u64,
Some(total),
query_state,
true,
))
}
async fn query_changes<O: QueryObject + Send + Sync>(
&self,
caller: &(),
account_id: &Id,
since_query_state: &State,
_filter: Option<&O::Filter>,
_sort: Option<&[O::Comparator]>,
max_changes: Option<u64>,
_up_to_id: Option<&Id>,
_collapse_threads: bool,
) -> Result<QueryChangesResult, BackendChangesError<Self::Error>> {
let changes = self
.get_changes::<O>(caller, account_id, since_query_state, max_changes)
.await?;
let inner = self.inner.lock().unwrap();
let new_query_state = State::from(
inner
.current_state(O::TYPE_NAME, account_id.as_ref())
.to_string(),
);
let current_ids: Vec<Id> = inner
.objects_ref(O::TYPE_NAME, account_id.as_ref())
.map(|m| {
let mut keys: Vec<Id> = m.keys().cloned().collect();
keys.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
keys
})
.unwrap_or_default();
let removed: Vec<Id> = changes.destroyed;
let added: Vec<AddedItem> = changes
.created
.iter()
.filter_map(|id| {
current_ids
.iter()
.position(|cur| cur == id)
.map(|idx| AddedItem::new(id.clone(), idx as u64))
})
.collect();
Ok(QueryChangesResult::new(
since_query_state.clone(),
new_query_state,
Some(current_ids.len() as u64),
removed,
added,
))
}
}
impl ChatBackend for MemoryBackend {
async fn create_object<O: SetObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
_create_id: &str,
obj: O,
) -> Result<(Id, O), BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().unwrap();
let server_id = Self::demo_next_id(&mut inner, O::TYPE_NAME, account_id.as_ref());
let mut val = serde_json::to_value(&obj)
.map_err(|e| BackendSetError::Other(MemoryError::new(format!("serialize: {e}"))))?;
val["id"] = serde_json::Value::String(server_id.as_ref().to_owned());
let stored_obj: O = O::deserialize(&val).map_err(|e| {
BackendSetError::Other(MemoryError::new(format!("deserialize after create: {e}")))
})?;
inner.known_accounts.insert(account_id.as_ref().to_owned());
let new_state = inner.bump_state(O::TYPE_NAME, account_id.as_ref());
inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.insert(server_id.clone(), val);
inner
.change_log_mut(O::TYPE_NAME, account_id.as_ref())
.push(ChangeEntry {
new_state,
created: vec![server_id.clone()],
updated: vec![],
destroyed: vec![],
});
Ok((server_id, stored_obj))
}
async fn update_object<O: SetObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
id: &Id,
patch: O::Patch,
) -> Result<Option<O>, BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().unwrap();
let existing = inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.get(id)
.cloned();
let mut current = match existing {
Some(v) => v,
None => {
return Err(BackendSetError::SetError(SetError::new(
SetErrorType::NotFound,
)))
}
};
let patch_val = serde_json::to_value(&patch).map_err(|e| {
BackendSetError::Other(MemoryError::new(format!("serialize patch: {e}")))
})?;
if let Err(MergePatchError::DepthExceeded) = json_merge_patch(&mut current, patch_val) {
return Err(BackendSetError::SetError(
SetError::new(SetErrorType::InvalidPatch)
.with_description("patch nesting exceeds server limit"),
));
}
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![],
});
Ok(None)
}
async fn destroy_object<O: SetObject + Send + Sync>(
&self,
_caller: &(),
account_id: &Id,
id: &Id,
) -> Result<(), BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().unwrap();
let removed = inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.remove(id);
match removed {
Some(_) => {
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()],
});
Ok(())
}
None => Err(BackendSetError::SetError(SetError::new(
SetErrorType::NotFound,
))),
}
}
fn supports_type<O: JmapObject>(&self) -> bool {
true
}
fn generate_invite_code(&self) -> String {
let mut bytes = [0u8; 16];
getrandom::fill(&mut bytes)
.expect("OS CSPRNG must be available for invite-code generation");
let mut out = String::with_capacity(bytes.len() * 2);
for byte in bytes {
use std::fmt::Write as _;
let _ = write!(out, "{byte:02x}");
}
out
}
fn limits(&self, _caller: &(), _account_id: &Id) -> ChatLimits {
let inner = self.inner.lock().unwrap();
inner.limits_override.unwrap_or_default()
}
fn protect_last_admin(&self, _caller: &(), _account_id: &Id) -> bool {
let inner = self.inner.lock().unwrap();
inner.protect_last_admin
}
async fn apply_space_patch(
&self,
caller: &(),
account_id: &Id,
space_id: &Id,
ops: Vec<SpacePatchOp>,
) -> Result<Vec<OpResult>, BackendSetError<Self::Error>> {
let caller_id_owned = <Self as JmapBackend>::principal_id(caller).cloned();
let mut inner = self.inner.lock().unwrap();
apply_space_patch_impl(
&mut inner,
caller_id_owned.as_ref(),
account_id,
space_id,
ops,
)
}
async fn apply_space_metadata_patch(
&self,
caller: &(),
account_id: &Id,
space_id: &Id,
patch: jmap_chat_types::SpaceMetadataPatch,
) -> Result<Option<jmap_chat_types::Space>, BackendSetError<Self::Error>> {
let caller_id_owned = <Self as JmapBackend>::principal_id(caller).cloned();
let patch_map = space_metadata_patch_to_map(patch);
let mut inner = self.inner.lock().unwrap();
apply_space_metadata_patch_impl(
&mut inner,
caller_id_owned.as_ref(),
account_id,
space_id,
patch_map,
)
}
fn retains_edit_history(&self) -> bool {
let inner = self.inner.lock().unwrap();
inner.retains_edit_history
}
async fn is_contact_blocked(
&self,
_caller: &(),
account_id: &Id,
contact_id: &Id,
) -> Result<bool, Self::Error> {
let inner = self.inner.lock().unwrap();
let blocked = inner
.objects_ref("ChatContact", account_id.as_ref())
.and_then(|map| map.get(contact_id))
.and_then(|val| val.get("blocked"))
.and_then(|v| v.as_bool())
.unwrap_or(false);
Ok(blocked)
}
async fn may_set_custom_emoji(
&self,
_caller: &(),
_account_id: &Id,
_target_space_id: Option<&Id>,
_op: EmojiSetOp,
) -> Result<Result<(), SetError>, Self::Error> {
Ok(Ok(()))
}
async fn slow_mode_check(
&self,
_caller: &(),
_account_id: &Id,
_chat_id: &Id,
) -> Result<(), SlowModeError> {
Ok(())
}
async fn expire_message(
&self,
_caller: &(),
account_id: &Id,
message_id: &Id,
) -> Result<(), Self::Error> {
let mut inner = self.inner.lock().unwrap();
let removed = inner
.objects_mut("Message", account_id.as_ref())
.remove(message_id);
if removed.is_some() {
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()],
});
}
Ok(())
}
}
#[allow(clippy::result_large_err)]
fn apply_space_patch_impl(
inner: &mut Inner,
caller_id: Option<&Id>,
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(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(SetError::new(SetErrorType::NotFound)))?;
if let Err(e) = validate_space_patch_ops(&space_snapshot, caller_id, &ops, protect_last_admin) {
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(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();
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 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(SetError::new(SetErrorType::Forbidden).with_description(stub_description(&op)))
}
};
results.push(OpResult { op_index, outcome });
}
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![],
});
}
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,
});
}
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,
});
}
Ok(results)
}
fn space_metadata_patch_to_map(
patch: jmap_chat_types::SpaceMetadataPatch,
) -> serde_json::Map<String, serde_json::Value> {
match serde_json::to_value(&patch).expect("derive(Serialize) on plain data is infallible") {
serde_json::Value::Object(map) => map,
_ => serde_json::Map::new(),
}
}
#[allow(clippy::result_large_err)]
fn apply_space_metadata_patch_impl(
inner: &mut Inner,
caller_id: Option<&Id>,
account_id: &Id,
space_id: &Id,
patch_map: serde_json::Map<String, serde_json::Value>,
) -> Result<Option<jmap_chat_types::Space>, BackendSetError<MemoryError>> {
use crate::permissions::MANAGE_SPACE;
let space_val = inner
.objects_ref("Space", account_id.as_ref())
.and_then(|m| m.get(space_id))
.cloned()
.ok_or_else(|| BackendSetError::SetError(SetError::new(SetErrorType::NotFound)))?;
if let Some(caller_id) = caller_id {
let caller_perms = caller_effective_permissions(&space_val, caller_id).unwrap_or_default();
if !caller_perms.contains(MANAGE_SPACE) {
return Err(BackendSetError::SetError(
SetError::new(SetErrorType::Forbidden).with_description(format!(
"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(
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![],
});
Ok(None)
}
#[allow(clippy::result_large_err)]
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>, SetError> {
use jmap_chat_types::space::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(mut cat) => {
let new_id = MemoryBackend::demo_next_id(inner, "Category", account_id);
cat.id = new_id.clone();
for ch_id in &cat.channel_ids {
if !channel_belongs_to_space(inner, account_id, ch_id, space_id) {
return Err(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")
})?;
cats.push(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;
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(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(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(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")
})?;
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)
}
#[allow(clippy::result_large_err)]
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>, SetError> {
use jmap_chat_types::space_set::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(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 = MemoryBackend::demo_next_id(inner, "Chat", account_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))
}
#[allow(clippy::result_large_err)]
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>, 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(
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)
}
#[allow(clippy::result_large_err)]
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>, SetError> {
use jmap_chat_types::clearable::Clearable;
use jmap_chat_types::space_set::ChannelPatch;
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(
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(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(SetError::new(SetErrorType::NotFound));
};
let serde_json::Value::Object(obj) = chat_val else {
return Err(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)
}
#[allow(clippy::result_large_err)]
fn apply_add_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, SetError> {
let role = match op {
SpacePatchOp::AddRole(r) => r,
_ => unreachable!("apply_add_role called with non-AddRole variant"),
};
let new_id = MemoryBackend::demo_next_id(inner, "Role", account_id);
let mut role = role;
role.id = new_id.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))?;
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(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(Some(new_id))
}
#[allow(clippy::result_large_err)]
fn apply_remove_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, 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(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;
Ok(None)
}
#[allow(clippy::result_large_err)]
fn apply_update_role(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, SetError> {
use jmap_chat_types::clearable::Clearable;
use jmap_chat_types::space::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(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)
}
#[allow(clippy::result_large_err)]
fn apply_add_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, 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(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(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)
}
#[allow(clippy::result_large_err)]
fn apply_remove_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, 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(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)
}
#[allow(clippy::result_large_err)]
fn apply_update_member(
inner: &mut Inner,
account_id: &str,
space_id: &Id,
op: SpacePatchOp,
space_mutated: &mut bool,
) -> Result<Option<Id>, SetError> {
use jmap_chat_types::clearable::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(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(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))
}
#[allow(clippy::result_large_err)]
fn validate_space_patch_ops(
space_val: &serde_json::Value,
caller_id: Option<&Id>,
ops: &[SpacePatchOp],
protect_last_admin: bool,
) -> Result<(), SetError> {
use crate::permissions::{
required_permissions_for_op, RequiredPermissions, MANAGE_MEMBERS, MANAGE_SPACE,
};
if let Some(caller_id) = caller_id {
let caller_perms = caller_effective_permissions(space_val, caller_id).unwrap_or_default();
let caller_highest = caller_highest_position(space_val, caller_id).unwrap_or(0);
for op in ops {
let required = match required_permissions_for_op(op) {
RequiredPermissions::Known(slice) => slice,
RequiredPermissions::UnknownOp => {
return Err(
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)
)),
);
}
};
for req in required {
if !caller_perms.contains(*req) {
return Err(
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(hierarchy_error(role.position, caller_highest, "AddRole"));
}
SpacePatchOp::RemoveRole(target_id) => {
if let Some(pos) = role_position(space_val, target_id.as_ref()) {
if pos >= caller_highest {
return Err(hierarchy_error(pos, caller_highest, "RemoveRole"));
}
}
}
SpacePatchOp::UpdateRole { id, patch } => {
if let Some(pos) = role_position(space_val, id.as_ref()) {
if pos >= caller_highest {
return Err(hierarchy_error(pos, caller_highest, "UpdateRole"));
}
}
if let Some(new_pos) = patch.position {
if new_pos >= caller_highest {
return Err(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()) {
if pos >= caller_highest {
return Err(hierarchy_error(pos, caller_highest, "AddMember"));
}
}
}
}
SpacePatchOp::UpdateMember { patch, .. } => {
if let Some(role_ids) = &patch.role_ids {
for rid in role_ids {
if let Some(pos) = role_position(space_val, rid.as_ref()) {
if pos >= caller_highest {
return Err(hierarchy_error(
pos,
caller_highest,
"UpdateMember",
));
}
}
}
}
}
SpacePatchOp::RemoveMember(_) => {
}
_ => {}
}
}
}
if protect_last_admin {
let mut to_remove: HashSet<String> = HashSet::new();
for op in ops {
if let SpacePatchOp::RemoveMember(id) = op {
to_remove.insert(id.as_ref().to_owned());
}
}
if !to_remove.is_empty() {
let members = space_val
.get("members")
.and_then(|v| v.as_array())
.map(Vec::as_slice)
.unwrap_or(&[]);
let mut admin_remaining: usize = 0;
for m in members {
let Some(mid) = m.get("id").and_then(|v| v.as_str()) else {
continue;
};
if to_remove.contains(mid) {
continue;
}
let perms = member_effective_permissions(space_val, mid).unwrap_or_default();
if perms.contains(MANAGE_MEMBERS) || perms.contains(MANAGE_SPACE) {
admin_remaining += 1;
break; }
}
if admin_remaining == 0 {
return Err(SetError::new(SetErrorType::Forbidden).with_description(
"removing these members would leave the Space with no \
`manage_members`/`manage_space` holder (last-admin protection)",
));
}
}
}
Ok(())
}
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 lines 1096, 1102)"
))
}
fn caller_effective_permissions(
space_val: &serde_json::Value,
caller_id: &Id,
) -> Option<HashSet<String>> {
member_effective_permissions(space_val, caller_id.as_ref())
}
fn member_effective_permissions(
space_val: &serde_json::Value,
member_id: &str,
) -> Option<HashSet<String>> {
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: HashSet<String> = HashSet::new();
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()) {
for p in role_perms {
if let Some(s) = p.as_str() {
perms.insert(s.to_owned());
}
}
}
}
}
Some(perms)
}
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 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 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 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 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(test)]
mod tests {
use super::*;
use crate::ChatBackend;
use std::collections::HashSet;
#[test]
fn generate_invite_code_is_csprng() {
let backend = MemoryBackend::new();
const N: usize = 256;
let mut codes: HashSet<String> = HashSet::with_capacity(N);
for _ in 0..N {
codes.insert(backend.generate_invite_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)"
);
}
}