use std::collections::HashSet;
use jmap_types::{Id, JmapError, JmapObject, State};
use serde_json::{Map, Value, json};
use crate::ChatBackend;
use jmap_server::{HandlerOutput, server_fail_from_backend};
pub(crate) use jmap_server::{
enforce_max_objects_in_get, enforce_max_objects_in_set, extract_account_id, not_found_json,
now_utc_string, optional_arg, serialize_value,
};
#[derive(Clone, Copy)]
pub(crate) enum PropType {
Str,
Bool,
UnsignedInt,
Array,
}
pub(crate) fn check_metadata_entry(
entry: &Map<String, Value>,
is_create: bool,
using: &[String],
) -> Result<(), Box<jmap_server::SetError>> {
let uses_metadata = using
.iter()
.any(|u| u == jmap_metadata_types::JMAP_METADATA_URI);
for (key, value) in entry {
if !is_metadata_key(key) {
continue;
}
let description = if !uses_metadata {
"writing metadata requires urn:ietf:params:jmap:metadata in using"
} else if is_create && value.is_null() {
"null is not allowed on create; use {}"
} else {
continue;
};
return Err(Box::new(
jmap_server::SetError::new(jmap_server::SetErrorType::InvalidProperties)
.with_properties([key.as_str()])
.with_description(description),
));
}
Ok(())
}
pub(crate) fn is_metadata_key(key: &str) -> bool {
let root = key.split_once('/').map_or(key, |(r, _)| r);
root == "metadata" || root == "privateMetadata"
}
pub(crate) type MetadataMaps = (Option<Map<String, Value>>, Option<Map<String, Value>>);
pub(crate) fn create_metadata(entry: &Value) -> Result<MetadataMaps, Value> {
let take = |property: &str| match entry.get(property) {
None | Some(Value::Null) => Ok(None),
Some(Value::Object(m)) => Ok(Some(m.clone())),
Some(_) => Err(Value::from(
&jmap_server::SetError::new(jmap_server::SetErrorType::InvalidProperties)
.with_properties([property])
.with_description("value must be an object"),
)),
};
Ok((take("metadata")?, take("privateMetadata")?))
}
const MAX_UNSIGNED_INT: u64 = (1 << 53) - 1;
pub(crate) fn mistyped_create_props(obj: &Value, props: &[(&str, PropType)]) -> Option<Value> {
let bad: Vec<&str> = props
.iter()
.filter(|(key, ty)| match obj.get(*key) {
None | Some(Value::Null) => false,
Some(v) => !match ty {
PropType::Str => v.is_string(),
PropType::Bool => v.is_boolean(),
PropType::UnsignedInt => v.as_u64().is_some_and(|n| n <= MAX_UNSIGNED_INT),
PropType::Array => v.is_array(),
},
})
.map(|(key, _)| *key)
.collect();
(!bad.is_empty()).then(|| json!({ "type": "invalidProperties", "properties": bad }))
}
pub(crate) fn default_sort(args: &mut Map<String, Value>, default: Value) {
let unsorted = match args.get("sort") {
None | Some(Value::Null) => true,
Some(Value::Array(a)) => a.is_empty(),
Some(_) => false,
};
if unsorted {
args.insert("sort".to_owned(), default);
}
}
pub(crate) fn reject_unsupported_sort<C: serde::de::DeserializeOwned + KnownSort>(
sort: Option<&Value>,
) -> Result<(), JmapError> {
if let Some(Value::Array(comparators)) = sort {
for c in comparators {
if !<C as serde::Deserialize>::deserialize(c).is_ok_and(|c| c.known()) {
return Err(JmapError::unsupported_sort());
}
}
}
Ok(())
}
pub(crate) trait KnownSort {
fn known(&self) -> bool;
}
macro_rules! known_sort {
($($cmp:ty => $prop:path),+ $(,)?) => {$(
impl KnownSort for $cmp {
fn known(&self) -> bool {
!matches!(self.property, $prop(_))
}
}
)+};
}
known_sort!(
jmap_chat_types::ChatContactComparator => jmap_chat_types::ChatContactComparatorProperty::Other,
jmap_chat_types::ChatComparator => jmap_chat_types::ChatComparatorProperty::Other,
jmap_chat_types::MessageComparator => jmap_chat_types::MessageComparatorProperty::Other,
jmap_chat_types::SpaceComparator => jmap_chat_types::SpaceComparatorProperty::Other,
jmap_chat_types::CustomEmojiComparator => jmap_chat_types::CustomEmojiComparatorProperty::Other,
);
#[derive(Debug, Default)]
pub(crate) struct SetAccumulators {
pub created: Map<String, Value>,
pub updated: Map<String, Value>,
pub destroyed: Vec<Value>,
pub not_created: Map<String, Value>,
pub not_updated: Map<String, Value>,
pub not_destroyed: Map<String, Value>,
}
pub(crate) async fn finalize_set_response<B, O>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
old_state: State,
mutated: bool,
acc: SetAccumulators,
) -> Result<HandlerOutput, JmapError>
where
B: ChatBackend,
O: JmapObject + Send + Sync,
{
let new_state = if mutated {
backend
.get_state::<O>(caller, account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
} else {
old_state.clone()
};
let SetAccumulators {
created,
updated,
destroyed,
not_created,
not_updated,
not_destroyed,
} = acc;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"oldState": old_state.as_ref(),
"newState": new_state.as_ref(),
"created": if created.is_empty() { Value::Null } else { Value::Object(created) },
"updated": if updated.is_empty() { Value::Null } else { Value::Object(updated) },
"destroyed": if destroyed.is_empty() { Value::Null } else { Value::Array(destroyed) },
"notCreated": if not_created.is_empty() { Value::Null } else { Value::Object(not_created) },
"notUpdated": if not_updated.is_empty() { Value::Null } else { Value::Object(not_updated) },
"notDestroyed": if not_destroyed.is_empty() { Value::Null } else { Value::Object(not_destroyed) },
})))
}
pub(crate) async fn check_read_only_patch<B, O>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
patch: &mut Value,
) -> Result<bool, Value>
where
B: ChatBackend,
O: jmap_server::GetObject + jmap_server::SetObject + serde::Serialize + Send + Sync,
{
let Value::Object(map) = patch else {
return Ok(false);
};
jmap_server::check_read_only_patch::<B, O>(backend, caller, account_id, id, map).await
}
pub(crate) fn strip_read_only_patch<O>(
patch: &mut Map<String, Value>,
stored: &O,
) -> Result<(), Value>
where
O: jmap_server::SetObject + serde::Serialize,
{
let current = match serde_json::to_value(stored) {
Ok(Value::Object(m)) => m,
Ok(_) => {
return Err(jmap_server::server_fail_value_from_backend(
"stored object is not a JSON object",
));
}
Err(e) => return Err(jmap_server::server_fail_value_from_backend(&e)),
};
jmap_server::strip_read_only_patch::<O>(patch, Some(¤t)).map_err(|e| Value::from(&*e))
}
pub(crate) fn filter_properties(
obj: &serde_json::Value,
prop_set: &HashSet<&str>,
) -> serde_json::Value {
match obj {
serde_json::Value::Object(map) => {
let filtered: serde_json::Map<String, serde_json::Value> = map
.iter()
.filter(|(k, _)| prop_set.contains(k.as_str()))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
serde_json::Value::Object(filtered)
}
_ => obj.clone(),
}
}
pub(crate) fn iso8601_before(a: &jmap_types::UTCDate, b: &jmap_types::UTCDate) -> bool {
let a_str: &str = a.as_ref();
let b_str: &str = b.as_ref();
let a_sec = &a_str[..a_str.len().min(19)];
let b_sec = &b_str[..b_str.len().min(19)];
a_sec < b_sec
}
pub(crate) fn resolve_ref(
raw: &str,
property: &str,
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<jmap_types::Id, Box<jmap_server::SetError>> {
jmap_server::resolve_creation_ref(raw, created_ids).ok_or_else(|| {
Box::new(
jmap_server::SetError::new(jmap_server::SetErrorType::InvalidProperties)
.with_properties([property])
.with_description(
"creation id reference matches no record created earlier in this request",
),
)
})
}
pub(crate) fn resolve_refs(
obj: &mut serde_json::Value,
props: &[&str],
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<(), Box<jmap_server::SetError>> {
let Some(m) = obj.as_object_mut() else {
return Ok(());
};
for p in props {
let values: Vec<&mut serde_json::Value> = match m.get_mut(*p) {
Some(serde_json::Value::Array(items)) => items.iter_mut().collect(),
Some(v) => vec![v],
None => Vec::new(),
};
for v in values {
if let serde_json::Value::String(raw) = v {
*raw = resolve_ref(raw, p, created_ids)?.as_ref().to_owned();
}
}
}
Ok(())
}
pub(crate) fn resolve_entry_refs(
obj: &mut serde_json::Value,
entries: &[(&str, &str, &str)],
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<(), Box<jmap_server::SetError>> {
for &(prop, field, named) in entries {
let Some(serde_json::Value::Array(items)) = obj.get_mut(prop) else {
continue;
};
for item in items {
if let Some(serde_json::Value::String(raw)) = item.get_mut(field) {
*raw = resolve_ref(raw, named, created_ids)?.as_ref().to_owned();
}
}
}
Ok(())
}
pub(crate) fn resolved_create(
obj: &serde_json::Value,
props: &[&str],
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<serde_json::Value, Box<jmap_server::SetError>> {
let mut obj = obj.clone();
resolve_refs(&mut obj, props, created_ids)?;
Ok(obj)
}
pub(crate) fn parents_first<'a>(
creates: &'a serde_json::Map<String, serde_json::Value>,
props: &[&str],
) -> Vec<(&'a String, &'a serde_json::Value)> {
let mut pending: Vec<(&String, &serde_json::Value)> = creates.iter().collect();
let mut ordered: Vec<(&String, &serde_json::Value)> = Vec::with_capacity(pending.len());
loop {
let before = pending.len();
pending.retain(|&(create_id, obj)| {
let waits = props.iter().any(|p| {
obj.get(*p)
.and_then(serde_json::Value::as_str)
.and_then(|r| r.strip_prefix('#'))
.is_some_and(|parent| {
parent != create_id.as_str()
&& creates.contains_key(parent)
&& !ordered.iter().any(|(done, _)| done.as_str() == parent)
})
});
if !waits {
ordered.push((create_id, obj));
}
waits
});
if pending.is_empty() || pending.len() == before {
ordered.extend(pending);
return ordered;
}
}
}
pub(crate) fn count_add_ops(ops: &[crate::SpacePatchOp]) -> (u32, u32, u32, u32) {
let mut add_roles: u32 = 0;
let mut add_members: u32 = 0;
let mut add_channels: u32 = 0;
let mut add_categories: u32 = 0;
for op in ops {
match op {
crate::SpacePatchOp::AddRole(_) => add_roles = add_roles.saturating_add(1),
crate::SpacePatchOp::AddMember(_) => {
add_members = add_members.saturating_add(1);
}
crate::SpacePatchOp::AddChannel(_) => {
add_channels = add_channels.saturating_add(1);
}
crate::SpacePatchOp::AddCategory(_) => {
add_categories = add_categories.saturating_add(1);
}
_ => {}
}
}
(add_roles, add_members, add_channels, add_categories)
}