use jmap_types::{Id, JmapError, JmapObject, State};
use serde_json::{Map, Value, json};
use crate::TasksBackend;
use jmap_server::{HandlerOutput, server_fail_from_backend};
pub(crate) use jmap_server::{enforce_max_objects_in_set, extract_account_id};
#[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: TasksBackend,
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) 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>> {
if !raw.starts_with('#') {
return jmap_server::parse_wire_id(raw, property);
}
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 {
if let Some(serde_json::Value::String(raw)) = m.get_mut(*p) {
*raw = resolve_ref(raw, p, created_ids)?.as_ref().to_owned();
}
}
Ok(())
}
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 matches!(C::deserialize(c), Ok(c) if !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_tasks_types::TaskComparator => jmap_tasks_types::TaskComparatorProperty::Other,
jmap_tasks_types::TaskNotificationComparator =>
jmap_tasks_types::TaskNotificationComparatorProperty::Other,
);
pub(crate) fn check_map_key_ids(
entry: &Map<String, Value>,
property: &str,
) -> Result<(), Box<jmap_server::SetError>> {
let prefix = format!("{property}/");
let map_keys = entry
.get(property)
.and_then(Value::as_object)
.into_iter()
.flat_map(|m| m.keys().map(String::as_str));
let path_ids = entry
.keys()
.filter_map(|k| k.strip_prefix(&prefix))
.map(|rest| rest.split_once('/').map_or(rest, |(id, _)| id));
for raw in map_keys.chain(path_ids) {
jmap_server::parse_wire_id(raw, property)?;
}
Ok(())
}
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"
}