Import upstream v0.16.22, stripped

Upstream commit: 474dd0229cb20cf513036619781ed97bd8073c3f Enterprise-only files removed or emptied: 63 Enterprise-only snippets removed: 117 in 50 files Dangling module declarations removed: 5 Cargo edits turning enterprise off: 14 Verification: clean Enterprise feature gates left for rebuilt features: 19 in 18 files Produced by tools/fork/strip.py. The full report is in docs/fork/strip-reports/ on main.
2026-09-18 10:21:56 -07:00
commit 7dae9b29fd
1650 changed files with 485521 additions and 0 deletions
@@ -0,0 +1,483 @@
+/*
+ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
+ */
+
+use crate::{
+    object::{
+        AnyId, JmapObject, JmapObjectId, MaybeReference,
+        email::{EmailProperty, EmailValue},
+        parse_ref,
+    },
+    request::{MaybeInvalid, deserialize::DeserializeArguments, reference::MaybeIdReference},
+    types::date::UTCDate,
+};
+use jmap_tools::{Element, JsonPointer, JsonPointerItem, Key, Property, Value};
+use std::{borrow::Cow, str::FromStr};
+use types::{blob::BlobId, id::Id};
+use utils::map::vec_map::VecMap;
+
+#[derive(Debug, Clone, Default)]
+pub struct EmailSubmission;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EmailSubmissionProperty {
+    Id,
+    IdentityId,
+    ThreadId,
+    EmailId,
+    Envelope,
+    MailFrom,
+    RcptTo,
+    Email,
+    Parameters,
+    SendAt,
+    UndoStatus,
+    DeliveryStatus,
+    SmtpReply,
+    Delivered,
+    Displayed,
+    DsnBlobIds,
+    MdnBlobIds,
+
+    Pointer(JsonPointer<EmailSubmissionProperty>),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EmailSubmissionValue {
+    Id(Id),
+    Date(UTCDate),
+    BlobId(BlobId),
+    UndoStatus(UndoStatus),
+    Delivered(Delivered),
+    Displayed(Displayed),
+    IdReference(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum UndoStatus {
+    Pending,
+    Final,
+    Canceled,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Delivered {
+    Queued,
+    Yes,
+    No,
+    Unknown,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Displayed {
+    Yes,
+    Unknown,
+}
+
+impl Property for EmailSubmissionProperty {
+    fn try_parse(key: Option<&Key<'_, Self>>, value: &str) -> Option<Self> {
+        EmailSubmissionProperty::parse(value, key.is_none())
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            EmailSubmissionProperty::DeliveryStatus => "deliveryStatus",
+            EmailSubmissionProperty::DsnBlobIds => "dsnBlobIds",
+            EmailSubmissionProperty::Email => "email",
+            EmailSubmissionProperty::Envelope => "envelope",
+            EmailSubmissionProperty::Id => "id",
+            EmailSubmissionProperty::IdentityId => "identityId",
+            EmailSubmissionProperty::MdnBlobIds => "mdnBlobIds",
+            EmailSubmissionProperty::SendAt => "sendAt",
+            EmailSubmissionProperty::ThreadId => "threadId",
+            EmailSubmissionProperty::UndoStatus => "undoStatus",
+            EmailSubmissionProperty::Parameters => "parameters",
+            EmailSubmissionProperty::SmtpReply => "smtpReply",
+            EmailSubmissionProperty::Delivered => "delivered",
+            EmailSubmissionProperty::Displayed => "displayed",
+            EmailSubmissionProperty::MailFrom => "mailFrom",
+            EmailSubmissionProperty::RcptTo => "rcptTo",
+            EmailSubmissionProperty::EmailId => "emailId",
+            EmailSubmissionProperty::Pointer(json_pointer) => {
+                return json_pointer.to_string().into();
+            }
+        }
+        .into()
+    }
+}
+
+impl Element for EmailSubmissionValue {
+    type Property = EmailSubmissionProperty;
+
+    fn try_parse<P>(key: &Key<'_, Self::Property>, value: &str) -> Option<Self> {
+        if let Key::Property(prop) = key {
+            match prop.patch_or_prop() {
+                EmailSubmissionProperty::Id
+                | EmailSubmissionProperty::ThreadId
+                | EmailSubmissionProperty::IdentityId
+                | EmailSubmissionProperty::EmailId => match parse_ref(value) {
+                    MaybeReference::Value(v) => Some(EmailSubmissionValue::Id(v)),
+                    MaybeReference::Reference(v) => Some(EmailSubmissionValue::IdReference(v)),
+                    MaybeReference::ParseError => None,
+                },
+                EmailSubmissionProperty::MdnBlobIds | EmailSubmissionProperty::DsnBlobIds => {
+                    match parse_ref(value) {
+                        MaybeReference::Value(v) => Some(EmailSubmissionValue::BlobId(v)),
+                        MaybeReference::Reference(v) => Some(EmailSubmissionValue::IdReference(v)),
+                        MaybeReference::ParseError => None,
+                    }
+                }
+                EmailSubmissionProperty::SendAt => UTCDate::from_str(value)
+                    .ok()
+                    .map(EmailSubmissionValue::Date),
+                EmailSubmissionProperty::UndoStatus => {
+                    UndoStatus::parse(value).map(EmailSubmissionValue::UndoStatus)
+                }
+                EmailSubmissionProperty::Delivered => {
+                    Delivered::parse(value).map(EmailSubmissionValue::Delivered)
+                }
+                EmailSubmissionProperty::Displayed => {
+                    Displayed::parse(value).map(EmailSubmissionValue::Displayed)
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            EmailSubmissionValue::Id(id) => id.to_string().into(),
+            EmailSubmissionValue::Date(utcdate) => utcdate.to_string().into(),
+            EmailSubmissionValue::BlobId(blob_id) => blob_id.to_string().into(),
+            EmailSubmissionValue::IdReference(r) => format!("#{r}").into(),
+            EmailSubmissionValue::UndoStatus(undo_status) => undo_status.as_str().into(),
+            EmailSubmissionValue::Delivered(delivered) => delivered.as_str().into(),
+            EmailSubmissionValue::Displayed(displayed) => displayed.as_str().into(),
+        }
+    }
+}
+
+impl EmailSubmissionProperty {
+    fn parse(value: &str, allow_patch: bool) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            "id" => EmailSubmissionProperty::Id,
+            "identityId" => EmailSubmissionProperty::IdentityId,
+            "threadId" => EmailSubmissionProperty::ThreadId,
+            "emailId" => EmailSubmissionProperty::EmailId,
+            "envelope" => EmailSubmissionProperty::Envelope,
+            "mailFrom" => EmailSubmissionProperty::MailFrom,
+            "rcptTo" => EmailSubmissionProperty::RcptTo,
+            "email" => EmailSubmissionProperty::Email,
+            "parameters" => EmailSubmissionProperty::Parameters,
+            "sendAt" => EmailSubmissionProperty::SendAt,
+            "undoStatus" => EmailSubmissionProperty::UndoStatus,
+            "deliveryStatus" => EmailSubmissionProperty::DeliveryStatus,
+            "smtpReply" => EmailSubmissionProperty::SmtpReply,
+            "delivered" => EmailSubmissionProperty::Delivered,
+            "displayed" => EmailSubmissionProperty::Displayed,
+            "dsnBlobIds" => EmailSubmissionProperty::DsnBlobIds,
+            "mdnBlobIds" => EmailSubmissionProperty::MdnBlobIds,
+        )
+        .or_else(|| {
+            if allow_patch && value.contains('/') {
+                EmailSubmissionProperty::Pointer(JsonPointer::parse(value)).into()
+            } else {
+                None
+            }
+        })
+    }
+
+    fn patch_or_prop(&self) -> &EmailSubmissionProperty {
+        if let EmailSubmissionProperty::Pointer(ptr) = self
+            && let Some(JsonPointerItem::Key(Key::Property(prop))) = ptr.last()
+        {
+            prop
+        } else {
+            self
+        }
+    }
+}
+
+impl UndoStatus {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"pending" => UndoStatus::Pending,
+            b"final" => UndoStatus::Final,
+            b"canceled" => UndoStatus::Canceled,
+        )
+    }
+
+    fn as_str(&self) -> &'static str {
+        match self {
+            UndoStatus::Pending => "pending",
+            UndoStatus::Final => "final",
+            UndoStatus::Canceled => "canceled",
+        }
+    }
+}
+
+impl Delivered {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"queued" => Delivered::Queued,
+            b"yes" => Delivered::Yes,
+            b"no" => Delivered::No,
+            b"unknown" => Delivered::Unknown,
+        )
+    }
+
+    fn as_str(&self) -> &'static str {
+        match self {
+            Delivered::Queued => "queued",
+            Delivered::Yes => "yes",
+            Delivered::No => "no",
+            Delivered::Unknown => "unknown",
+        }
+    }
+}
+
+impl Displayed {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"yes" => Displayed::Yes,
+            b"unknown" => Displayed::Unknown,
+        )
+    }
+
+    fn as_str(&self) -> &'static str {
+        match self {
+            Displayed::Yes => "yes",
+            Displayed::Unknown => "unknown",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EmailSubmissionSetArguments<'x> {
+    pub on_success_update_email:
+        Option<VecMap<MaybeIdReference<Id>, Value<'x, EmailProperty, EmailValue>>>,
+    pub on_success_destroy_email: Option<Vec<MaybeIdReference<Id>>>,
+}
+
+impl<'x> DeserializeArguments<'x> for EmailSubmissionSetArguments<'x> {
+    fn deserialize_argument<A>(&mut self, key: &str, map: &mut A) -> Result<(), A::Error>
+    where
+        A: serde::de::MapAccess<'x>,
+    {
+        hashify::fnc_map!(key.as_bytes(),
+            b"onSuccessUpdateEmail" => {
+                self.on_success_update_email = map.next_value()?;
+            },
+            b"onSuccessDestroyEmail" => {
+                self.on_success_destroy_email = map.next_value()?;
+            },
+            _ => {
+                let _ = map.next_value::<serde::de::IgnoredAny>()?;
+            }
+        );
+
+        Ok(())
+    }
+}
+
+impl FromStr for EmailSubmissionProperty {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        EmailSubmissionProperty::parse(s, false).ok_or(())
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for UndoStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        UndoStatus::parse(<&str>::deserialize(deserializer)?)
+            .ok_or_else(|| serde::de::Error::custom("invalid JMAP UndoStatus"))
+    }
+}
+
+impl JmapObject for EmailSubmission {
+    type Property = EmailSubmissionProperty;
+
+    type Element = EmailSubmissionValue;
+
+    type Id = Id;
+
+    type Filter = EmailSubmissionFilter;
+
+    type Comparator = EmailSubmissionComparator;
+
+    type GetArguments = ();
+
+    type SetArguments<'de> = EmailSubmissionSetArguments<'de>;
+
+    type QueryArguments = ();
+
+    type CopyArguments = ();
+
+    type ParseArguments = ();
+
+    const ID_PROPERTY: Self::Property = EmailSubmissionProperty::Id;
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EmailSubmissionFilter {
+    IdentityIds(Vec<MaybeInvalid<Id>>),
+    EmailIds(Vec<MaybeInvalid<Id>>),
+    ThreadIds(Vec<MaybeInvalid<Id>>),
+    Before(UTCDate),
+    After(UTCDate),
+    UndoStatus(UndoStatus),
+    _T(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EmailSubmissionComparator {
+    EmailId,
+    ThreadId,
+    SentAt,
+    _T(String),
+}
+
+impl<'de> DeserializeArguments<'de> for EmailSubmissionFilter {
+    fn deserialize_argument<A>(&mut self, key: &str, map: &mut A) -> Result<(), A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        hashify::fnc_map!(key.as_bytes(),
+            b"identityIds" => {
+                *self = EmailSubmissionFilter::IdentityIds(map.next_value()?);
+            },
+            b"emailIds" => {
+                *self = EmailSubmissionFilter::EmailIds(map.next_value()?);
+            },
+            b"threadIds" => {
+                *self = EmailSubmissionFilter::ThreadIds(map.next_value()?);
+            },
+            b"before" => {
+                *self = EmailSubmissionFilter::Before(map.next_value()?);
+            },
+            b"after" => {
+                *self = EmailSubmissionFilter::After(map.next_value()?);
+            },
+            b"undoStatus" => {
+                *self = EmailSubmissionFilter::UndoStatus(map.next_value()?);
+            },
+            _ => {
+                *self = EmailSubmissionFilter::_T(key.to_string());
+                let _ = map.next_value::<serde::de::IgnoredAny>()?;
+            }
+        );
+
+        Ok(())
+    }
+}
+
+impl<'de> DeserializeArguments<'de> for EmailSubmissionComparator {
+    fn deserialize_argument<A>(&mut self, key: &str, map: &mut A) -> Result<(), A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        if key == "property" {
+            let value = map.next_value::<Cow<str>>()?;
+            hashify::fnc_map!(value.as_bytes(),
+
+                b"emailId" => {
+                    *self = EmailSubmissionComparator::EmailId;
+                },
+                b"threadId" => {
+                    *self = EmailSubmissionComparator::ThreadId;
+                },
+                b"sentAt" => {
+                    *self = EmailSubmissionComparator::SentAt;
+                },
+                _ => {
+                    *self = EmailSubmissionComparator::_T(key.to_string());
+                }
+            );
+        } else {
+            let _ = map.next_value::<serde::de::IgnoredAny>()?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Default for EmailSubmissionFilter {
+    fn default() -> Self {
+        EmailSubmissionFilter::_T("".to_string())
+    }
+}
+
+impl Default for EmailSubmissionComparator {
+    fn default() -> Self {
+        EmailSubmissionComparator::_T("".to_string())
+    }
+}
+
+impl From<Id> for EmailSubmissionValue {
+    fn from(id: Id) -> Self {
+        EmailSubmissionValue::Id(id)
+    }
+}
+
+impl JmapObjectId for EmailSubmissionValue {
+    fn as_id(&self) -> Option<Id> {
+        match self {
+            EmailSubmissionValue::Id(id) => Some(*id),
+            _ => None,
+        }
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        match self {
+            EmailSubmissionValue::Id(id) => Some(AnyId::Id(*id)),
+            EmailSubmissionValue::BlobId(blob_id) => Some(AnyId::BlobId(blob_id.clone())),
+            _ => None,
+        }
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        if let EmailSubmissionValue::IdReference(r) = self {
+            Some(r)
+        } else {
+            None
+        }
+    }
+
+    fn try_set_id(&mut self, new_id: AnyId) -> bool {
+        match new_id {
+            AnyId::Id(id) => {
+                *self = EmailSubmissionValue::Id(id);
+            }
+            AnyId::BlobId(blob_id) => {
+                *self = EmailSubmissionValue::BlobId(blob_id);
+            }
+        }
+        true
+    }
+}
+
+impl JmapObjectId for EmailSubmissionProperty {
+    fn as_id(&self) -> Option<Id> {
+        None
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        None
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, _: AnyId) -> bool {
+        false
+    }
+}