Box large futures

2026-04-19 08:11:56 +02:00
parent c0d0ac9ea3
commit af23099e35
72 changed files with 1267 additions and 1469 deletions
--- a/crates/jmap-proto/src/references/mod.rs
+++ b/crates/jmap-proto/src/references/mod.rs
@@ -310,7 +310,7 @@ mod tests {
                        id: call.id,
                        name: call.name,
                        method: ResponseMethod::Changes(ChangesResponseMethod::Mailbox(
-                            ChangesResponse {
+                            Box::new(ChangesResponse {
                                account_id: Id::new(1),
                                old_state: Default::default(),
                                new_state: Default::default(),
@@ -322,7 +322,7 @@ mod tests {
                                    MailboxProperty::Name.into(),
                                    MailboxProperty::ParentId.into(),
                                ]),
-                            },
+                            }),
                        )),
                    });
                }
--- a/crates/jmap-proto/src/request/mod.rs
+++ b/crates/jmap-proto/src/request/mod.rs
@@ -61,110 +61,110 @@ pub struct Call<T> {
 pub enum RequestMethod<'x> {
    Get(GetRequestMethod),
    Set(SetRequestMethod<'x>),
-    Changes(ChangesRequest),
+    Changes(Box<ChangesRequest>),
    Copy(CopyRequestMethod<'x>),
-    ImportEmail(ImportEmailRequest),
+    ImportEmail(Box<ImportEmailRequest>),
    Parse(ParseRequestMethod),
    Query(QueryRequestMethod),
    QueryChanges(QueryChangesRequestMethod),
-    SearchSnippet(GetSearchSnippetRequest),
-    ValidateScript(ValidateSieveScriptRequest),
-    LookupBlob(BlobLookupRequest),
-    UploadBlob(BlobUploadRequest),
+    SearchSnippet(Box<GetSearchSnippetRequest>),
+    ValidateScript(Box<ValidateSieveScriptRequest>),
+    LookupBlob(Box<BlobLookupRequest>),
+    UploadBlob(Box<BlobUploadRequest>),
    Echo(Value<'x, Null, Null>),
    Error(trc::Error),
 }

 #[derive(Debug)]
 pub enum GetRequestMethod {
-    Email(GetRequest<Email>),
-    Mailbox(GetRequest<Mailbox>),
-    Thread(GetRequest<Thread>),
-    Identity(GetRequest<Identity>),
-    EmailSubmission(GetRequest<EmailSubmission>),
-    PushSubscription(GetRequest<PushSubscription>),
-    Sieve(GetRequest<Sieve>),
-    VacationResponse(GetRequest<VacationResponse>),
-    Principal(GetRequest<Principal>),
-    PrincipalAvailability(GetAvailabilityRequest),
-    Quota(GetRequest<Quota>),
-    Blob(GetRequest<Blob>),
-    AddressBook(GetRequest<AddressBook>),
-    ContactCard(GetRequest<ContactCard>),
-    FileNode(GetRequest<FileNode>),
-    Calendar(GetRequest<Calendar>),
-    CalendarEvent(GetRequest<CalendarEvent>),
-    CalendarEventNotification(GetRequest<CalendarEventNotification>),
-    ParticipantIdentity(GetRequest<ParticipantIdentity>),
-    ShareNotification(GetRequest<ShareNotification>),
-    Registry(GetRequest<Registry>),
+    Email(Box<GetRequest<Email>>),
+    Mailbox(Box<GetRequest<Mailbox>>),
+    Thread(Box<GetRequest<Thread>>),
+    Identity(Box<GetRequest<Identity>>),
+    EmailSubmission(Box<GetRequest<EmailSubmission>>),
+    PushSubscription(Box<GetRequest<PushSubscription>>),
+    Sieve(Box<GetRequest<Sieve>>),
+    VacationResponse(Box<GetRequest<VacationResponse>>),
+    Principal(Box<GetRequest<Principal>>),
+    PrincipalAvailability(Box<GetAvailabilityRequest>),
+    Quota(Box<GetRequest<Quota>>),
+    Blob(Box<GetRequest<Blob>>),
+    AddressBook(Box<GetRequest<AddressBook>>),
+    ContactCard(Box<GetRequest<ContactCard>>),
+    FileNode(Box<GetRequest<FileNode>>),
+    Calendar(Box<GetRequest<Calendar>>),
+    CalendarEvent(Box<GetRequest<CalendarEvent>>),
+    CalendarEventNotification(Box<GetRequest<CalendarEventNotification>>),
+    ParticipantIdentity(Box<GetRequest<ParticipantIdentity>>),
+    ShareNotification(Box<GetRequest<ShareNotification>>),
+    Registry(Box<GetRequest<Registry>>),
 }

 #[derive(Debug)]
 pub enum SetRequestMethod<'x> {
-    Email(SetRequest<'x, Email>),
-    Mailbox(SetRequest<'x, Mailbox>),
-    Identity(SetRequest<'x, Identity>),
-    EmailSubmission(SetRequest<'x, EmailSubmission>),
-    PushSubscription(SetRequest<'x, PushSubscription>),
-    Sieve(SetRequest<'x, Sieve>),
-    VacationResponse(SetRequest<'x, VacationResponse>),
-    AddressBook(SetRequest<'x, AddressBook>),
-    ContactCard(SetRequest<'x, ContactCard>),
-    FileNode(SetRequest<'x, FileNode>),
-    ShareNotification(SetRequest<'x, ShareNotification>),
-    Calendar(SetRequest<'x, Calendar>),
-    CalendarEvent(SetRequest<'x, CalendarEvent>),
-    CalendarEventNotification(SetRequest<'x, CalendarEventNotification>),
-    ParticipantIdentity(SetRequest<'x, ParticipantIdentity>),
-    Registry(SetRequest<'x, Registry>),
+    Email(Box<SetRequest<'x, Email>>),
+    Mailbox(Box<SetRequest<'x, Mailbox>>),
+    Identity(Box<SetRequest<'x, Identity>>),
+    EmailSubmission(Box<SetRequest<'x, EmailSubmission>>),
+    PushSubscription(Box<SetRequest<'x, PushSubscription>>),
+    Sieve(Box<SetRequest<'x, Sieve>>),
+    VacationResponse(Box<SetRequest<'x, VacationResponse>>),
+    AddressBook(Box<SetRequest<'x, AddressBook>>),
+    ContactCard(Box<SetRequest<'x, ContactCard>>),
+    FileNode(Box<SetRequest<'x, FileNode>>),
+    ShareNotification(Box<SetRequest<'x, ShareNotification>>),
+    Calendar(Box<SetRequest<'x, Calendar>>),
+    CalendarEvent(Box<SetRequest<'x, CalendarEvent>>),
+    CalendarEventNotification(Box<SetRequest<'x, CalendarEventNotification>>),
+    ParticipantIdentity(Box<SetRequest<'x, ParticipantIdentity>>),
+    Registry(Box<SetRequest<'x, Registry>>),
 }

 #[derive(Debug)]
 pub enum CopyRequestMethod<'x> {
-    Email(CopyRequest<'x, Email>),
-    ContactCard(CopyRequest<'x, ContactCard>),
-    CalendarEvent(CopyRequest<'x, CalendarEvent>),
-    Blob(CopyBlobRequest),
+    Email(Box<CopyRequest<'x, Email>>),
+    ContactCard(Box<CopyRequest<'x, ContactCard>>),
+    CalendarEvent(Box<CopyRequest<'x, CalendarEvent>>),
+    Blob(Box<CopyBlobRequest>),
 }

 #[derive(Debug)]
 pub enum QueryRequestMethod {
-    Email(QueryRequest<Email>),
-    Mailbox(QueryRequest<Mailbox>),
-    EmailSubmission(QueryRequest<EmailSubmission>),
-    Sieve(QueryRequest<Sieve>),
-    Principal(QueryRequest<Principal>),
-    Quota(QueryRequest<Quota>),
-    AddressBook(QueryRequest<AddressBook>),
-    ContactCard(QueryRequest<ContactCard>),
-    FileNode(QueryRequest<FileNode>),
-    Calendar(QueryRequest<Calendar>),
-    CalendarEvent(QueryRequest<CalendarEvent>),
-    CalendarEventNotification(QueryRequest<CalendarEventNotification>),
-    ShareNotification(QueryRequest<ShareNotification>),
-    Registry(QueryRequest<Registry>),
+    Email(Box<QueryRequest<Email>>),
+    Mailbox(Box<QueryRequest<Mailbox>>),
+    EmailSubmission(Box<QueryRequest<EmailSubmission>>),
+    Sieve(Box<QueryRequest<Sieve>>),
+    Principal(Box<QueryRequest<Principal>>),
+    Quota(Box<QueryRequest<Quota>>),
+    AddressBook(Box<QueryRequest<AddressBook>>),
+    ContactCard(Box<QueryRequest<ContactCard>>),
+    FileNode(Box<QueryRequest<FileNode>>),
+    Calendar(Box<QueryRequest<Calendar>>),
+    CalendarEvent(Box<QueryRequest<CalendarEvent>>),
+    CalendarEventNotification(Box<QueryRequest<CalendarEventNotification>>),
+    ShareNotification(Box<QueryRequest<ShareNotification>>),
+    Registry(Box<QueryRequest<Registry>>),
 }

 #[derive(Debug)]
 pub enum QueryChangesRequestMethod {
-    Email(QueryChangesRequest<Email>),
-    Mailbox(QueryChangesRequest<Mailbox>),
-    EmailSubmission(QueryChangesRequest<EmailSubmission>),
-    Principal(QueryChangesRequest<Principal>),
-    Quota(QueryChangesRequest<Quota>),
-    ContactCard(QueryChangesRequest<ContactCard>),
-    FileNode(QueryChangesRequest<FileNode>),
-    CalendarEvent(QueryChangesRequest<CalendarEvent>),
-    CalendarEventNotification(QueryChangesRequest<CalendarEventNotification>),
-    ShareNotification(QueryChangesRequest<ShareNotification>),
+    Email(Box<QueryChangesRequest<Email>>),
+    Mailbox(Box<QueryChangesRequest<Mailbox>>),
+    EmailSubmission(Box<QueryChangesRequest<EmailSubmission>>),
+    Principal(Box<QueryChangesRequest<Principal>>),
+    Quota(Box<QueryChangesRequest<Quota>>),
+    ContactCard(Box<QueryChangesRequest<ContactCard>>),
+    FileNode(Box<QueryChangesRequest<FileNode>>),
+    CalendarEvent(Box<QueryChangesRequest<CalendarEvent>>),
+    CalendarEventNotification(Box<QueryChangesRequest<CalendarEventNotification>>),
+    ShareNotification(Box<QueryChangesRequest<ShareNotification>>),
 }

 #[derive(Debug)]
 pub enum ParseRequestMethod {
-    Email(ParseRequest<Email>),
-    ContactCard(ParseRequest<ContactCard>),
-    CalendarEvent(ParseRequest<CalendarEvent>),
+    Email(Box<ParseRequest<Email>>),
+    ContactCard(Box<ParseRequest<ContactCard>>),
+    CalendarEvent(Box<ParseRequest<CalendarEvent>>),
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
--- a/crates/jmap-proto/src/response/mod.rs
+++ b/crates/jmap-proto/src/response/mod.rs
@@ -103,40 +103,40 @@ pub enum GetResponseMethod {
 #[derive(Debug, serde::Serialize)]
 #[serde(untagged)]
 pub enum SetResponseMethod {
-    Email(SetResponse<Email>),
-    Mailbox(SetResponse<Mailbox>),
-    Identity(SetResponse<Identity>),
-    EmailSubmission(SetResponse<EmailSubmission>),
-    PushSubscription(SetResponse<PushSubscription>),
-    Sieve(SetResponse<Sieve>),
-    VacationResponse(SetResponse<VacationResponse>),
-    AddressBook(SetResponse<AddressBook>),
-    ContactCard(SetResponse<ContactCard>),
-    FileNode(SetResponse<FileNode>),
-    ShareNotification(SetResponse<ShareNotification>),
-    Calendar(SetResponse<Calendar>),
-    CalendarEvent(SetResponse<CalendarEvent>),
-    CalendarEventNotification(SetResponse<CalendarEventNotification>),
-    ParticipantIdentity(SetResponse<ParticipantIdentity>),
-    Registry(SetResponse<Registry>),
+    Email(Box<SetResponse<Email>>),
+    Mailbox(Box<SetResponse<Mailbox>>),
+    Identity(Box<SetResponse<Identity>>),
+    EmailSubmission(Box<SetResponse<EmailSubmission>>),
+    PushSubscription(Box<SetResponse<PushSubscription>>),
+    Sieve(Box<SetResponse<Sieve>>),
+    VacationResponse(Box<SetResponse<VacationResponse>>),
+    AddressBook(Box<SetResponse<AddressBook>>),
+    ContactCard(Box<SetResponse<ContactCard>>),
+    FileNode(Box<SetResponse<FileNode>>),
+    ShareNotification(Box<SetResponse<ShareNotification>>),
+    Calendar(Box<SetResponse<Calendar>>),
+    CalendarEvent(Box<SetResponse<CalendarEvent>>),
+    CalendarEventNotification(Box<SetResponse<CalendarEventNotification>>),
+    ParticipantIdentity(Box<SetResponse<ParticipantIdentity>>),
+    Registry(Box<SetResponse<Registry>>),
 }

 #[derive(Debug, serde::Serialize)]
 #[serde(untagged)]
 pub enum ChangesResponseMethod {
-    Email(ChangesResponse<Email>),
-    Mailbox(ChangesResponse<Mailbox>),
-    Thread(ChangesResponse<Thread>),
-    Identity(ChangesResponse<Identity>),
-    EmailSubmission(ChangesResponse<EmailSubmission>),
-    Quota(ChangesResponse<Quota>),
-    AddressBook(ChangesResponse<AddressBook>),
-    ContactCard(ChangesResponse<ContactCard>),
-    FileNode(ChangesResponse<FileNode>),
-    Calendar(ChangesResponse<Calendar>),
-    CalendarEvent(ChangesResponse<CalendarEvent>),
-    CalendarEventNotification(ChangesResponse<CalendarEventNotification>),
-    ShareNotification(ChangesResponse<ShareNotification>),
+    Email(Box<ChangesResponse<Email>>),
+    Mailbox(Box<ChangesResponse<Mailbox>>),
+    Thread(Box<ChangesResponse<Thread>>),
+    Identity(Box<ChangesResponse<Identity>>),
+    EmailSubmission(Box<ChangesResponse<EmailSubmission>>),
+    Quota(Box<ChangesResponse<Quota>>),
+    AddressBook(Box<ChangesResponse<AddressBook>>),
+    ContactCard(Box<ChangesResponse<ContactCard>>),
+    FileNode(Box<ChangesResponse<FileNode>>),
+    Calendar(Box<ChangesResponse<Calendar>>),
+    CalendarEvent(Box<ChangesResponse<CalendarEvent>>),
+    CalendarEventNotification(Box<ChangesResponse<CalendarEventNotification>>),
+    ShareNotification(Box<ChangesResponse<ShareNotification>>),
 }

 #[derive(Debug, serde::Serialize)]
@@ -306,103 +306,103 @@ impl<'x> From<GetResponse<Registry>> for ResponseMethod<'x> {

 impl<'x> From<SetResponse<Email>> for ResponseMethod<'x> {
    fn from(value: SetResponse<Email>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Email(value))
+        ResponseMethod::Set(SetResponseMethod::Email(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<Mailbox>> for ResponseMethod<'x> {
    fn from(value: SetResponse<Mailbox>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Mailbox(value))
+        ResponseMethod::Set(SetResponseMethod::Mailbox(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<Identity>> for ResponseMethod<'x> {
    fn from(value: SetResponse<Identity>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Identity(value))
+        ResponseMethod::Set(SetResponseMethod::Identity(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<EmailSubmission>> for ResponseMethod<'x> {
    fn from(value: SetResponse<EmailSubmission>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::EmailSubmission(value))
+        ResponseMethod::Set(SetResponseMethod::EmailSubmission(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<PushSubscription>> for ResponseMethod<'x> {
    fn from(value: SetResponse<PushSubscription>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::PushSubscription(value))
+        ResponseMethod::Set(SetResponseMethod::PushSubscription(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<Sieve>> for ResponseMethod<'x> {
    fn from(value: SetResponse<Sieve>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Sieve(value))
+        ResponseMethod::Set(SetResponseMethod::Sieve(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<VacationResponse>> for ResponseMethod<'x> {
    fn from(value: SetResponse<VacationResponse>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::VacationResponse(value))
+        ResponseMethod::Set(SetResponseMethod::VacationResponse(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<AddressBook>> for ResponseMethod<'x> {
    fn from(value: SetResponse<AddressBook>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::AddressBook(value))
+        ResponseMethod::Set(SetResponseMethod::AddressBook(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<ContactCard>> for ResponseMethod<'x> {
    fn from(value: SetResponse<ContactCard>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::ContactCard(value))
+        ResponseMethod::Set(SetResponseMethod::ContactCard(Box::new(value)))
    }
 }

 impl<'x> From<SetResponse<Registry>> for ResponseMethod<'x> {
    fn from(value: SetResponse<Registry>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Registry(value))
+        ResponseMethod::Set(SetResponseMethod::Registry(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<Email>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<Email>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::Email(value))
+        ResponseMethod::Changes(ChangesResponseMethod::Email(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<Mailbox>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<Mailbox>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::Mailbox(value))
+        ResponseMethod::Changes(ChangesResponseMethod::Mailbox(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<Thread>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<Thread>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::Thread(value))
+        ResponseMethod::Changes(ChangesResponseMethod::Thread(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<Identity>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<Identity>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::Identity(value))
+        ResponseMethod::Changes(ChangesResponseMethod::Identity(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<EmailSubmission>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<EmailSubmission>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::EmailSubmission(value))
+        ResponseMethod::Changes(ChangesResponseMethod::EmailSubmission(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<Quota>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<Quota>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::Quota(value))
+        ResponseMethod::Changes(ChangesResponseMethod::Quota(Box::new(value)))
    }
 }

 impl<'x> From<ChangesResponse<AddressBook>> for ResponseMethod<'x> {
    fn from(value: ChangesResponse<AddressBook>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::AddressBook(value))
+        ResponseMethod::Changes(ChangesResponseMethod::AddressBook(Box::new(value)))
    }
 }

@@ -498,13 +498,13 @@ impl From<GetResponse<FileNode>> for ResponseMethod<'_> {

 impl From<SetResponse<FileNode>> for ResponseMethod<'_> {
    fn from(response: SetResponse<FileNode>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::FileNode(response))
+        ResponseMethod::Set(SetResponseMethod::FileNode(Box::new(response)))
    }
 }

 impl From<ChangesResponse<FileNode>> for ResponseMethod<'_> {
    fn from(response: ChangesResponse<FileNode>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::FileNode(response))
+        ResponseMethod::Changes(ChangesResponseMethod::FileNode(Box::new(response)))
    }
 }

@@ -522,31 +522,31 @@ impl From<GetResponse<Calendar>> for ResponseMethod<'_> {

 impl From<SetResponse<Calendar>> for ResponseMethod<'_> {
    fn from(response: SetResponse<Calendar>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::Calendar(response))
+        ResponseMethod::Set(SetResponseMethod::Calendar(Box::new(response)))
    }
 }

 impl From<ChangesResponse<CalendarEvent>> for ResponseMethod<'_> {
    fn from(response: ChangesResponse<CalendarEvent>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::CalendarEvent(response))
+        ResponseMethod::Changes(ChangesResponseMethod::CalendarEvent(Box::new(response)))
    }
 }

 impl From<ChangesResponse<CalendarEventNotification>> for ResponseMethod<'_> {
    fn from(response: ChangesResponse<CalendarEventNotification>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::CalendarEventNotification(response))
+        ResponseMethod::Changes(ChangesResponseMethod::CalendarEventNotification(Box::new(response)))
    }
 }

 impl From<SetResponse<CalendarEvent>> for ResponseMethod<'_> {
    fn from(response: SetResponse<CalendarEvent>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::CalendarEvent(response))
+        ResponseMethod::Set(SetResponseMethod::CalendarEvent(Box::new(response)))
    }
 }

 impl From<SetResponse<ParticipantIdentity>> for ResponseMethod<'_> {
    fn from(response: SetResponse<ParticipantIdentity>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::ParticipantIdentity(response))
+        ResponseMethod::Set(SetResponseMethod::ParticipantIdentity(Box::new(response)))
    }
 }

@@ -558,13 +558,13 @@ impl From<GetResponse<ParticipantIdentity>> for ResponseMethod<'_> {

 impl From<ChangesResponse<ShareNotification>> for ResponseMethod<'_> {
    fn from(response: ChangesResponse<ShareNotification>) -> Self {
-        ResponseMethod::Changes(ChangesResponseMethod::ShareNotification(response))
+        ResponseMethod::Changes(ChangesResponseMethod::ShareNotification(Box::new(response)))
    }
 }

 impl From<SetResponse<ShareNotification>> for ResponseMethod<'_> {
    fn from(response: SetResponse<ShareNotification>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::ShareNotification(response))
+        ResponseMethod::Set(SetResponseMethod::ShareNotification(Box::new(response)))
    }
 }

@@ -600,6 +600,6 @@ impl From<CalendarEventNotificationGetResponse> for ResponseMethod<'_> {

 impl From<SetResponse<CalendarEventNotification>> for ResponseMethod<'_> {
    fn from(value: SetResponse<CalendarEventNotification>) -> Self {
-        ResponseMethod::Set(SetResponseMethod::CalendarEventNotification(value))
+        ResponseMethod::Set(SetResponseMethod::CalendarEventNotification(Box::new(value)))
    }
 }