#![allow(async_fn_in_trait)]
#![deny(clippy::await_holding_lock)]
mod history;
use std::cmp::Ordering;
use std::collections::{BTreeSet, HashMap, HashSet};
use std::marker::PhantomData;
use crate::{TaskQueryArgs, TasksBackend};
use jmap_metadata_server::{
ChangedProperties, MetadataCondition, MetadataFilterError, MetadataOnlyChanges, SetKind,
changed_properties, check_metadata_depth, check_metadata_write, is_metadata_property,
metadata_path_exists, metadata_text_contains, metadata_text_equals,
};
use jmap_metadata_types::{DataTypeMetadataInfo, MetadataTextMatch};
use jmap_object_history_server::{ChangeEvent, ChangeKind, fold_restore};
use jmap_server::{
AddedItem, BackendChangesError, BackendQueryError, BackendSetError, ChangesResult, GetObject,
JmapAccounts, JmapObject, JmapReads, MemoryCaller, QueryChangesParams, QueryChangesResult,
QueryObject, QueryParams, QueryResult, SetError, SetErrorType, SetObject,
};
use jmap_server::{
BeginSetError, ConditionalBackend, PatchPathError, ScopedState, SetScope, SetScopeRequest,
apply_patch_object, check_patch_paths, limit_or_max, resolve_query_start,
};
use jmap_tasks_types::{
Task, TaskComparator, TaskComparatorProperty, TaskFilterCondition, TaskList,
};
use jmap_types::{Id, JmapError, State};
#[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
}
pub(crate) fn serde(context: impl std::fmt::Display, e: &serde_json::Error) -> Self {
Self::new(format!("{context}: serde_json {:?} error", e.classify()))
}
}
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 {}
#[derive(Debug, Clone, Copy)]
enum IdFate {
Created,
Updated,
Destroyed,
}
#[derive(Clone, Debug)]
struct ChangeEntry {
new_state: u64,
created: Vec<Id>,
updated: Vec<Id>,
destroyed: Vec<Id>,
updated_props: Option<BTreeSet<String>>,
restored: Vec<Id>,
}
impl ChangeEntry {
fn is_metadata_only_update(&self) -> bool {
self.created.is_empty()
&& self.destroyed.is_empty()
&& self.updated_props.as_ref().is_some_and(|props| {
!props.is_empty() && props.iter().all(|p| is_metadata_property(p))
})
}
}
#[derive(Default, Clone)]
struct AccountAux {
task_list_refcount: HashMap<Id, u64>,
}
#[derive(Default, Clone)]
struct Inner {
objects: HashMap<&'static str, HashMap<String, HashMap<Id, serde_json::Value>>>,
states: HashMap<&'static str, HashMap<String, u64>>,
change_log: HashMap<&'static str, HashMap<String, Vec<ChangeEntry>>>,
aux: HashMap<String, AccountAux>,
known_accounts: HashSet<String>,
metadata_info: HashMap<&'static str, DataTypeMetadataInfo>,
history: Option<jmap_object_history_server::HistoryStore>,
}
impl Inner {
fn current_state(&self, type_name: &'static str, account_id: &str) -> u64 {
self.states
.get(type_name)
.and_then(|m| m.get(account_id))
.copied()
.unwrap_or(0)
}
fn bump_state(&mut self, type_name: &'static str, account_id: &str) -> u64 {
let entry = self
.states
.entry(type_name)
.or_default()
.entry(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.objects
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default()
}
fn require_account(&self, account_id: &str) -> Result<(), BackendSetError<MemoryError>> {
if self.known_accounts.contains(account_id) {
Ok(())
} else {
Err(BackendSetError::Other(MemoryError::new(format!(
"unknown account {account_id:?}"
))))
}
}
fn require_account_for_target(
&self,
account_id: &str,
) -> Result<(), BackendSetError<MemoryError>> {
if self.known_accounts.contains(account_id) {
Ok(())
} else {
Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))))
}
}
fn objects_ref(
&self,
type_name: &'static str,
account_id: &str,
) -> Option<&HashMap<Id, serde_json::Value>> {
self.objects.get(type_name).and_then(|m| m.get(account_id))
}
fn change_log_mut(
&mut self,
type_name: &'static str,
account_id: &str,
) -> &mut Vec<ChangeEntry> {
self.change_log
.entry(type_name)
.or_default()
.entry(account_id.to_owned())
.or_default()
}
fn aux_mut(&mut self, account_id: &str) -> &mut AccountAux {
self.aux.entry(account_id.to_owned()).or_default()
}
fn aux_ref(&self, account_id: &str) -> Option<&AccountAux> {
self.aux.get(account_id)
}
fn workflow_statuses(&mut self, account_id: &str, list_id: Option<&Id>) -> Option<Vec<String>> {
let list = self
.objects_mut(TaskList::TYPE_NAME, account_id)
.get(list_id?)?;
serde_json::from_value(list.get("workflowStatuses")?.clone()).ok()
}
fn apply_workflow(
&mut self,
account_id: &str,
task: &mut serde_json::Value,
write: crate::workflow::WorkflowWrite<'_>,
) -> Result<bool, BackendSetError<MemoryError>> {
let list = Self::task_list_id_of(task);
let statuses = self.workflow_statuses(account_id, list.as_ref());
let serde_json::Value::Object(map) = task else {
return Ok(false);
};
crate::workflow::apply_workflow_status(
map,
write,
statuses.as_deref(),
jmap_server::now_utc_string().as_ref(),
)
.map_err(BackendSetError::SetError)
}
fn task_list_id_of(task: &serde_json::Value) -> Option<Id> {
task.get("taskListId")
.and_then(|v| v.as_str())
.map(Id::from)
}
fn inc_task_ref(&mut self, account_id: &str, list_id: Option<Id>) {
if let Some(id) = list_id {
*self
.aux_mut(account_id)
.task_list_refcount
.entry(id)
.or_insert(0) += 1;
}
}
fn dec_task_ref(&mut self, account_id: &str, list_id: Option<Id>) {
let Some(id) = list_id else { return };
let aux = self.aux_mut(account_id);
if let Some(count) = aux.task_list_refcount.get_mut(&id) {
*count = count.saturating_sub(1);
if *count == 0 {
aux.task_list_refcount.remove(&id);
}
}
}
}
#[non_exhaustive]
pub struct MemoryBackend<C = Id> {
inner: ScopedState<Inner>,
caller: PhantomData<fn() -> C>,
}
impl<C> Default for MemoryBackend<C> {
fn default() -> Self {
Self {
inner: ScopedState::default(),
caller: PhantomData,
}
}
}
impl<C> Clone for MemoryBackend<C> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
caller: PhantomData,
}
}
}
impl MemoryBackend {
pub fn new() -> Self {
Self::default()
}
}
impl<C: MemoryCaller> MemoryBackend<C> {
#[must_use]
pub fn with_account(self, account_id: &Id) -> Self {
self.register_account(account_id);
self
}
#[must_use]
pub fn with_metadata_info(self, data_type: &str, info: DataTypeMetadataInfo) -> Self {
let type_name = metadata_type_name(data_type).unwrap_or_else(|| {
panic!("MemoryBackend supports metadata only on TaskList and Task, not {data_type:?}")
});
assert!(
!info.supports_private,
"MemoryBackend does not support privateMetadata (supportsPrivate must be false)"
);
self.inner
.lock_unscoped()
.metadata_info
.insert(type_name, info);
self
}
#[doc(hidden)]
pub fn register_account(&self, account_id: &Id) {
debug_assert!(
!account_id.as_ref().is_empty(),
"register_account: account_id must not be the empty string \
(RFC 8620 §1.2, bd:JMAP-dx0s)"
);
let mut inner = self.inner.lock_unscoped();
inner.known_accounts.insert(account_id.as_ref().to_owned());
inner.aux.entry(account_id.as_ref().to_owned()).or_default();
}
pub fn seed_object(
&self,
account_id: &Id,
type_name: &'static str,
id: &Id,
value: serde_json::Value,
) {
const KNOWN_TYPES: &[&str] = &[
jmap_tasks_types::TaskList::TYPE_NAME,
jmap_tasks_types::Task::TYPE_NAME,
jmap_tasks_types::TaskNotification::TYPE_NAME,
];
assert!(
KNOWN_TYPES.contains(&type_name),
"seed_object: type_name {type_name:?} is not one of the known \
TYPE_NAME values {KNOWN_TYPES:?}"
);
let obj = value.as_object().unwrap_or_else(|| {
panic!("seed_object: value must be a JSON object with an `id` field, got {value:?}")
});
let value_id = obj
.get("id")
.and_then(serde_json::Value::as_str)
.unwrap_or_else(|| {
panic!(
"seed_object: value must contain an `id` string field; got value = {value:?}"
)
});
assert_eq!(
value_id,
id.as_ref(),
"seed_object: value's `id` field {value_id:?} does not match the \
`id` argument {id:?}"
);
let account_id = account_id.as_ref();
let mut inner = self.inner.lock_unscoped();
inner.known_accounts.insert(account_id.to_owned());
let list_id = if type_name == "Task" {
Inner::task_list_id_of(&value)
} else {
None
};
let prev = inner
.objects_mut(type_name, account_id)
.insert(id.clone(), value);
if type_name == "Task" {
if let Some(old) = prev.as_ref() {
inner.dec_task_ref(account_id, Inner::task_list_id_of(old));
}
inner.inc_task_ref(account_id, list_id);
}
}
}
impl<C: MemoryCaller> JmapAccounts for MemoryBackend<C> {
type Error = MemoryError;
type CallerCtx = C;
fn principal_id(caller: &C) -> Option<&Id> {
caller.principal()
}
fn metadata_info<O: JmapObject>(
&self,
_caller: &C,
_account_id: &Id,
) -> Option<DataTypeMetadataInfo> {
self.inner
.lock_unscoped()
.metadata_info
.get(O::TYPE_NAME)
.cloned()
}
async fn account_exists(&self, _caller: &C, account_id: &Id) -> Result<bool, Self::Error> {
let inner = self.inner.lock().await;
Ok(inner.known_accounts.contains(account_id.as_ref()))
}
}
impl<C: MemoryCaller> JmapReads for MemoryBackend<C> {
async fn get_objects<O: GetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
ids: Option<&[Id]>,
_properties: Option<&[String]>,
) -> Result<(Vec<O>, Vec<Id>), Self::Error> {
let inner = self.inner.lock().await;
let map = inner.objects_ref(O::TYPE_NAME, account_id.as_ref());
let deser_err = |e: serde_json::Error| {
MemoryError::serde(format_args!("deserialize {}", O::TYPE_NAME), &e)
};
match ids {
None => {
let list = map
.map(|m| {
m.values()
.map(|val| O::deserialize(val).map_err(deser_err))
.collect::<Result<Vec<_>, _>>()
})
.transpose()?
.unwrap_or_default();
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) => found.push(O::deserialize(val).map_err(deser_err)?),
None => not_found.push(id.clone()),
}
}
Ok((found, not_found))
}
}
}
async fn get_state<O: JmapObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
) -> Result<State, Self::Error> {
let inner = self.inner.lock().await;
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: &C,
account_id: &Id,
params: jmap_server::ChangesParams<'_>,
) -> Result<ChangesResult, BackendChangesError<Self::Error>> {
let since_state = params.since_state;
let max_changes = params.max_changes;
let mode = if params.ignore_metadata_only_changes {
MetadataOnlyChanges::Ignore
} else {
MetadataOnlyChanges::Report
};
let inner = self.inner.lock().await;
let since_n: u64 = since_state
.as_ref()
.parse()
.map_err(|_| BackendChangesError::CannotCalculate)?;
let log = inner
.change_log
.get(O::TYPE_NAME)
.and_then(|m| m.get(account_id.as_ref()))
.map(Vec::as_slice)
.unwrap_or(&[]);
let mut 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());
let mut has_more = false;
if let Some(max) = max_changes {
let mut ids = 0u64;
if let Some(cut) = relevant.iter().position(|e| {
if !(mode == MetadataOnlyChanges::Ignore && e.is_metadata_only_update()) {
ids +=
(e.created.len() + e.updated.len() + e.destroyed.len() + e.restored.len())
as u64;
}
ids > max
}) {
if cut == 0 {
return Err(BackendChangesError::TooManyChanges { limit: max });
}
relevant.truncate(cut);
has_more = true;
}
}
let new_state = match relevant.last() {
Some(e) if has_more => e.new_state,
_ => current_state,
};
let mut fates: HashMap<Id, IdFate> = HashMap::new();
let mut order: Vec<Id> = Vec::new();
let mut window_props = ChangedProperties::new();
for entry in &relevant {
for id in &entry.created {
if fates.insert(id.clone(), IdFate::Created).is_none() {
order.push(id.clone());
}
}
for id in &entry.updated {
window_props.record(id.as_ref(), entry.updated_props.as_ref());
let fate = match fates.get(id) {
Some(IdFate::Created) => IdFate::Created,
Some(IdFate::Destroyed) => IdFate::Destroyed,
_ => IdFate::Updated,
};
if fates.insert(id.clone(), fate).is_none() {
order.push(id.clone());
}
}
for id in &entry.destroyed {
if matches!(fates.get(id), Some(IdFate::Created)) {
fates.remove(id);
} else if fates.insert(id.clone(), IdFate::Destroyed).is_none() {
order.push(id.clone());
}
}
}
let mut events: HashMap<Id, Vec<ChangeEvent>> = HashMap::new();
for entry in &relevant {
for (ids, event) in [
(&entry.created, ChangeEvent::Created),
(&entry.updated, ChangeEvent::Updated),
(&entry.destroyed, ChangeEvent::Destroyed),
(&entry.restored, ChangeEvent::Restored),
] {
for id in ids {
events.entry(id.clone()).or_default().push(event);
}
}
}
for (id, list) in &events {
if !list.contains(&ChangeEvent::Restored) {
continue;
}
let fate = match fold_restore(list) {
Some(ChangeKind::Created) => IdFate::Created,
Some(ChangeKind::Destroyed) => IdFate::Destroyed,
Some(_) => {
window_props.record(id.as_ref(), None);
IdFate::Updated
}
None => {
fates.remove(id);
continue;
}
};
if fates.insert(id.clone(), fate).is_none() {
order.push(id.clone());
}
}
let mut created: Vec<Id> = Vec::new();
let mut updated: Vec<Id> = Vec::new();
let mut destroyed: Vec<Id> = Vec::new();
for id in order {
match fates.remove(&id) {
Some(IdFate::Created) => created.push(id),
Some(IdFate::Updated)
if mode == MetadataOnlyChanges::Ignore
&& window_props.is_metadata_only(id.as_ref()) => {}
Some(IdFate::Updated) => updated.push(id),
Some(IdFate::Destroyed) => destroyed.push(id),
None => {}
}
}
let updated_properties = window_props.updated_properties(&updated, mode, &[]);
Ok(ChangesResult::new(
created,
updated,
destroyed,
has_more,
State::from(new_state.to_string()),
)
.with_updated_properties(updated_properties))
}
async fn query_objects<O: QueryObject + Send + Sync>(
&self,
caller: &C,
account_id: &Id,
params: QueryParams<'_, O>,
) -> Result<QueryResult, BackendQueryError<Self::Error>> {
self.query_impl(caller, account_id, params, &TaskQueryArgs::default())
.await
}
async fn query_changes<O: QueryObject + Send + Sync>(
&self,
caller: &C,
account_id: &Id,
params: QueryChangesParams<'_, O>,
) -> Result<QueryChangesResult, BackendChangesError<Self::Error>> {
let QueryChangesParams {
since_query_state,
filter,
sort,
max_changes,
..
} = params;
let changes = self
.get_changes::<O>(
caller,
account_id,
jmap_server::ChangesParams::new(since_query_state).max_changes(max_changes),
)
.await?;
let current = self
.query_objects::<O>(
caller,
account_id,
QueryParams::new().filter(filter).sort(sort),
)
.await
.map_err(|e| match e {
BackendQueryError::Other(e) => BackendChangesError::Other(e),
_ => BackendChangesError::CannotCalculate,
})?;
let created_set: HashSet<&Id> = changes.created.iter().collect();
let updated_set: HashSet<&Id> = changes.updated.iter().collect();
let mut removed: Vec<Id> = changes
.destroyed
.iter()
.chain(changes.updated.iter())
.cloned()
.collect();
removed.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
removed.dedup();
let added: Vec<AddedItem> = current
.ids
.iter()
.enumerate()
.filter(|(_, id)| created_set.contains(id) || updated_set.contains(id))
.map(|(pos, id)| AddedItem::new(id.clone(), pos as u64))
.collect();
Ok(QueryChangesResult::new(
since_query_state.clone(),
changes.new_state,
current.total,
removed,
added,
))
}
}
fn metadata_type_name(data_type: &str) -> Option<&'static str> {
[TaskList::TYPE_NAME, Task::TYPE_NAME]
.into_iter()
.find(|t| *t == data_type)
}
fn invalid_metadata_property(property: &str, description: &str) -> BackendSetError<MemoryError> {
BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties([property])
.with_description(description),
))
}
impl Inner {
fn check_metadata_set(
&self,
type_name: &'static str,
account_id: &str,
kind: SetKind,
entry: &serde_json::Map<String, serde_json::Value>,
stored: Option<&serde_json::Map<String, serde_json::Value>>,
containers: &[&str],
) -> Result<Option<DataTypeMetadataInfo>, BackendSetError<MemoryError>> {
let Some(first) = entry.keys().find(|k| crate::helpers::is_metadata_key(k)) else {
return Ok(None);
};
let Some(info) = self.metadata_info.get(type_name) else {
return Err(invalid_metadata_property(
first,
"metadata is not supported on this data type",
));
};
let writes_shared = entry.keys().any(|k| {
crate::helpers::is_metadata_key(k)
&& k.split_once('/').map_or(k.as_str(), |(root, _)| root) == "metadata"
});
let denies = |rights: Option<&serde_json::Value>| {
rights
.and_then(|r| r.get("maySetMetadata"))
.and_then(serde_json::Value::as_bool)
== Some(false)
};
let forbidden = writes_shared
&& if type_name == TaskList::TYPE_NAME {
denies(stored.and_then(|l| l.get("myRights")))
} else {
let lists = self.objects_ref(TaskList::TYPE_NAME, account_id);
containers.iter().any(|id| {
denies(
lists
.and_then(|l| l.get(*id))
.and_then(|list| list.get("myRights")),
)
})
};
if forbidden {
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::Forbidden)
.with_description("maySetMetadata is required to write metadata"),
)));
}
check_metadata_write(kind, entry, stored, info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
Ok(Some(info.clone()))
}
}
fn task_update_containers<'a>(
stored: &'a serde_json::Map<String, serde_json::Value>,
patch: &'a serde_json::Map<String, serde_json::Value>,
) -> Vec<&'a str> {
[stored.get("taskListId"), patch.get("taskListId")]
.into_iter()
.flatten()
.filter_map(serde_json::Value::as_str)
.collect()
}
fn check_metadata_create(
inner: &Inner,
type_name: &'static str,
account_id: &str,
supplied: &serde_json::Value,
val: &serde_json::Value,
) -> Result<(), BackendSetError<MemoryError>> {
let (Some(type_name), Some(supplied), Some(obj)) = (
metadata_type_name(type_name),
supplied.as_object(),
val.as_object(),
) else {
return Ok(());
};
let entry: serde_json::Map<String, serde_json::Value> = supplied
.iter()
.filter(|(k, _)| is_metadata_property(k))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
let containers: Vec<&str> = if type_name == Task::TYPE_NAME {
obj.get("taskListId")
.and_then(serde_json::Value::as_str)
.into_iter()
.collect()
} else {
Vec::new()
};
if let Some(info) = inner.check_metadata_set(
type_name,
account_id,
SetKind::Create,
&entry,
None,
&containers,
)? {
check_metadata_depth(&entry, obj, &info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
}
Ok(())
}
const METADATA_CONDITION_KEYS: [&str; 6] = [
"metadataExists",
"privateMetadataExists",
"metadataTextContains",
"privateMetadataTextContains",
"metadataTextEquals",
"privateMetadataTextEquals",
];
const SHARED_METADATA_CONDITION_KEYS: [&str; 3] = [
"metadataExists",
"metadataTextContains",
"metadataTextEquals",
];
const TASK_CONDITION_KEYS: [&str; 5] = [
"inTaskLists",
"workflowStatus",
"progress",
"after",
"before",
];
fn task_matches(
c: &TaskFilterCondition,
task: &serde_json::Value,
query_zone: &str,
) -> Result<bool, BackendQueryError<MemoryError>> {
let str_of = |key: &str| task.get(key).and_then(serde_json::Value::as_str);
if let Some(lists) = &c.in_task_lists
&& !str_of("taskListId").is_some_and(|l| lists.iter().any(|id| id.as_ref() == l))
{
return Ok(false);
}
if let Some(status) = &c.workflow_status
&& str_of("workflowStatus") != Some(status.as_str())
{
return Ok(false);
}
if let Some(progress) = &c.progress
&& str_of("progress") != Some(progress.as_str())
{
return Ok(false);
}
if c.after.is_some() || c.before.is_some() {
if str_of("timeZone").is_some_and(|z| z != query_zone) {
let mut err = JmapError::unsupported_filter();
err.description = Some(
"after/before on a task in another time zone needs a time-zone database".to_owned(),
);
return Err(BackendQueryError::Method(err));
}
let (start, due) = (str_of("start"), str_of("due"));
if let Some(after) = &c.after
&& !due.or(start).is_some_and(|end| end > after.as_ref())
{
return Ok(false);
}
if let Some(before) = &c.before
&& !start.or(due).is_some_and(|begin| begin < before.as_ref())
{
return Ok(false);
}
}
Ok(metadata_matches(
task.get("metadata").and_then(serde_json::Value::as_object),
c.metadata_exists.as_deref(),
c.metadata_text_contains.as_ref(),
c.metadata_text_equals.as_ref(),
))
}
fn task_sort<C: serde::Serialize>(
sort: &[C],
) -> Result<Vec<TaskComparator>, BackendQueryError<MemoryError>> {
sort.iter()
.map(|c| {
let v = jmap_server::serialize_value(c).map_err(BackendQueryError::Method)?;
let c: TaskComparator = serde_json::from_value(v)
.map_err(|e| BackendQueryError::Method(JmapError::server_fail(e.to_string())))?;
let known = matches!(
c.property,
TaskComparatorProperty::Id
| TaskComparatorProperty::Uid
| TaskComparatorProperty::Start
| TaskComparatorProperty::Created
| TaskComparatorProperty::Updated
);
if known && text_cmp(c.collation.as_deref(), "", "").is_some() {
Ok(c)
} else {
Err(BackendQueryError::Method(JmapError::unsupported_sort()))
}
})
.collect()
}
fn text_cmp(collation: Option<&str>, a: &str, b: &str) -> Option<Ordering> {
match collation {
None | Some("i;octet") => Some(a.cmp(b)),
Some("i;ascii-casemap") => Some(a.to_ascii_lowercase().cmp(&b.to_ascii_lowercase())),
Some("i;unicode-casemap") => Some(a.to_lowercase().cmp(&b.to_lowercase())),
Some(_) => None,
}
}
fn check_one_start_zone(
matched: &[(&Id, &serde_json::Value)],
query_zone: &str,
) -> Result<(), BackendQueryError<MemoryError>> {
let mut zones = matched
.iter()
.filter(|(_, t)| t.get("start").is_some_and(serde_json::Value::is_string))
.map(|(_, t)| {
t.get("timeZone")
.and_then(serde_json::Value::as_str)
.unwrap_or(query_zone)
});
let first = zones.next();
if zones.any(|z| Some(z) != first) {
let mut err = JmapError::unsupported_sort();
err.description = Some(
"sorting tasks in several time zones by start needs a time-zone database".to_owned(),
);
return Err(BackendQueryError::Method(err));
}
Ok(())
}
fn compare_tasks(
comparators: &[TaskComparator],
(a_id, a): &(&Id, &serde_json::Value),
(b_id, b): &(&Id, &serde_json::Value),
) -> Ordering {
for c in comparators {
let text = |id: &Id, t: &serde_json::Value| -> Option<String> {
let s = |k: &str| t.get(k).and_then(serde_json::Value::as_str);
match c.property {
TaskComparatorProperty::Id => Some(id.as_ref().to_owned()),
TaskComparatorProperty::Uid => s("uid").map(str::to_owned),
TaskComparatorProperty::Start => s("start").map(str::to_owned),
TaskComparatorProperty::Created => {
s("created").map(|v| v.trim_end_matches('Z').to_owned())
}
TaskComparatorProperty::Updated => {
s("updated").map(|v| v.trim_end_matches('Z').to_owned())
}
_ => None,
}
};
let is_text = matches!(
c.property,
TaskComparatorProperty::Id | TaskComparatorProperty::Uid
);
let ord = match (text(a_id, a), text(b_id, b)) {
(Some(x), Some(y)) if is_text => {
text_cmp(c.collation.as_deref(), &x, &y).unwrap_or(Ordering::Equal)
}
(Some(x), Some(y)) => x.cmp(&y),
(Some(_), None) => Ordering::Less,
(None, Some(_)) => Ordering::Greater,
(None, None) => Ordering::Equal,
};
let ord = if c.is_ascending { ord } else { ord.reverse() };
if ord != Ordering::Equal {
return ord;
}
}
a_id.as_ref().cmp(b_id.as_ref())
}
fn is_recurring(task: &serde_json::Value) -> bool {
let non_empty = |key: &str| match task.get(key) {
Some(serde_json::Value::Array(a)) => !a.is_empty(),
Some(serde_json::Value::Object(o)) => !o.is_empty(),
_ => false,
};
non_empty("recurrenceRules") || non_empty("recurrenceOverrides")
}
fn check_metadata_filter(
filter: &serde_json::Value,
info: Option<&DataTypeMetadataInfo>,
) -> Result<(), BackendQueryError<MemoryError>> {
let unsupported = |description: String| {
let mut err = JmapError::unsupported_filter();
err.description = Some(description);
BackendQueryError::Method(err)
};
if filter.get("operator").is_some() {
return filter
.get("conditions")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
.try_for_each(|f| check_metadata_filter(f, info));
}
let Some(leaf) = filter.as_object() else {
return Ok(());
};
if !METADATA_CONDITION_KEYS
.iter()
.any(|k| leaf.get(*k).is_some_and(|v| !v.is_null()))
{
return Ok(());
}
let Some(info) = info else {
return Err(unsupported(
"metadata filter conditions are not supported".to_owned(),
));
};
MetadataCondition::take_from(&mut leaf.clone(), info)
.map(drop)
.map_err(|e| match e {
MetadataFilterError::InvalidArguments(d) => {
BackendQueryError::Method(JmapError::invalid_arguments(d))
}
other => unsupported(other.to_string()),
})
}
fn metadata_matches(
metadata: Option<&serde_json::Map<String, serde_json::Value>>,
exists: Option<&str>,
contains: Option<&MetadataTextMatch>,
equals: Option<&MetadataTextMatch>,
) -> bool {
let empty = serde_json::Map::new();
let metadata = metadata.unwrap_or(&empty);
exists.is_none_or(|p| metadata_path_exists(metadata, p))
&& contains.is_none_or(|m| metadata_text_contains(metadata, m))
&& equals.is_none_or(|m| metadata_text_equals(metadata, m))
}
fn with_id<O: SetObject>(obj: &O, id: &Id) -> Result<O, BackendSetError<MemoryError>> {
let mut val = serde_json::to_value(obj)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize copied object", &e)))?;
if let Some(map) = val.as_object_mut() {
map.insert(
"id".to_owned(),
serde_json::Value::String(id.as_ref().to_owned()),
);
}
serde_json::from_value(val)
.map_err(|e| BackendSetError::Other(MemoryError::serde("deserialize copied object", &e)))
}
impl<C: MemoryCaller> MemoryBackend<C> {
async fn store_created<O: SetObject>(
&self,
account_id: &Id,
build: impl FnOnce(&Id) -> Result<O, BackendSetError<MemoryError>>,
supplied: Option<&serde_json::Value>,
) -> Result<(Id, O), BackendSetError<MemoryError>> {
let server_id = Id::from(uuid::Uuid::new_v4().to_string());
let mut stored_obj = build(&server_id)?;
let mut val = serde_json::to_value(&stored_obj)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize", &e)))?;
let mut inner = self.inner.lock().await;
if O::TYPE_NAME == Task::TYPE_NAME
&& inner.apply_workflow(
account_id.as_ref(),
&mut val,
crate::workflow::WorkflowWrite::Create,
)?
{
stored_obj = O::deserialize(&val)
.map_err(|e| BackendSetError::Other(MemoryError::serde("deserialize", &e)))?;
}
debug_assert!(!inner.history_retains(O::TYPE_NAME, account_id, &server_id));
check_metadata_create(
&inner,
O::TYPE_NAME,
account_id.as_ref(),
supplied.unwrap_or(&val),
&val,
)?;
inner.require_account(account_id.as_ref())?;
let task_list_id = if O::TYPE_NAME == "Task" {
Inner::task_list_id_of(&val)
} else {
None
};
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![],
restored: vec![],
updated_props: None,
});
if O::TYPE_NAME == "Task" {
inner.inc_task_ref(account_id.as_ref(), task_list_id);
}
Ok((server_id, stored_obj))
}
}
impl<C: MemoryCaller> MemoryBackend<C> {
async fn query_impl<O: QueryObject + Send + Sync>(
&self,
caller: &C,
account_id: &Id,
params: QueryParams<'_, O>,
task_args: &TaskQueryArgs,
) -> Result<QueryResult, BackendQueryError<MemoryError>> {
let QueryParams {
filter,
sort,
limit,
position,
anchor,
anchor_offset,
..
} = params;
let inner = self.inner.lock().await;
let is_task = O::TYPE_NAME == Task::TYPE_NAME;
let mut task_condition: Option<TaskFilterCondition> = None;
if let Some(f) = filter {
let v = jmap_server::serialize_value(f).map_err(BackendQueryError::Method)?;
check_metadata_filter(&v, inner.metadata_info.get(O::TYPE_NAME))?;
if v.get("operator").is_some() {
return Err(BackendQueryError::Method(JmapError::unsupported_filter()));
}
let any_field_set = match v.as_object() {
Some(m) => m.iter().any(|(k, val)| {
!val.is_null()
&& !(is_task
&& (TASK_CONDITION_KEYS.contains(&k.as_str())
|| SHARED_METADATA_CONDITION_KEYS.contains(&k.as_str())))
}),
None => true,
};
if any_field_set {
return Err(BackendQueryError::Method(JmapError::unsupported_filter()));
}
if is_task {
task_condition = Some(serde_json::from_value(v).map_err(|e| {
BackendQueryError::Method(JmapError::server_fail(e.to_string()))
})?);
}
}
let comparators = match sort.filter(|s| !s.is_empty()) {
None => Vec::new(),
Some(s) if is_task => task_sort(s)?,
Some(_) => return Err(BackendQueryError::Method(JmapError::unsupported_sort())),
};
let query_zone = task_args.time_zone.as_deref().unwrap_or("Etc/UTC");
let mut matched: Vec<(&Id, &serde_json::Value)> = Vec::new();
if let Some(objects) = inner.objects_ref(O::TYPE_NAME, account_id.as_ref()) {
for (id, v) in objects {
let keep = match &task_condition {
None => true,
Some(c) => task_matches(c, v, query_zone)?,
};
if keep {
matched.push((id, v));
}
}
}
if is_task && task_args.expand_recurrences {
let too_long = task_condition
.as_ref()
.and_then(crate::task::expand_duration_seconds)
.is_some_and(|secs| {
u64::try_from(secs).is_ok_and(|secs| {
secs > self
.limits(caller, account_id)
.max_expanded_query_duration_seconds
})
});
if too_long {
return Err(BackendQueryError::Method(JmapError::custom(
"expandDurationTooLarge",
)));
}
if matched.iter().any(|(_, v)| is_recurring(v)) {
return Err(BackendQueryError::Method(JmapError::custom(
"cannotCalculateOccurrences",
)));
}
}
if comparators
.iter()
.any(|c| c.property == TaskComparatorProperty::Start)
{
check_one_start_zone(&matched, query_zone)?;
}
matched.sort_by(|a, b| compare_tasks(&comparators, a, b));
let ids: Vec<Id> = matched.into_iter().map(|(k, _)| k.clone()).collect();
let total = ids.len() as u64;
let query_state = State::from(
inner
.current_state(O::TYPE_NAME, account_id.as_ref())
.to_string()
.as_str(),
);
let start = resolve_query_start(&ids, position, anchor, anchor_offset)
.map_err(BackendQueryError::Method)?;
let ids: Vec<Id> = ids[start..]
.iter()
.take(limit_or_max(limit))
.cloned()
.collect();
Ok(QueryResult::new(
ids,
start as u64,
Some(total),
query_state,
true,
))
}
}
impl<C: MemoryCaller> TasksBackend for MemoryBackend<C> {
async fn create_object<O, F>(
&self,
_caller: &C,
account_id: &Id,
_create_id: &str,
build: F,
) -> Result<(Id, O), BackendSetError<Self::Error>>
where
O: SetObject + Send + Sync,
F: FnOnce(&Id) -> O + Send,
{
self.store_created(account_id, |id| Ok(build(id)), None)
.await
}
async fn copy_object<O: SetObject + Send + Sync>(
&self,
_caller: &C,
_from_account_id: &Id,
to_account_id: &Id,
obj: O,
create: &serde_json::Value,
) -> Result<(Id, O), BackendSetError<Self::Error>> {
self.store_created(to_account_id, |id| with_id(&obj, id), Some(create))
.await
}
async fn update_object<O: SetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
id: &Id,
patch: O::Patch,
) -> Result<Option<O>, BackendSetError<Self::Error>> {
let patch_val = serde_json::to_value(&patch)
.map_err(|e| BackendSetError::Other(MemoryError::serde("serialize patch", &e)))?;
let invalid_patch = |e: PatchPathError| {
BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
))
};
if let serde_json::Value::Object(patch_map) = &patch_val {
check_patch_paths(patch_map).map_err(invalid_patch)?;
}
let mut inner = self.inner.lock().await;
inner.require_account_for_target(account_id.as_ref())?;
let existing = inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.get(id)
.cloned();
let Some(mut current) = existing else {
return Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
))));
};
let previous = current.clone();
let was_draft = current.get("isDraft").and_then(|v| v.as_bool()) == Some(true);
let old_task_list_id = if O::TYPE_NAME == "Task" {
Inner::task_list_id_of(¤t)
} else {
None
};
let mut updated_props = None;
if let (serde_json::Value::Object(base), serde_json::Value::Object(patch_map)) =
(&mut current, &patch_val)
{
let metadata_info = if metadata_type_name(O::TYPE_NAME).is_some() {
let containers = if O::TYPE_NAME == Task::TYPE_NAME {
task_update_containers(base, patch_map)
} else {
Vec::new()
};
inner.check_metadata_set(
O::TYPE_NAME,
account_id.as_ref(),
SetKind::Update,
patch_map,
Some(base),
&containers,
)?
} else {
None
};
if metadata_info.is_some() {
base.entry("metadata")
.or_insert_with(|| serde_json::Value::Object(serde_json::Map::new()));
}
let before = base.clone();
apply_patch_object(base, patch_map).map_err(invalid_patch)?;
if let Some(info) = &metadata_info {
for property in ["metadata", "privateMetadata"] {
if patch_map
.get(property)
.is_some_and(serde_json::Value::is_null)
{
base.insert(
property.to_owned(),
serde_json::Value::Object(serde_json::Map::new()),
);
}
}
check_metadata_depth(patch_map, base, info)
.map_err(|e| invalid_metadata_property(e.property(), e.description()))?;
}
updated_props = Some(changed_properties(&before, base));
}
if let Err(e) = O::deserialize(¤t) {
let mut heads: Vec<String> = patch_val
.as_object()
.into_iter()
.flat_map(|m| m.keys())
.map(|k| {
let head = k.split('/').next().unwrap_or(k);
head.replace("~1", "/").replace("~0", "~")
})
.collect();
heads.sort_unstable();
heads.dedup();
let mut err =
SetError::new(SetErrorType::InvalidProperties).with_description(e.to_string());
if heads.len() == 1 {
err = err.with_properties(heads);
}
return Err(BackendSetError::SetError(Box::new(err)));
}
if O::TYPE_NAME == "Task"
&& !was_draft
&& current.get("isDraft").and_then(|v| v.as_bool()) == Some(true)
{
return Err(BackendSetError::SetError(Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties(vec!["isDraft".to_owned()]),
)));
}
let mut echo = false;
if O::TYPE_NAME == Task::TYPE_NAME {
let written: Vec<String> = patch_val
.as_object()
.into_iter()
.flat_map(|m| m.keys())
.map(|k| {
let head = k.split('/').next().unwrap_or(k);
head.replace("~1", "/").replace("~0", "~")
})
.collect();
let empty = serde_json::Map::new();
let before = previous.as_object().unwrap_or(&empty);
echo = inner.apply_workflow(
account_id.as_ref(),
&mut current,
crate::workflow::WorkflowWrite::Update {
before,
written: &written,
},
)?;
}
let new_task_list_id = if O::TYPE_NAME == "Task" {
Inner::task_list_id_of(¤t)
} else {
None
};
let echoed = if echo {
Some(
O::deserialize(¤t)
.map_err(|e| BackendSetError::Other(MemoryError::serde("deserialize", &e)))?,
)
} else {
None
};
inner.record_replace(O::TYPE_NAME, account_id, id, previous);
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![],
restored: vec![],
updated_props,
});
if O::TYPE_NAME == "Task" && old_task_list_id != new_task_list_id {
inner.dec_task_ref(account_id.as_ref(), old_task_list_id);
inner.inc_task_ref(account_id.as_ref(), new_task_list_id);
}
Ok(echoed)
}
async fn query_tasks(
&self,
caller: &C,
account_id: &Id,
params: QueryParams<'_, Task>,
args: &TaskQueryArgs,
) -> Result<QueryResult, BackendQueryError<Self::Error>> {
self.query_impl(caller, account_id, params, args).await
}
async fn update_task_per_user(
&self,
caller: &C,
account_id: &Id,
id: &Id,
patch: jmap_types::PatchObject,
) -> Result<Option<jmap_tasks_types::Task>, BackendSetError<Self::Error>> {
self.update_object::<jmap_tasks_types::Task>(caller, account_id, id, patch)
.await
}
async fn destroy_object<O: SetObject + Send + Sync>(
&self,
_caller: &C,
account_id: &Id,
id: &Id,
) -> Result<(), BackendSetError<Self::Error>> {
let mut inner = self.inner.lock().await;
inner.require_account_for_target(account_id.as_ref())?;
let removed = inner
.objects_mut(O::TYPE_NAME, account_id.as_ref())
.remove(id);
match removed {
Some(val) => {
inner.record_destroy(O::TYPE_NAME, account_id, id, val.clone());
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()],
restored: vec![],
updated_props: None,
});
if O::TYPE_NAME == "Task" {
inner.dec_task_ref(account_id.as_ref(), Inner::task_list_id_of(&val));
}
Ok(())
}
None => Err(BackendSetError::SetError(Box::new(SetError::new(
SetErrorType::NotFound,
)))),
}
}
fn supports_type<O: JmapObject>(&self, _caller: &C, _account_id: &jmap_types::Id) -> bool {
matches!(O::TYPE_NAME, "TaskList" | "Task" | "TaskNotification")
}
async fn task_list_has_tasks(
&self,
_caller: &C,
account_id: &Id,
task_list_id: &Id,
) -> Result<bool, MemoryError> {
let inner = self.inner.lock().await;
Ok(inner
.aux_ref(account_id.as_ref())
.is_some_and(|a| a.task_list_refcount.contains_key(task_list_id)))
}
}
impl<C: MemoryCaller> ConditionalBackend for MemoryBackend<C> {
async fn begin_set(
&self,
_caller: &C,
request: SetScopeRequest<'_>,
) -> Result<Box<dyn SetScope>, BeginSetError<MemoryError>> {
Ok(self
.inner
.open(request, |_: &Inner, _: &Inner| Vec::new())
.await)
}
}
#[cfg(test)]
mod memory_error_tests {
use super::MemoryError;
#[test]
fn serde_error_display_omits_offending_value() {
let canary = "alice@example.com";
let e = serde_json::from_value::<u64>(serde_json::Value::String(canary.into()))
.expect_err("a string is not a u64");
assert!(
e.to_string().contains(canary),
"precondition: serde_json quotes the value"
);
let shown = MemoryError::serde("decode", &e).to_string();
assert!(!shown.contains(canary), "canary leaked: {shown}");
assert!(
shown.contains("decode") && shown.contains("Data"),
"{shown}"
);
}
}
#[cfg(test)]
mod fixture_helper_tests {
use super::*;
use serde_json::json;
#[tokio::test]
async fn with_account_registers_account() {
let acc = Id::from("acc1");
let backend = MemoryBackend::<()>::default().with_account(&acc);
assert!(backend.account_exists(&(), &acc).await.unwrap());
assert!(
!backend
.account_exists(&(), &Id::from("acc2"))
.await
.unwrap()
);
}
#[tokio::test]
async fn seeded_task_marks_task_list_non_empty() {
let acc = Id::from("acc1");
let backend = MemoryBackend::<()>::default();
backend.seed_object(
&acc,
"Task",
&Id::from("t1"),
json!({"id": "t1", "taskListId": "tl1"}),
);
assert!(
backend
.task_list_has_tasks(&(), &acc, &Id::from("tl1"))
.await
.unwrap()
);
}
#[test]
#[should_panic(expected = "not one of the known")]
fn seed_object_rejects_unknown_type_name() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
"Tasklist",
&Id::from("tl1"),
json!({"id": "tl1"}),
);
}
#[test]
#[should_panic(expected = "must be a JSON object")]
fn seed_object_rejects_non_object_value() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
"TaskList",
&Id::from("tl1"),
json!(42),
);
}
#[test]
#[should_panic(expected = "must contain an `id` string field")]
fn seed_object_rejects_value_without_id_field() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
"TaskList",
&Id::from("tl1"),
json!({"name": "Work"}),
);
}
#[test]
#[should_panic(expected = "does not match the `id` argument")]
fn seed_object_rejects_id_mismatch() {
MemoryBackend::<()>::default().seed_object(
&Id::from("acc1"),
"TaskList",
&Id::from("tl1"),
json!({"id": "tl2"}),
);
}
}
#[cfg(all(test, debug_assertions))]
mod empty_account_id_tests {
use super::{Id, MemoryBackend};
#[test]
#[should_panic(expected = "account_id must not be the empty string")]
fn register_account_rejects_empty_id() {
MemoryBackend::<()>::default().register_account(&Id::from(""));
}
}
#[cfg(test)]
mod changes_tests {
use super::*;
use jmap_tasks_types::Task;
#[tokio::test]
async fn get_changes_dedups_ids_across_window() {
let backend = MemoryBackend::<()>::default();
let id = |s: &str| Id::from(s);
{
let mut inner = backend.inner.lock_unscoped();
let log = inner.change_log_mut(Task::TYPE_NAME, "acc1");
log.push(ChangeEntry {
new_state: 1,
created: vec![id("eph"), id("fresh")],
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 2,
created: vec![],
updated: vec![id("fresh"), id("old"), id("doomed")],
destroyed: vec![id("eph")],
restored: vec![],
updated_props: None,
});
log.push(ChangeEntry {
new_state: 3,
created: vec![],
updated: vec![id("old")],
destroyed: vec![id("doomed"), id("gone")],
restored: vec![],
updated_props: None,
});
}
let changes = backend
.get_changes::<Task>(
&(),
&id("acc1"),
jmap_server::ChangesParams::new(&State::from("0")),
)
.await
.expect("get_changes must succeed");
assert_eq!(changes.created, vec![id("fresh")]);
assert_eq!(changes.updated, vec![id("old")]);
assert_eq!(changes.destroyed, vec![id("doomed"), id("gone")]);
}
}
#[cfg(test)]
mod max_changes_tests {
use super::*;
use jmap_tasks_types::Task as T;
const CALLER: () = ();
fn with_creates(states: &[&[&str]]) -> MemoryBackend<()> {
let backend = MemoryBackend::<()>::default();
let mut inner = backend.inner.lock_unscoped();
for ids in states {
let new_state = inner.bump_state(T::TYPE_NAME, "acc1");
inner
.change_log_mut(T::TYPE_NAME, "acc1")
.push(ChangeEntry {
new_state,
created: ids.iter().map(|s| Id::from(*s)).collect(),
updated: vec![],
destroyed: vec![],
restored: vec![],
updated_props: None,
});
}
drop(inner);
backend
}
#[tokio::test]
async fn over_max_changes_pages_through_intermediate_state() {
let backend = with_creates(&[&["a"], &["b"], &["c"]]);
let first = changes(&backend, "0", 2).await.expect("first page");
assert_eq!(sorted(first.created), [Id::from("a"), Id::from("b")]);
assert!(first.has_more_changes);
assert_eq!(first.new_state.as_ref(), "2");
let rest = changes(&backend, "2", 2).await.expect("second page");
assert_eq!(rest.created, [Id::from("c")]);
assert!(!rest.has_more_changes);
assert_eq!(rest.new_state.as_ref(), "3");
}
#[tokio::test]
async fn one_state_over_max_changes_cannot_calculate() {
let backend = with_creates(&[&["a", "b", "c"]]);
assert!(matches!(
changes(&backend, "0", 2).await,
Err(BackendChangesError::TooManyChanges { limit: 2 })
));
}
fn sorted(mut ids: Vec<Id>) -> Vec<Id> {
ids.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
ids
}
async fn changes(
backend: &MemoryBackend<()>,
since: &str,
max: u64,
) -> Result<ChangesResult, BackendChangesError<<MemoryBackend<()> as JmapAccounts>::Error>>
{
backend
.get_changes::<T>(
&CALLER,
&Id::from("acc1"),
jmap_server::ChangesParams::new(&State::from(since)).max_changes(Some(max)),
)
.await
}
}