1use crate::{Id, ValidationError};
14use std::fmt;
15use std::str::FromStr;
16
17#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
38pub struct JmapUri {
39 data_type: String,
40 account_id: Id,
41 object_id: Id,
42}
43
44#[non_exhaustive]
46#[derive(Debug, Clone, PartialEq, Eq)]
47pub enum JmapUriError {
48 NotJmapScheme,
50 ReservedForm,
53 InvalidDataType,
55 InvalidAccountId(Option<ValidationError>),
57 MissingObjectId,
59 InvalidObjectId(ValidationError),
62}
63
64impl fmt::Display for JmapUriError {
65 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
66 match self {
67 Self::NotJmapScheme => f.write_str("URI scheme is not `jmap`"),
68 Self::ReservedForm => {
69 f.write_str("jmap:// URI is a reserved form, not a JMAP object URI")
70 }
71 Self::InvalidDataType => {
72 f.write_str("jmap: URI type is not a lowercased JMAP data type name")
73 }
74 Self::InvalidAccountId(_) => f.write_str("jmap: URI accountId is missing or invalid"),
75 Self::MissingObjectId => f.write_str("jmap: URI has no objectId"),
76 Self::InvalidObjectId(_) => f.write_str("jmap: URI objectId is invalid"),
77 }
78 }
79}
80
81impl std::error::Error for JmapUriError {
82 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
83 match self {
84 Self::InvalidAccountId(Some(e)) | Self::InvalidObjectId(e) => Some(e),
85 _ => None,
86 }
87 }
88}
89
90impl JmapUri {
91 pub fn new(
100 data_type: impl Into<String>,
101 account_id: Id,
102 object_id: Id,
103 ) -> Result<Self, JmapUriError> {
104 let data_type = data_type.into();
105 validate_data_type(&data_type)?;
106 Id::new_validated(account_id.as_ref())
107 .map_err(|e| JmapUriError::InvalidAccountId(Some(e)))?;
108 Id::new_validated(object_id.as_ref()).map_err(JmapUriError::InvalidObjectId)?;
109 Ok(Self {
110 data_type,
111 account_id,
112 object_id,
113 })
114 }
115
116 pub fn data_type(&self) -> &str {
118 &self.data_type
119 }
120
121 pub fn account_id(&self) -> &Id {
123 &self.account_id
124 }
125
126 pub fn object_id(&self) -> &Id {
128 &self.object_id
129 }
130}
131
132fn validate_data_type(s: &str) -> Result<(), JmapUriError> {
133 if !s.is_empty()
134 && s.bytes()
135 .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit())
136 {
137 Ok(())
138 } else {
139 Err(JmapUriError::InvalidDataType)
140 }
141}
142
143impl FromStr for JmapUri {
144 type Err = JmapUriError;
145
146 fn from_str(s: &str) -> Result<Self, Self::Err> {
149 let mut parts = s.splitn(4, ':');
152 let scheme = parts.next().unwrap_or_default();
153 let Some(data_type) = parts.next().filter(|_| scheme.eq_ignore_ascii_case("jmap")) else {
155 return Err(JmapUriError::NotJmapScheme);
156 };
157 if data_type.starts_with("//") {
158 return Err(JmapUriError::ReservedForm);
159 }
160 validate_data_type(data_type)?;
161 let account_id = parts.next().ok_or(JmapUriError::InvalidAccountId(None))?;
162 let account_id =
163 Id::new_validated(account_id).map_err(|e| JmapUriError::InvalidAccountId(Some(e)))?;
164 let object_id = parts.next().ok_or(JmapUriError::MissingObjectId)?;
165 let object_id = Id::new_validated(object_id).map_err(JmapUriError::InvalidObjectId)?;
166 Self::new(data_type, account_id, object_id)
167 }
168}
169
170impl fmt::Display for JmapUri {
171 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
172 write!(
173 f,
174 "jmap:{}:{}:{}",
175 self.data_type, self.account_id, self.object_id
176 )
177 }
178}
179
180impl serde::Serialize for JmapUri {
181 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
182 serializer.collect_str(self)
183 }
184}
185
186impl<'de> serde::Deserialize<'de> for JmapUri {
187 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
188 let s = <std::borrow::Cow<'de, str>>::deserialize(deserializer)?;
189 s.parse().map_err(serde::de::Error::custom)
190 }
191}