use std::collections::BTreeMap;
use jmap_chat_types::SPEC_PERMISSION_NAMES;
use jmap_chat_types::{
CategoryCreate, CategoryPatch, ChannelCreate, ChannelPatch, MemberPatch, RolePatch,
};
use jmap_chat_types::{
Chat, ChatKind, RoleCreate, Space, SpaceBan, SpaceInvite, SpaceMember, SpaceRole,
};
use jmap_chat_types::{SpaceComparator, SpaceFilter};
use jmap_types::{Id, JmapError, PatchObject, SetObject, UTCDate};
use serde_json::{Value, json};
use subtle::ConstantTimeEq;
use crate::helpers::check_read_only_patch;
use crate::helpers::{
PropType, check_metadata_entry, create_metadata, is_metadata_key, mistyped_create_props,
};
use crate::helpers::{
SetAccumulators, count_add_ops, default_sort, enforce_max_objects_in_get,
enforce_max_objects_in_set, extract_account_id, finalize_set_response, iso8601_before,
not_found_json, now_utc_string, optional_arg, reject_unsupported_sort, serialize_value,
};
use crate::helpers::{resolve_entry_refs, resolve_ref, resolve_refs};
use crate::{ChatBackend, ChatLimits, InviteJoinRefusal, SpacePatchOp};
use jmap_server::{
HandlerOutput, MetadataProjection, QueryParams, backend_set_error_value, bool_arg, filter_arg,
is_client_updatable, query_anchor_args, reject_server_set, server_fail_from_backend,
server_fail_value_from_backend,
};
use jmap_server::{SetError, SetErrorType};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum StructuralKey {
AddRoles,
UpdateRoles,
RemoveRoles,
AddMembers,
UpdateMembers,
RemoveMembers,
AddChannels,
UpdateChannels,
RemoveChannels,
AddCategories,
UpdateCategories,
RemoveCategories,
}
impl StructuralKey {
fn from_wire(key: &str) -> Option<Self> {
Some(match key {
"addRoles" => Self::AddRoles,
"updateRoles" => Self::UpdateRoles,
"removeRoles" => Self::RemoveRoles,
"addMembers" => Self::AddMembers,
"updateMembers" => Self::UpdateMembers,
"removeMembers" => Self::RemoveMembers,
"addChannels" => Self::AddChannels,
"updateChannels" => Self::UpdateChannels,
"removeChannels" => Self::RemoveChannels,
"addCategories" => Self::AddCategories,
"updateCategories" => Self::UpdateCategories,
"removeCategories" => Self::RemoveCategories,
_ => return None,
})
}
fn wire_name(self) -> &'static str {
match self {
Self::AddRoles => "addRoles",
Self::UpdateRoles => "updateRoles",
Self::RemoveRoles => "removeRoles",
Self::AddMembers => "addMembers",
Self::UpdateMembers => "updateMembers",
Self::RemoveMembers => "removeMembers",
Self::AddChannels => "addChannels",
Self::UpdateChannels => "updateChannels",
Self::RemoveChannels => "removeChannels",
Self::AddCategories => "addCategories",
Self::UpdateCategories => "updateCategories",
Self::RemoveCategories => "removeCategories",
}
}
}
fn parse_structural_entries(key: StructuralKey, value: Value) -> Result<Vec<SpacePatchOp>, String> {
let canonical = key.wire_name();
let arr = match value {
Value::Array(a) => a,
other => {
return Err(format!(
"{canonical} must be a JSON array, got {}",
jmap_server::json_type_name(&other)
));
}
};
let mut out = Vec::with_capacity(arr.len());
for (idx, entry) in arr.into_iter().enumerate() {
let op = match key {
StructuralKey::AddRoles => {
SpacePatchOp::AddRole(parse_entry::<RoleCreate>(canonical, idx, entry)?)
}
StructuralKey::RemoveRoles => {
SpacePatchOp::RemoveRole(parse_id_entry(canonical, idx, entry)?)
}
StructuralKey::UpdateRoles => {
let (id, patch) = parse_update_entry::<RolePatch>(canonical, idx, entry)?;
SpacePatchOp::UpdateRole { id, patch }
}
StructuralKey::AddMembers => {
let (user_id, role_ids) = parse_add_member_entry(canonical, idx, entry)?;
SpacePatchOp::AddMember(jmap_chat_types::MemberCreate::new(user_id, role_ids))
}
StructuralKey::RemoveMembers => {
SpacePatchOp::RemoveMember(parse_id_entry(canonical, idx, entry)?)
}
StructuralKey::UpdateMembers => {
let (id, patch) = parse_update_entry::<MemberPatch>(canonical, idx, entry)?;
SpacePatchOp::UpdateMember { user_id: id, patch }
}
StructuralKey::AddChannels => {
SpacePatchOp::AddChannel(parse_entry::<ChannelCreate>(canonical, idx, entry)?)
}
StructuralKey::RemoveChannels => {
SpacePatchOp::RemoveChannel(parse_id_entry(canonical, idx, entry)?)
}
StructuralKey::UpdateChannels => {
let (id, patch) = parse_update_entry::<ChannelPatch>(canonical, idx, entry)?;
SpacePatchOp::UpdateChannel { id, patch }
}
StructuralKey::AddCategories => {
SpacePatchOp::AddCategory(parse_entry::<CategoryCreate>(canonical, idx, entry)?)
}
StructuralKey::RemoveCategories => {
SpacePatchOp::RemoveCategory(parse_id_entry(canonical, idx, entry)?)
}
StructuralKey::UpdateCategories => {
let (id, patch) = parse_update_entry::<CategoryPatch>(canonical, idx, entry)?;
SpacePatchOp::UpdateCategory { id, patch }
}
};
out.push(op);
}
Ok(out)
}
fn parse_entry<T: serde::de::DeserializeOwned>(
canonical: &'static str,
idx: usize,
entry: Value,
) -> Result<T, String> {
serde_json::from_value(entry)
.map_err(|e| format!("{canonical}[{idx}]: failed to parse entry: {e}"))
}
fn dedup_caller_members(members: Vec<Value>, caller_identity: &str) -> Vec<Value> {
let mut seen_ours = false;
members
.into_iter()
.filter(|m| {
if m.get("id").and_then(|v| v.as_str()) == Some(caller_identity) {
if seen_ours {
false
} else {
seen_ours = true;
true
}
} else {
true
}
})
.collect()
}
fn parse_id_entry(canonical: &'static str, idx: usize, entry: Value) -> Result<Id, String> {
match entry {
Value::String(s) => Id::new_validated(s).map_err(|e| format!("{canonical}[{idx}]: {e}")),
other => Err(format!(
"{canonical}[{idx}] must be a string Id, got {}",
jmap_server::json_type_name(&other)
)),
}
}
fn parse_update_entry<P: serde::de::DeserializeOwned>(
canonical: &'static str,
idx: usize,
entry: Value,
) -> Result<(Id, P), String> {
let mut obj = match entry {
Value::Object(o) => o,
other => {
return Err(format!(
"{canonical}[{idx}] must be a JSON object, got {}",
jmap_server::json_type_name(&other)
));
}
};
let id_val = obj
.remove("id")
.ok_or_else(|| format!("{canonical}[{idx}] missing required \"id\" property"))?;
let id = match id_val {
Value::String(s) => {
Id::new_validated(s).map_err(|e| format!("{canonical}[{idx}].id: {e}"))?
}
other => {
return Err(format!(
"{canonical}[{idx}].id must be a string, got {}",
jmap_server::json_type_name(&other)
));
}
};
let patch: P = serde_json::from_value(Value::Object(obj))
.map_err(|e| format!("{canonical}[{idx}]: failed to parse patch fields: {e}"))?;
Ok((id, patch))
}
fn parse_add_member_entry(
canonical: &'static str,
idx: usize,
entry: Value,
) -> Result<(Id, Vec<Id>), String> {
let mut obj = match entry {
Value::Object(o) => o,
other => {
return Err(format!(
"{canonical}[{idx}] must be a JSON object, got {}",
jmap_server::json_type_name(&other)
));
}
};
let id_val = obj
.remove("id")
.ok_or_else(|| format!("{canonical}[{idx}] missing required \"id\" property"))?;
let user_id = match id_val {
Value::String(s) => {
Id::new_validated(s).map_err(|e| format!("{canonical}[{idx}].id: {e}"))?
}
other => {
return Err(format!(
"{canonical}[{idx}].id must be a string, got {}",
jmap_server::json_type_name(&other)
));
}
};
let role_ids: Vec<Id> = match obj.remove("roleIds") {
None | Some(Value::Null) => Vec::new(),
Some(v) => serde_json::from_value(v)
.map_err(|e| format!("{canonical}[{idx}].roleIds must be a string array: {e}"))?,
};
if let Some(extra) = obj.keys().next() {
return Err(format!(
"{canonical}[{idx}] has unexpected property \"{extra}\""
));
}
Ok((user_id, role_ids))
}
pub async fn handle_space_get<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
enforce_max_objects_in_get(&args, backend.max_objects_in_get(caller, &account_id))?;
let ids: Option<Vec<Id>> = match args.remove("ids") {
None | Some(Value::Null) => None,
Some(v) => Some(
serde_json::from_value(v)
.map_err(|_| JmapError::invalid_arguments("ids must be an Id array"))?,
),
};
let properties: Option<Vec<String>> = match args.remove("properties") {
None | Some(Value::Null) => None,
Some(v) => Some(
serde_json::from_value(v)
.map_err(|_| JmapError::invalid_arguments("properties must be a string array"))?,
),
};
let projection = MetadataProjection::new(
properties.as_deref(),
true,
using,
backend.metadata_info::<Space>(caller, &account_id).as_ref(),
)?;
let ids_slice = ids.as_deref();
let (list, mut not_found) = backend
.get_objects::<Space>(caller, &account_id, ids_slice, properties.as_deref())
.await
.map_err(|e| server_fail_from_backend(&e))?;
let state = backend
.get_state::<Space>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let caller_member_id: &Id = &account_id;
let mut visible_list: Vec<&Space> = Vec::with_capacity(list.len());
for space in &list {
if non_member_non_previewable(space, caller_member_id) {
not_found.push(space.id.clone());
} else {
visible_list.push(space);
}
}
let list_json: Vec<Value> = visible_list
.iter()
.map(|space| {
project_space_for_caller(space, caller_member_id, properties.as_deref(), &projection)
})
.collect::<Result<Vec<_>, _>>()?;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"state": state.as_ref(),
"list": list_json,
"notFound": not_found_json(¬_found),
})))
}
fn non_member_non_previewable(space: &Space, caller_member_id: &Id) -> bool {
let is_member = space
.members
.iter()
.any(|m| m.id.as_ref() == caller_member_id.as_ref());
!is_member && !space.is_publicly_previewable
}
const NON_MEMBER_PREVIEWABLE_FIELDS: &[&str] = &[
"id",
"name",
"description",
"iconBlobId",
"memberCount",
"createdAt",
"isPublic",
"isPubliclyPreviewable",
"closedAt",
];
fn project_space_for_caller(
space: &Space,
caller_member_id: &Id,
properties: Option<&[String]>,
projection: &MetadataProjection,
) -> Result<Value, JmapError> {
let full = serialize_value(space)?;
let is_member = space
.members
.iter()
.any(|m| m.id.as_ref() == caller_member_id.as_ref());
let allowed_fields: Option<Vec<&str>> = if is_member {
None
} else if space.is_publicly_previewable {
Some(NON_MEMBER_PREVIEWABLE_FIELDS.to_vec())
} else {
None
};
let request_filter: Option<&[String]> = properties;
let metadata_source = allowed_fields.is_none().then(|| full.clone());
let mut out = match (allowed_fields, request_filter) {
(None, None) => full,
(None, Some(props)) => filter_object_fields(full, |k| props.iter().any(|p| p == k)),
(Some(cap), None) => filter_object_fields(full, |k| cap.contains(&k)),
(Some(cap), Some(props)) => {
filter_object_fields(full, |k| cap.contains(&k) && props.iter().any(|p| p == k))
}
};
if let Some(source) = &metadata_source {
projection.apply(source, &mut out);
}
Ok(out)
}
fn filter_object_fields<F: Fn(&str) -> bool>(value: Value, keep: F) -> Value {
match value {
Value::Object(map) => {
Value::Object(map.into_iter().filter(|(k, _)| keep(k.as_str())).collect())
}
other => other,
}
}
pub async fn handle_space_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<Space, B>(backend, caller, args, using).await
}
pub async fn handle_space_query<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::reject_metadata_filter_arg(
&args,
jmap_chat_types::SpaceFilterCondition::has_metadata_condition,
using,
)?;
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
let calculate_total: bool = bool_arg(&args, "calculateTotal", false);
let limit: Option<u64> = match args.remove("limit") {
None | Some(Value::Null) => None,
Some(v) => match v.as_u64() {
Some(n) => Some(n),
None => {
return Err(JmapError::invalid_arguments(format!(
"limit: expected a non-negative integer, got {}",
jmap_server::json_type_name(&v)
)));
}
},
};
let position: i64 = match args.remove("position") {
None | Some(Value::Null) => 0,
Some(v) => v.as_i64().ok_or_else(|| {
JmapError::invalid_arguments(format!(
"position: expected an integer, got {}",
jmap_server::json_type_name(&v)
))
})?,
};
let (anchor, anchor_offset) = query_anchor_args(&args)?;
default_sort(&mut args, json!([{ "property": "name" }]));
reject_unsupported_sort::<SpaceComparator>(args.get("sort"))?;
let filter: Option<SpaceFilter> = filter_arg(&mut args)?;
let sort: Option<Vec<SpaceComparator>> = optional_arg(&mut args, "sort", || {
JmapError::invalid_arguments("sort must be an array")
})?;
let result = backend
.query_objects::<Space>(
caller,
&account_id,
QueryParams::new()
.filter(filter.as_ref())
.sort(sort.as_deref())
.limit(limit)
.position(position)
.anchor(anchor.as_ref())
.anchor_offset(anchor_offset),
)
.await
.map_err(JmapError::from)?;
let mut resp = json!({
"accountId": account_id.as_ref(),
"queryState": result.query_state.as_ref(),
"canCalculateChanges": result.can_calculate_changes,
"position": result.position,
"ids": result.ids.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
});
if calculate_total && let Some(t) = result.total {
resp["total"] = json!(t);
}
Ok(HandlerOutput::new(resp))
}
pub async fn handle_space_query_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
mut args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::reject_metadata_filter_arg(
&args,
jmap_chat_types::SpaceFilterCondition::has_metadata_condition,
using,
)?;
if let Value::Object(map) = &mut args {
default_sort(map, json!([{ "property": "name" }]));
}
reject_unsupported_sort::<SpaceComparator>(args.get("sort"))?;
jmap_server::handle_query_changes::<Space, B>(backend, caller, args).await
}
async fn check_space_count_limits<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
space_id: &Id,
ops: &[SpacePatchOp],
limits: &ChatLimits,
) -> Result<Option<SetError>, JmapError> {
let (add_roles, add_members, add_channels, add_categories) = count_add_ops(ops);
if add_roles == 0 && add_members == 0 && add_channels == 0 && add_categories == 0 {
return Ok(None);
}
let (found, _not_found) = backend
.get_objects::<Space>(
caller,
account_id,
Some(std::slice::from_ref(space_id)),
None,
)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let Some(space) = found.into_iter().next() else {
return Ok(None);
};
let cur_roles = u32::try_from(space.roles.len()).unwrap_or(u32::MAX);
let cur_members = u32::try_from(space.members.len()).unwrap_or(u32::MAX);
let cur_categories = u32::try_from(space.categories.len()).unwrap_or(u32::MAX);
let cur_channels = u32::try_from(
space.uncategorized_channel_ids.len()
+ space
.categories
.iter()
.map(|c| c.channel_ids.len())
.sum::<usize>(),
)
.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
}
};
Ok([
(
"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)))
}
const BOOTSTRAP_ADMIN_ROLE_ID: &str = "admin";
const BOOTSTRAP_ADMIN_ROLE_POSITION: u64 = 9_007_199_254_740_991;
fn resolve_override_targets(
patch: &mut Value,
created_ids: &std::collections::BTreeMap<Id, Id>,
) -> Result<(), Box<jmap_server::SetError>> {
let Some(Value::Array(channels)) = patch.get_mut("updateChannels") else {
return Ok(());
};
for channel in channels {
let Some(Value::Array(overrides)) = channel.get_mut("permissionOverrides") else {
continue;
};
for entry in overrides {
if let Some(Value::String(raw)) = entry.get_mut("targetId") {
*raw = resolve_ref(raw, "updateChannels", created_ids)?
.as_ref()
.to_owned();
}
}
}
Ok(())
}
pub async fn handle_space_set<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
created_ids: &BTreeMap<Id, Id>,
mut args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::resolve_blob_refs(&mut args, &["iconBlobId"], created_ids);
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
enforce_max_objects_in_set(&args, backend.max_objects_in_set(caller, &account_id))?;
let old_state = backend
.get_state::<Space>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(|v| v.as_str())
&& if_in_state != old_state.as_ref()
{
return Err(JmapError::state_mismatch());
}
let mut created = serde_json::Map::new();
let mut not_created = serde_json::Map::new();
let mut updated = serde_json::Map::new();
let mut not_updated = serde_json::Map::new();
let mut destroyed_list: Vec<Value> = Vec::new();
let mut not_destroyed = serde_json::Map::new();
let mut mutated = false;
let extension_props: Vec<&str> = backend
.space_extension_properties(caller, &account_id)
.iter()
.copied()
.filter(|&key| {
!(Space::SERVER_SET.contains(&key)
|| Space::CLIENT_SETTABLE.contains(&key)
|| StructuralKey::from_wire(key).is_some())
})
.collect();
if let Some(create_map) = args.get("create").and_then(|v| v.as_object()) {
for (create_id, obj_val) in create_map {
if let Some(err) = obj_val.as_object().and_then(reject_server_set::<Space>) {
not_created.insert(create_id.clone(), serde_json::Value::from(&err));
continue;
}
let unknown_keys: Vec<&str> = obj_val
.as_object()
.into_iter()
.flat_map(|m| m.keys())
.map(String::as_str)
.filter(|key| {
!(Space::CLIENT_SETTABLE.contains(key) || extension_props.contains(key))
})
.collect();
if !unknown_keys.is_empty() {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": unknown_keys }),
);
continue;
}
if let Some(Err(err)) = obj_val
.as_object()
.map(|o| check_metadata_entry(o, true, using))
{
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
let (metadata, private_metadata) = match create_metadata(obj_val) {
Ok(maps) => maps,
Err(err) => {
not_created.insert(create_id.clone(), err);
continue;
}
};
if let Some(err) = mistyped_create_props(
obj_val,
&[
("description", PropType::Str),
("iconBlobId", PropType::Str),
("isPublic", PropType::Bool),
("isPubliclyPreviewable", PropType::Bool),
],
) {
not_created.insert(create_id.clone(), err);
continue;
}
let icon_blob_id = match obj_val.get("iconBlobId").and_then(|v| v.as_str()) {
None => None,
Some(raw) => match jmap_server::parse_wire_id(raw, "iconBlobId") {
Ok(id) => Some(id),
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
},
};
let name = match obj_val.get("name").and_then(|v| v.as_str()) {
Some(s) if !s.is_empty() => s.to_owned(),
_ => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["name"] }),
);
continue;
}
};
if name.len() > 256 {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["name"] }),
);
continue;
}
let is_public = obj_val
.get("isPublic")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let is_publicly_previewable = obj_val
.get("isPubliclyPreviewable")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let now_str = now_utc_string();
let now: UTCDate = UTCDate::from(now_str.as_ref());
let admin_role: SpaceRole = serde_json::from_value(json!({
"id": BOOTSTRAP_ADMIN_ROLE_ID,
"name": "Admin",
"permissions": SPEC_PERMISSION_NAMES,
"position": BOOTSTRAP_ADMIN_ROLE_POSITION,
}))
.expect("bootstrap role literal matches SpaceRole");
let owner: SpaceMember = serde_json::from_value(json!({
"id": account_id,
"roleIds": [BOOTSTRAP_ADMIN_ROLE_ID],
"joinedAt": now_str,
}))
.expect("bootstrap member literal matches SpaceMember");
let build = |id: &Id| {
let mut space = Space::new(
id.clone(),
name,
vec![admin_role],
vec![owner],
vec![],
vec![],
now,
is_public,
is_publicly_previewable,
1,
);
if let Some(desc) = obj_val.get("description").and_then(|v| v.as_str()) {
space.description = Some(desc.to_owned());
}
space.icon_blob_id = icon_blob_id;
space.metadata = metadata;
space.private_metadata = private_metadata;
for &key in &extension_props {
match obj_val.get(key) {
None | Some(Value::Null) => {}
Some(v) => {
space.extra.insert(key.to_owned(), v.clone());
}
}
}
space
};
match backend
.create_object::<Space, _>(caller, &account_id, create_id, build)
.await
{
Ok((_server_id, created_obj)) => {
mutated = true;
created.insert(
create_id.clone(),
jmap_server::serialize_value(&created_obj)?,
);
}
Err(e) => {
not_created.insert(create_id.clone(), backend_set_error_value(e));
}
}
}
}
let space_limits = backend.limits(caller, &account_id);
jmap_server::resolve_set_id_refs(&mut args, created_ids, &created);
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, mut patch_val) in update_map {
let id = match jmap_server::parse_wire_id(&id_str, "id") {
Ok(id) => id,
Err(err) => {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
if let Err(err) = resolve_refs(&mut patch_val, &["removeMembers"], created_ids)
.and_then(|()| {
resolve_entry_refs(
&mut patch_val,
&[
("addMembers", "id", "addMembers"),
("updateMembers", "id", "updateMembers"),
],
created_ids,
)
})
.and_then(|()| resolve_override_targets(&mut patch_val, created_ids))
{
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
let closed = match backend
.get_objects::<Space>(caller, &account_id, Some(std::slice::from_ref(&id)), None)
.await
{
Ok((spaces, _)) => spaces.first().is_some_and(|s| s.closed_at.is_some()),
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
if closed && patch_val.get("removeMembers") != Some(&json!([account_id])) {
not_updated.insert(id_str, space_closed());
continue;
}
match check_read_only_patch::<_, Space>(
backend,
caller,
&account_id,
&id,
&mut patch_val,
)
.await
{
Ok(false) => {}
Ok(true) => {
updated.insert(id_str, Value::Null);
continue;
}
Err(err) => {
not_updated.insert(id_str, err);
continue;
}
}
let Value::Object(mut patch_map) = patch_val else {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": "patch must be a JSON object" }),
);
continue;
};
let mut ops: Vec<SpacePatchOp> = Vec::new();
let mut clean_patch = serde_json::Map::new();
let mut object_metadata_patch = serde_json::Map::new();
let mut unknown_keys: Vec<String> = Vec::new();
let mut bad_structural_key: Option<(&'static str, String)> = None;
for (key, value) in std::mem::take(&mut patch_map) {
if let Some(structural) = StructuralKey::from_wire(&key) {
match parse_structural_entries(structural, value) {
Ok(parsed) => ops.extend(parsed),
Err(reason) => {
bad_structural_key = Some((structural.wire_name(), reason));
break;
}
}
} else if is_metadata_key(&key) {
object_metadata_patch.insert(key, value);
} else if is_client_updatable::<Space>(&key)
|| extension_props.contains(&key.as_str())
{
clean_patch.insert(key, value);
} else {
unknown_keys.push(key);
}
}
if let Some((canonical, reason)) = bad_structural_key {
not_updated.insert(
id_str,
json!({
"type": "invalidProperties",
"properties": [canonical],
"description": reason,
}),
);
continue;
}
if !unknown_keys.is_empty() {
not_updated.insert(
id_str,
json!({ "type": "invalidProperties", "properties": unknown_keys }),
);
continue;
}
if let Err(err) = check_metadata_entry(&object_metadata_patch, false, using) {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
if ops.is_empty() && clean_patch.is_empty() && object_metadata_patch.is_empty() {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": "patch contains no valid fields" }),
);
continue;
}
let self_removal = clean_patch.is_empty()
&& object_metadata_patch.is_empty()
&& matches!(ops.as_slice(), [SpacePatchOp::RemoveMember(m)] if *m == account_id);
if closed && !self_removal {
not_updated.insert(id_str, space_closed());
continue;
}
if ops.iter().any(|op| match op {
SpacePatchOp::AddRole(role) => role.position == 0,
SpacePatchOp::UpdateRole { patch, .. } => patch.position == Some(0),
_ => false,
}) {
not_updated.insert(
id_str,
json!({
"type": "invalidProperties",
"properties": ["position"],
"description":
"SpaceRole.position 0 is reserved for the implicit @everyone role; defined roles MUST have position > 0 (draft-atwood-jmap-chat-00 §SpaceRole)",
}),
);
continue;
}
if !ops.is_empty() {
match check_space_count_limits(
backend,
caller,
&account_id,
&id,
&ops,
&space_limits,
)
.await
{
Ok(Some(err)) => {
not_updated.insert(id_str, serde_json::Value::from(&err));
continue;
}
Ok(None) => {}
Err(je) => return Err(je),
}
}
if !object_metadata_patch.is_empty() {
let patch: PatchObject =
match serde_json::from_value(Value::Object(object_metadata_patch)) {
Ok(p) => p,
Err(e) => {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
continue;
}
};
if let Err(e) = backend
.update_object::<Space>(caller, &account_id, &id, patch)
.await
{
not_updated.insert(id_str, backend_set_error_value(e));
continue;
}
mutated = true;
}
if !ops.is_empty() {
let removed_channels: Vec<Id> = ops
.iter()
.filter_map(|op| match op {
SpacePatchOp::RemoveChannel(chat_id) => Some(chat_id.clone()),
_ => None,
})
.collect();
match backend
.apply_space_patch(caller, &account_id, &id, ops)
.await
{
Ok(op_results) => {
if let Some(first_err) =
op_results.iter().find_map(|r| r.outcome.as_ref().err())
{
not_updated.insert(id_str, serde_json::Value::from(first_err));
continue;
}
for chat_id in &removed_channels {
backend
.on_chat_destroyed(caller, &account_id, chat_id)
.await;
}
}
Err(e) => {
not_updated.insert(id_str, backend_set_error_value(e));
continue;
}
}
}
if clean_patch.is_empty() {
mutated = true;
updated.insert(id_str, Value::Null);
continue;
}
let typed_patch: jmap_chat_types::SpaceMetadataPatch =
match serde_json::from_value(Value::Object(clean_patch)) {
Ok(p) => p,
Err(e) => {
not_updated.insert(
id_str,
json!({
"type": "invalidProperties",
"description": format!("metadata patch failed to deserialize: {e}"),
}),
);
continue;
}
};
match backend
.apply_space_metadata_patch(caller, &account_id, &id, typed_patch)
.await
{
Ok(Some(obj)) => {
mutated = true;
updated.insert(id_str, jmap_server::serialize_value(&obj)?);
}
Ok(None) => {
mutated = true;
updated.insert(id_str, Value::Null);
}
Err(e) => {
not_updated.insert(id_str, backend_set_error_value(e));
}
}
}
}
if let Some(destroy_arr) = args.get("destroy").and_then(|v| v.as_array()) {
let id_strs: Vec<&str> = destroy_arr
.iter()
.map(|v| {
v.as_str().ok_or_else(|| {
JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {}",
jmap_server::json_type_name(v)
))
})
})
.collect::<Result<_, _>>()?;
for id_str in id_strs {
let id = match jmap_server::parse_wire_id(id_str, "id") {
Ok(id) => id,
Err(err) => {
not_destroyed.insert(id_str.to_owned(), serde_json::Value::from(&*err));
continue;
}
};
let channel_ids = match space_channel_ids(backend, caller, &account_id, &id).await {
Ok(ids) => ids,
Err(e) => {
not_destroyed.insert(id_str.to_owned(), server_fail_value_from_backend(&e));
continue;
}
};
match backend
.destroy_object::<Space>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str.to_owned()));
for chat_id in &channel_ids {
backend
.on_chat_destroyed(caller, &account_id, chat_id)
.await;
}
backend.on_space_destroyed(caller, &account_id, &id).await;
}
Err(e) => {
not_destroyed.insert(id_str.to_owned(), backend_set_error_value(e));
}
}
}
}
finalize_set_response::<B, Space>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
pub async fn handle_space_join<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let (account_id, args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
let invite_code = args
.get("inviteCode")
.and_then(|v| v.as_str())
.map(|s| s.to_owned());
let space_id_str = args
.get("spaceId")
.and_then(|v| v.as_str())
.map(|s| s.to_owned());
let (space_id, current_members, invite_id, closed) = match (invite_code, space_id_str) {
(Some(_), Some(_)) | (None, None) => {
return Err(JmapError::invalid_arguments(
"exactly one of inviteCode or spaceId must be provided",
));
}
(Some(code), None) => {
let (invites, _) = backend
.get_objects::<SpaceInvite>(caller, &account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let invite = invites
.into_iter()
.find(|inv| inv.code.as_bytes().ct_eq(code.as_bytes()).into())
.ok_or_else(|| JmapError::invalid_arguments("invite code not found"))?;
if let Some(expires_at) = &invite.expires_at {
let now = now_utc_string();
if !iso8601_before(&now, expires_at) {
return Err(JmapError::invalid_arguments("invite has expired"));
}
}
if let Some(max) = invite.max_uses
&& invite.uses >= max
{
return Err(JmapError::invalid_arguments(
"invite has reached its maximum number of uses",
));
}
let space_id = invite.space_id.clone();
let (spaces, _) = backend
.get_objects::<Space>(
caller,
&account_id,
Some(std::slice::from_ref(&space_id)),
None,
)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let closed = spaces.first().is_some_and(|s| s.closed_at.is_some());
(space_id, Vec::new(), Some(invite.id), closed)
}
(None, Some(sid)) => {
let space_id_typed = Id::new_validated(sid.as_str())
.map_err(|e| JmapError::invalid_arguments(format!("spaceId: {e}")))?;
let (spaces, _) = backend
.get_objects::<Space>(caller, &account_id, Some(&[space_id_typed]), None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let space = spaces
.into_iter()
.next()
.filter(|s| s.is_public)
.ok_or_else(|| JmapError::custom("notPermitted"))?;
let space_id = space.id.clone();
let closed = space.closed_at.is_some();
let members: Vec<Value> = space
.members
.into_iter()
.map(serde_json::to_value)
.collect::<Result<Vec<_>, _>>()
.map_err(|e| server_fail_from_backend(&e))?;
(space_id, members, None, closed)
}
};
let (bans, _) = backend
.get_objects::<SpaceBan>(caller, &account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let now = now_utc_string();
if bans.iter().any(|b| {
b.space_id == space_id
&& b.user_id == account_id
&& b.expires_at
.as_ref()
.is_none_or(|e| iso8601_before(&now, e))
}) {
return Err(JmapError::forbidden());
}
if closed {
return Err(JmapError::forbidden());
}
let joined = || {
Ok(HandlerOutput::new(
json!({ "accountId": account_id.as_ref(), "spaceId": space_id.as_ref() }),
))
};
if let Some(invite_id) = invite_id {
let joined_at = UTCDate::from(now_utc_string().as_ref());
return match backend
.join_space_with_invite(caller, &account_id, &invite_id, &joined_at)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
Ok(()) => {
create_channel_read_positions(backend, caller, &account_id, &space_id).await;
joined()
}
Err(InviteJoinRefusal::NotFound) => {
Err(JmapError::invalid_arguments("invite code not found"))
}
Err(InviteJoinRefusal::Exhausted) => Err(JmapError::invalid_arguments(
"invite has reached its maximum number of uses",
)),
Err(InviteJoinRefusal::AlreadyMember) => Err(JmapError::invalid_arguments(
"caller is already a member of this space",
)),
};
}
let now_str = now_utc_string();
let mut new_members = current_members;
let already_member = new_members
.iter()
.any(|m| m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref()));
if already_member {
return Err(JmapError::invalid_arguments(
"caller is already a member of this space",
));
}
new_members.push(json!({
"id": account_id.as_ref(),
"roleIds": [],
"joinedAt": now_str,
}));
let mut members_patch = serde_json::Map::new();
members_patch.insert("members".to_owned(), json!(new_members));
backend
.update_object::<Space>(
caller,
&account_id,
&space_id,
PatchObject::from_map(members_patch),
)
.await
.map_err(|e: jmap_server::BackendSetError<_>| server_fail_from_backend(&e))?;
let (post_spaces, _) = backend
.get_objects::<Space>(
caller,
&account_id,
Some(std::slice::from_ref(&space_id)),
None,
)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let post_members: Vec<Value> = post_spaces
.into_iter()
.next()
.map(|s| {
s.members
.into_iter()
.map(serde_json::to_value)
.collect::<Result<Vec<_>, _>>()
})
.transpose()
.map_err(|e| server_fail_from_backend(&e))?
.unwrap_or_default();
let duplicate_count = post_members
.iter()
.filter(|m| m.get("id").and_then(|v| v.as_str()) == Some(account_id.as_ref()))
.count();
if duplicate_count > 1 {
let deduped = dedup_caller_members(post_members, account_id.as_ref());
let mut deduped_patch = serde_json::Map::new();
deduped_patch.insert("members".to_owned(), json!(deduped));
backend
.update_object::<Space>(
caller,
&account_id,
&space_id,
PatchObject::from_map(deduped_patch),
)
.await
.map_err(|e: jmap_server::BackendSetError<_>| server_fail_from_backend(&e))?;
}
create_channel_read_positions(backend, caller, &account_id, &space_id).await;
joined()
}
fn space_closed() -> Value {
json!({ "type": "forbidden", "description": "the Space is closed" })
}
async fn create_channel_read_positions<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
space_id: &Id,
) {
let Ok(channel_ids) = space_channel_ids(backend, caller, account_id, space_id).await else {
return;
};
crate::message::ensure_read_positions(backend, caller, account_id, channel_ids).await;
}
async fn space_channel_ids<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
space_id: &Id,
) -> Result<Vec<Id>, B::Error> {
let (chats, _) = backend
.get_objects::<Chat>(caller, account_id, None, None)
.await?;
Ok(chats
.into_iter()
.filter(|c| c.kind == ChatKind::Channel && c.space_id.as_ref() == Some(space_id))
.map(|c| c.id)
.collect())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn dedup_caller_members_keeps_single_entry() {
let input = vec![json!({"id": "a1", "joinedAt": "2026-01-01T00:00:00.000Z"})];
let out = dedup_caller_members(input, "a1");
assert_eq!(out.len(), 1);
assert_eq!(out[0]["id"], "a1");
}
#[test]
fn dedup_caller_members_collapses_duplicates() {
let input = vec![
json!({"id": "a1", "joinedAt": "2026-01-01T00:00:00.000Z"}),
json!({"id": "a1", "joinedAt": "2026-01-01T00:00:00.001Z"}),
];
let out = dedup_caller_members(input, "a1");
assert_eq!(out.len(), 1);
assert_eq!(out[0]["id"], "a1");
assert_eq!(out[0]["joinedAt"], "2026-01-01T00:00:00.000Z");
}
#[test]
fn dedup_caller_members_collapses_three_duplicates() {
let input = vec![
json!({"id": "a1"}),
json!({"id": "a1"}),
json!({"id": "a1"}),
];
let out = dedup_caller_members(input, "a1");
assert_eq!(out.len(), 1);
assert_eq!(out[0]["id"], "a1");
}
#[test]
fn dedup_caller_members_preserves_other_members() {
let input = vec![
json!({"id": "u2"}),
json!({"id": "a1"}),
json!({"id": "u3"}),
json!({"id": "a1"}),
json!({"id": "u4"}),
];
let out = dedup_caller_members(input, "a1");
assert_eq!(out.len(), 4);
let ids: Vec<&str> = out
.iter()
.filter_map(|m| m.get("id").and_then(|v| v.as_str()))
.collect();
assert_eq!(ids, vec!["u2", "a1", "u3", "u4"]);
}
#[test]
fn dedup_caller_members_empty() {
let out = dedup_caller_members(vec![], "a1");
assert!(out.is_empty());
}
#[test]
fn dedup_caller_members_skips_malformed_entries() {
let input = vec![
json!({"joinedAt": "2026-01-01T00:00:00.000Z"}), json!({"id": 42}), json!({"id": "a1"}),
];
let out = dedup_caller_members(input, "a1");
assert_eq!(out.len(), 3);
}
}