use std::collections::{HashMap, HashSet};
use jmap_chat_types::query::ChatComparator;
use jmap_chat_types::vocabulary::SPEC_CHAT_MEMBER_ROLES;
use jmap_chat_types::{Chat, ChatKind, ChatMember};
use jmap_types::{Id, JmapError, PatchObject, UTCDate};
use serde::Deserialize;
use serde_json::{json, Value};
use crate::backend::{BackendSetError, ChatBackend, SetError, SetErrorType};
use crate::helpers::{
enforce_max_objects_in_set, extract_account_id, finalize_set_response, now_utc_string,
reject_unsupported_sort, set_error_value, SetAccumulators,
};
use crate::helpers::{mistyped_create_props, PropType, PLACEHOLDER_ID};
use jmap_server::{server_fail_from_backend, server_fail_value_from_backend, HandlerOutput};
const MEMBER_PATCH_KEYS: &[&str] = &["addMembers", "removeMembers", "updateMemberRoles"];
const SHARED_GROUP_KEYS: &[&str] = &["name", "description", "avatarBlobId", "pinnedMessageIds"];
#[derive(Deserialize)]
struct MemberRoleEntry {
id: Id,
role: Option<String>,
}
#[allow(clippy::result_large_err)]
fn apply_member_patch_keys(
chat: &Chat,
owner_id: &Id,
patch: &serde_json::Map<String, Value>,
max_members: u32,
) -> Result<(Vec<ChatMember>, bool), SetError> {
fn parse<T: serde::de::DeserializeOwned>(
patch: &serde_json::Map<String, Value>,
key: &str,
) -> Result<Option<T>, SetError> {
patch
.get(key)
.map(|v| serde_json::from_value(v.clone()))
.transpose()
.map_err(|_| SetError::new(SetErrorType::InvalidProperties).with_properties([key]))
}
let valid_role = |role: &str| SPEC_CHAT_MEMBER_ROLES.contains(&role);
let invalid = |key: &str| SetError::new(SetErrorType::InvalidProperties).with_properties([key]);
let forbidden = |desc: &str| SetError::new(SetErrorType::Forbidden).with_description(desc);
let add: Option<Vec<MemberRoleEntry>> = parse(patch, "addMembers")?;
let remove: Option<Vec<Id>> = parse(patch, "removeMembers")?;
let update: Option<Vec<MemberRoleEntry>> = parse(patch, "updateMemberRoles")?;
if add
.iter()
.flatten()
.any(|e| e.role.as_deref().is_some_and(|r| !valid_role(r)))
{
return Err(invalid("addMembers"));
}
if update
.iter()
.flatten()
.any(|e| !e.role.as_deref().is_some_and(valid_role))
{
return Err(invalid("updateMemberRoles"));
}
if chat.kind != ChatKind::Group {
return Err(forbidden("member patch keys apply to group chats only"));
}
let mut members = chat.members.clone().unwrap_or_default();
let is_admin = members
.iter()
.any(|m| m.id == *owner_id && m.role == "admin");
let self_leave = add.is_none()
&& update.is_none()
&& remove.as_deref() == Some(std::slice::from_ref(owner_id));
if !is_admin && !self_leave {
return Err(forbidden("only group chat admins may change members"));
}
if let Some(add) = &add {
let now = UTCDate::from(now_utc_string().as_ref());
for entry in add {
if members.iter().all(|m| m.id != entry.id) {
let role = entry.role.clone().unwrap_or_else(|| "member".to_owned());
let mut m = ChatMember::new(entry.id.clone(), role, now.clone());
m.invited_by = Some(owner_id.clone());
members.push(m);
}
}
if members.len() > max_members as usize {
return Err(SetError::new(SetErrorType::OverQuota)
.with_description("group chat member limit exceeded"));
}
}
if let Some(remove) = &remove {
members.retain(|m| !remove.contains(&m.id));
}
if let Some(update) = &update {
for entry in update {
let member = members
.iter_mut()
.find(|m| m.id == entry.id)
.ok_or_else(|| invalid("updateMemberRoles"))?;
member.role = entry.role.clone().expect("role checked above");
}
if !members.is_empty() && members.iter().all(|m| m.role != "admin") {
return Err(forbidden("the last admin may not demote themselves"));
}
}
let closes = is_admin
&& members.iter().all(|m| m.id != *owner_id)
&& !members.is_empty()
&& members.iter().all(|m| m.role != "admin");
Ok((members, closes))
}
pub async fn handle_chat_get<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handlers::handle_get::<Chat, B>(backend, caller, args).await
}
pub async fn handle_chat_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handlers::handle_changes::<Chat, B>(backend, caller, args).await
}
pub async fn handle_chat_query<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
reject_unsupported_sort::<ChatComparator>(args.get("sort"))?;
jmap_server::handlers::handle_query::<Chat, B>(backend, caller, args).await
}
pub async fn handle_chat_query_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handlers::handle_query_changes::<Chat, B>(backend, caller, args).await
}
pub async fn handle_chat_set<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let (account_id, mut args) = extract_account_id(args)?;
enforce_max_objects_in_set(&args, backend.max_objects_in_set(caller, &account_id))?;
let old_state = backend
.get_state::<Chat>(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 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;
if let Some(create_map) = args.get("create").and_then(|v| v.as_object()) {
let has_direct_create = create_map.values().any(|v| {
v.get("kind")
.and_then(|k| k.as_str())
.is_some_and(|s| s.eq_ignore_ascii_case("direct"))
});
let (existing_chats, mut known_direct_contact_ids): (Vec<Chat>, HashSet<String>) =
if has_direct_create {
let (chats, _) = backend
.get_objects::<Chat>(caller, &account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let known = chats
.iter()
.filter(|c| c.kind == ChatKind::Direct)
.filter_map(|c| c.contact_id.as_ref().map(|id| id.as_ref().to_owned()))
.collect();
(chats, known)
} else {
(Vec::new(), HashSet::new())
};
let mut batch_direct_ids: HashMap<String, Id> = HashMap::new();
for (create_id, obj_val) in create_map {
if let Some(err) = mistyped_create_props(
obj_val,
&[
("contactId", PropType::Str),
("name", PropType::Str),
("description", PropType::Str),
("spaceId", PropType::Str),
("muted", PropType::Bool),
("receiveTypingIndicators", PropType::Bool),
],
) {
not_created.insert(create_id.clone(), err);
continue;
}
let Some(kind_str) = obj_val
.get("kind")
.and_then(|v| v.as_str())
.map(str::to_owned)
else {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["kind"] }),
);
continue;
};
let kind = match serde_json::from_value::<ChatKind>(Value::String(kind_str)) {
Ok(k) if !matches!(k, ChatKind::Other(_)) => k,
_ => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["kind"] }),
);
continue;
}
};
let direct_contact_id_str: Option<String> = match &kind {
ChatKind::Direct => {
let Some(contact_id_str) = obj_val
.get("contactId")
.and_then(|v| v.as_str())
.map(str::to_owned)
else {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["contactId"] }),
);
continue;
};
if let Some(dup) = existing_chats.iter().find(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str.as_str())
}) {
not_created.insert(
create_id.clone(),
serde_json::to_value(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(dup.id.clone()),
)
.expect("derive(Serialize) on plain data is infallible"),
);
continue;
}
if known_direct_contact_ids.contains(&contact_id_str) {
let canonical_id = if let Some(c) = existing_chats.iter().find(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str.as_str())
}) {
c.id.clone()
} else if let Some(id) = batch_direct_ids.get(&contact_id_str) {
id.clone()
} else {
not_created.insert(
create_id.clone(),
json!({
"type": "serverFail",
"description": "direct chat for contact not found after concurrent operation; retry"
}),
);
continue;
};
not_created.insert(
create_id.clone(),
serde_json::to_value(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(canonical_id),
)
.expect("derive(Serialize) on plain data is infallible"),
);
continue;
}
Some(contact_id_str)
}
ChatKind::Channel => {
not_created.insert(create_id.clone(), json!({ "type": "forbidden" }));
continue;
}
_ => None,
};
let member_ids: Option<Vec<Id>> = if kind == ChatKind::Group {
match obj_val.get("memberIds") {
None => Some(Vec::new()),
Some(v) => match serde_json::from_value::<Vec<String>>(v.clone()) {
Ok(ids) => Some(ids.into_iter().map(Id::from).collect()),
Err(_) => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["memberIds"] }),
);
continue;
}
},
}
} else {
None
};
let now_str = now_utc_string();
let now: UTCDate = UTCDate::from(now_str.as_ref());
let members: Option<Vec<ChatMember>> = member_ids.map(|ids| {
let creator: Id = account_id.clone();
let mut members = vec![ChatMember::new(
creator.clone(),
"admin".to_owned(),
now.clone(),
)];
for id in ids {
if members.iter().all(|m| m.id != id) {
let mut m = ChatMember::new(id, "member".to_owned(), now.clone());
m.invited_by = Some(creator.clone());
members.push(m);
}
}
members
});
let contact_id: Option<Id> = obj_val
.get("contactId")
.and_then(|v| v.as_str())
.map(Id::from);
let name: Option<String> = obj_val
.get("name")
.and_then(|v| v.as_str())
.map(str::to_owned);
let description: Option<String> = obj_val
.get("description")
.and_then(|v| v.as_str())
.map(str::to_owned);
let space_id: Option<Id> = obj_val
.get("spaceId")
.and_then(|v| v.as_str())
.map(Id::from);
let muted: bool = obj_val
.get("muted")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let receive_typing_indicators: bool = obj_val
.get("receiveTypingIndicators")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let mut chat = Chat::new(
Id::from(PLACEHOLDER_ID),
kind,
now,
0,
vec![],
muted,
receive_typing_indicators,
);
chat.contact_id = contact_id;
chat.name = name;
chat.description = description;
chat.space_id = space_id;
chat.members = members;
match backend
.create_object::<Chat>(caller, &account_id, create_id, chat)
.await
{
Ok((new_id, created_obj)) => {
if let Some(contact_id_str) = direct_contact_id_str.as_deref() {
let (current_chats, _) = backend
.get_objects::<Chat>(caller, &account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let duplicates: Vec<&Chat> = current_chats
.iter()
.filter(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str)
})
.collect();
if duplicates.len() > 1 {
let canonical_id: Id = duplicates
.iter()
.map(|c| c.id.as_ref())
.min()
.map(Id::from)
.unwrap_or_else(|| new_id.clone());
if new_id != canonical_id {
if let Err(e) = backend
.destroy_object::<Chat>(caller, &account_id, &new_id)
.await
{
not_created.insert(
create_id.clone(),
server_fail_value_from_backend(&e),
);
continue;
}
not_created.insert(
create_id.clone(),
serde_json::to_value(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(canonical_id),
)
.unwrap_or_else(|e| server_fail_value_from_backend(&e)),
);
continue;
}
}
known_direct_contact_ids.insert(contact_id_str.to_owned());
batch_direct_ids.insert(contact_id_str.to_owned(), new_id.clone());
}
mutated = true;
created.insert(
create_id.clone(),
serde_json::to_value(&created_obj)
.expect("derive(Serialize) on plain data is infallible"),
);
}
Err(BackendSetError::SetError(set_err)) => {
not_created.insert(create_id.clone(), set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_created.insert(create_id.clone(), server_fail_value_from_backend(&e));
}
Err(_) => {
not_created.insert(
create_id.clone(),
json!({
"type": "serverFail",
"description": "unhandled backend error variant",
}),
);
}
}
}
}
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, patch_val) in update_map {
let id = Id::from(id_str.as_str());
const CHAT_READONLY: &[&str] =
&["id", "createdAt", "unreadCount", "closedAt", "activeCallId"];
let bad_props: Vec<&str> = CHAT_READONLY
.iter()
.copied()
.filter(|&field| patch_val.get(field).is_some())
.collect();
if !bad_props.is_empty() {
not_updated.insert(
id_str,
json!({ "type": "invalidProperties", "properties": bad_props }),
);
continue;
}
let mut patch = match serde_json::from_value::<PatchObject>(patch_val) {
Ok(p) => p,
Err(e) => {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
continue;
}
};
let touches_closed_keys = patch.as_map().keys().any(|k| {
let top = k.split('/').next().unwrap_or(k);
MEMBER_PATCH_KEYS.contains(&top) || SHARED_GROUP_KEYS.contains(&top)
});
if touches_closed_keys {
match backend
.get_objects::<Chat>(caller, &account_id, Some(std::slice::from_ref(&id)), None)
.await
{
Ok((chats, _)) if chats.first().is_some_and(|c| c.closed_at.is_some()) => {
not_updated.insert(
id_str,
json!({ "type": "forbidden", "description": "the group is closed" }),
);
continue;
}
Ok(_) => {}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
if MEMBER_PATCH_KEYS
.iter()
.any(|k| patch.as_map().contains_key(*k))
{
let stored = match backend
.get_objects::<Chat>(caller, &account_id, Some(std::slice::from_ref(&id)), None)
.await
{
Ok((chats, _)) => chats.into_iter().next(),
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
if let Some(stored) = stored {
let max_members = backend.limits(caller, &account_id).max_group_chat_members;
match apply_member_patch_keys(&stored, &account_id, patch.as_map(), max_members)
{
Ok((members, closes)) => {
let map = patch.as_map_mut();
for key in MEMBER_PATCH_KEYS {
map.remove(*key);
}
map.insert(
"members".to_owned(),
serde_json::to_value(members)
.expect("derive(Serialize) on plain data is infallible"),
);
if closes {
map.insert("closedAt".to_owned(), json!(now_utc_string()));
}
}
Err(set_err) => {
not_updated.insert(id_str, set_error_value(&set_err));
continue;
}
}
}
}
let touches_pins = patch
.as_map()
.keys()
.any(|k| k == "pinnedMessageIds" || k.starts_with("pinnedMessageIds/"));
if touches_pins {
match backend
.may_set_pinned_messages(caller, &account_id, &id)
.await
{
Ok(Ok(())) => {}
Ok(Err(set_err)) => {
not_updated.insert(id_str, set_error_value(&set_err));
continue;
}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
if let Some(Value::Array(new_pins)) = patch.as_map().get("pinnedMessageIds") {
let stored = match backend
.get_objects::<Chat>(caller, &account_id, Some(std::slice::from_ref(&id)), None)
.await
{
Ok((chats, _)) => chats.into_iter().next(),
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
if let Some(stored) = stored {
let added: Vec<Id> = new_pins
.iter()
.filter_map(Value::as_str)
.map(Id::from)
.filter(|pin| !stored.pinned_message_ids.contains(pin))
.collect();
if !added.is_empty() {
match backend
.validate_pinned_message_ids(caller, &account_id, &id, &added)
.await
{
Ok(Ok(())) => {}
Ok(Err(set_err)) => {
not_updated.insert(id_str, set_error_value(&set_err));
continue;
}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
}
}
match backend
.update_object::<Chat>(caller, &account_id, &id, patch)
.await
{
Ok(Some(obj)) => {
mutated = true;
updated.insert(
id_str,
serde_json::to_value(&obj)
.expect("derive(Serialize) on plain data is infallible"),
);
}
Ok(None) => {
mutated = true;
updated.insert(id_str, Value::Null);
}
Err(BackendSetError::SetError(set_err)) => {
not_updated.insert(id_str, set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
}
Err(_) => {
not_updated.insert(
id_str,
json!({
"type": "serverFail",
"description": "unhandled backend error variant",
}),
);
}
}
}
}
if let Some(destroy_arr) = args.get("destroy").and_then(|v| v.as_array()) {
if let Some(bad) = destroy_arr.iter().find(|v| !v.is_string()) {
return Err(JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {bad}"
)));
}
for id_val in destroy_arr {
let Some(id_str) = id_val.as_str() else {
continue; };
let id = Id::from(id_str);
match backend
.destroy_object::<Chat>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str.to_owned()));
}
Err(BackendSetError::SetError(set_err)) => {
not_destroyed.insert(id_str.to_owned(), set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_destroyed.insert(id_str.to_owned(), server_fail_value_from_backend(&e));
}
Err(_) => {
not_destroyed.insert(
id_str.to_owned(),
json!({
"type": "serverFail",
"description": "unhandled backend error variant",
}),
);
}
}
}
}
finalize_set_response::<B, Chat>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
pub async fn handle_chat_typing<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let (account_id, args) = extract_account_id(args)?;
let chat_id: Id = match args.get("chatId").and_then(|v| v.as_str()) {
Some(s) if !s.is_empty() => Id::from(s),
_ => return Err(JmapError::invalid_arguments("chatId is required")),
};
let _typing: bool = match args.get("typing") {
Some(Value::Bool(b)) => *b,
None => return Err(JmapError::invalid_arguments("typing is required")),
Some(_) => return Err(JmapError::invalid_arguments("typing must be a boolean")),
};
let (found, _not_found) = backend
.get_objects::<Chat>(
caller,
&account_id,
Some(std::slice::from_ref(&chat_id)),
None,
)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let chat = found
.into_iter()
.next()
.filter(|c| {
c.kind != ChatKind::Group || c.members.iter().flatten().any(|m| m.id == account_id)
})
.ok_or_else(|| {
JmapError::invalid_arguments("chatId is not a Chat the account participates in")
})?;
if let Some(contact_id) = chat.contact_id.as_ref() {
let _blocked = backend
.is_contact_blocked(caller, &account_id, contact_id)
.await
.unwrap_or(false);
}
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
})))
}