1use serde::de::{self, DeserializeOwned};
10use serde::{Deserialize, Deserializer, Serialize, Serializer};
11use serde_json::{Map, Value};
12
13use jmap_types::problem::ProblemDetails;
14use jmap_types::{JmapRequest, JmapResponse, StateChange};
15
16const REQUEST: &str = "Request";
17const RESPONSE: &str = "Response";
18const REQUEST_ERROR: &str = "RequestError";
19const STATE_CHANGE: &str = "StateChange";
20const PUSH_ENABLE: &str = "WebSocketPushEnable";
21const PUSH_DISABLE: &str = "WebSocketPushDisable";
22
23fn check_type<E: de::Error>(found: Option<String>, expected: &'static str) -> Result<(), E> {
26 match found {
27 None => Ok(()),
28 Some(t) if t == expected => Ok(()),
29 Some(t) => Err(E::invalid_value(de::Unexpected::Str(&t), &expected)),
30 }
31}
32
33#[non_exhaustive]
42#[derive(Debug, Clone, PartialEq)]
43pub struct WsRequest {
44 pub id: Option<String>,
47 pub request: JmapRequest,
49}
50
51impl WsRequest {
52 pub fn new(request: JmapRequest, id: Option<String>) -> Self {
54 Self { id, request }
55 }
56}
57
58#[derive(Serialize)]
59struct RequestOut<'a> {
60 #[serde(rename = "@type")]
61 ty: &'static str,
62 #[serde(skip_serializing_if = "Option::is_none")]
63 id: Option<&'a str>,
64 #[serde(flatten)]
65 request: &'a JmapRequest,
66}
67
68#[derive(Deserialize)]
69struct RequestIn {
70 #[serde(rename = "@type", default)]
71 ty: Option<String>,
72 #[serde(default)]
73 id: Option<String>,
74 #[serde(flatten)]
75 request: JmapRequest,
76}
77
78impl Serialize for WsRequest {
79 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
80 RequestOut {
81 ty: REQUEST,
82 id: self.id.as_deref(),
83 request: &self.request,
84 }
85 .serialize(s)
86 }
87}
88
89impl<'de> Deserialize<'de> for WsRequest {
90 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
91 let r = RequestIn::deserialize(d)?;
92 check_type(r.ty, REQUEST)?;
93 Ok(Self {
94 id: r.id,
95 request: r.request,
96 })
97 }
98}
99
100#[non_exhaustive]
110#[derive(Debug, Clone, PartialEq)]
111pub struct WsResponse {
112 pub request_id: Option<String>,
114 pub response: JmapResponse,
116}
117
118impl WsResponse {
119 pub fn new(response: JmapResponse, request_id: Option<String>) -> Self {
121 Self {
122 request_id,
123 response,
124 }
125 }
126}
127
128#[derive(Serialize)]
129struct ResponseOut<'a> {
130 #[serde(rename = "@type")]
131 ty: &'static str,
132 #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
133 request_id: Option<&'a str>,
134 #[serde(flatten)]
135 response: &'a JmapResponse,
136}
137
138#[derive(Deserialize)]
139struct ResponseIn {
140 #[serde(rename = "@type", default)]
141 ty: Option<String>,
142 #[serde(rename = "requestId", default)]
143 request_id: Option<String>,
144 #[serde(flatten)]
145 response: JmapResponse,
146}
147
148impl Serialize for WsResponse {
149 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
150 ResponseOut {
151 ty: RESPONSE,
152 request_id: self.request_id.as_deref(),
153 response: &self.response,
154 }
155 .serialize(s)
156 }
157}
158
159impl<'de> Deserialize<'de> for WsResponse {
160 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
161 let r = ResponseIn::deserialize(d)?;
162 check_type(r.ty, RESPONSE)?;
163 Ok(Self {
164 request_id: r.request_id,
165 response: r.response,
166 })
167 }
168}
169
170#[non_exhaustive]
196#[derive(Debug, Clone, PartialEq)]
197pub struct WsRequestError {
198 pub request_id: Option<String>,
200 pub problem: ProblemDetails,
203}
204
205impl WsRequestError {
206 pub fn new(problem: ProblemDetails, request_id: Option<String>) -> Self {
209 Self {
210 request_id,
211 problem,
212 }
213 }
214}
215
216#[derive(Serialize)]
217struct RequestErrorOut<'a> {
218 #[serde(rename = "@type")]
219 ty: &'static str,
220 #[serde(rename = "requestId")]
221 request_id: Option<&'a str>,
222 #[serde(flatten)]
223 problem: &'a ProblemDetails,
224}
225
226#[derive(Deserialize)]
227struct RequestErrorIn {
228 #[serde(rename = "@type", default)]
229 ty: Option<String>,
230 #[serde(rename = "requestId", default)]
231 request_id: Option<String>,
232 #[serde(flatten)]
233 problem: ProblemDetails,
234}
235
236impl Serialize for WsRequestError {
237 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
238 RequestErrorOut {
239 ty: REQUEST_ERROR,
240 request_id: self.request_id.as_deref(),
241 problem: &self.problem,
242 }
243 .serialize(s)
244 }
245}
246
247impl<'de> Deserialize<'de> for WsRequestError {
248 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
249 let r = RequestErrorIn::deserialize(d)?;
250 check_type(r.ty, REQUEST_ERROR)?;
251 Ok(Self {
252 request_id: r.request_id,
253 problem: r.problem,
254 })
255 }
256}
257
258#[non_exhaustive]
269#[derive(Debug, Clone, PartialEq, Eq)]
270pub struct WsStateChange {
271 pub push_state: Option<String>,
273 pub state_change: StateChange,
275}
276
277impl WsStateChange {
278 pub fn new(state_change: StateChange, push_state: Option<String>) -> Self {
280 Self {
281 push_state,
282 state_change,
283 }
284 }
285}
286
287#[derive(Serialize)]
288struct StateChangeOut<'a> {
289 #[serde(flatten)]
291 state_change: &'a StateChange,
292 #[serde(rename = "pushState", skip_serializing_if = "Option::is_none")]
293 push_state: Option<&'a str>,
294}
295
296#[derive(Deserialize)]
297struct StateChangeIn {
298 #[serde(rename = "pushState", default)]
299 push_state: Option<String>,
300 #[serde(flatten)]
302 state_change: StateChange,
303}
304
305impl Serialize for WsStateChange {
306 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
307 StateChangeOut {
308 state_change: &self.state_change,
309 push_state: self.push_state.as_deref(),
310 }
311 .serialize(s)
312 }
313}
314
315impl<'de> Deserialize<'de> for WsStateChange {
316 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
317 let r = StateChangeIn::deserialize(d)?;
318 Ok(Self {
319 push_state: r.push_state,
320 state_change: r.state_change,
321 })
322 }
323}
324
325#[non_exhaustive]
335#[derive(Debug, Clone, PartialEq, Eq, Default)]
336pub struct WebSocketPushEnable {
337 pub data_types: Option<Vec<String>>,
341 pub push_state: Option<String>,
344 pub extra: Map<String, Value>,
346}
347
348impl WebSocketPushEnable {
349 pub fn new(data_types: Option<Vec<String>>, push_state: Option<String>) -> Self {
352 Self {
353 data_types,
354 push_state,
355 extra: Map::new(),
356 }
357 }
358}
359
360#[derive(Serialize)]
361struct PushEnableOut<'a> {
362 #[serde(rename = "@type")]
363 ty: &'static str,
364 #[serde(rename = "dataTypes")]
365 data_types: Option<&'a [String]>,
366 #[serde(rename = "pushState", skip_serializing_if = "Option::is_none")]
367 push_state: Option<&'a str>,
368 #[serde(flatten)]
369 extra: &'a Map<String, Value>,
370}
371
372#[derive(Deserialize)]
373struct PushEnableIn {
374 #[serde(rename = "@type", default)]
375 ty: Option<String>,
376 #[serde(rename = "dataTypes", default)]
377 data_types: Option<Vec<String>>,
378 #[serde(rename = "pushState", default)]
379 push_state: Option<String>,
380 #[serde(flatten)]
381 extra: Map<String, Value>,
382}
383
384impl Serialize for WebSocketPushEnable {
385 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
386 PushEnableOut {
387 ty: PUSH_ENABLE,
388 data_types: self.data_types.as_deref(),
389 push_state: self.push_state.as_deref(),
390 extra: &self.extra,
391 }
392 .serialize(s)
393 }
394}
395
396impl<'de> Deserialize<'de> for WebSocketPushEnable {
397 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
398 let r = PushEnableIn::deserialize(d)?;
399 check_type(r.ty, PUSH_ENABLE)?;
400 Ok(Self {
401 data_types: r.data_types,
402 push_state: r.push_state,
403 extra: r.extra,
404 })
405 }
406}
407
408#[non_exhaustive]
411#[derive(Debug, Clone, PartialEq, Eq, Default)]
412pub struct WebSocketPushDisable {
413 pub extra: Map<String, Value>,
415}
416
417impl WebSocketPushDisable {
418 pub fn new() -> Self {
420 Self::default()
421 }
422}
423
424#[derive(Serialize)]
425struct PushDisableOut<'a> {
426 #[serde(rename = "@type")]
427 ty: &'static str,
428 #[serde(flatten)]
429 extra: &'a Map<String, Value>,
430}
431
432#[derive(Deserialize)]
433struct PushDisableIn {
434 #[serde(rename = "@type", default)]
435 ty: Option<String>,
436 #[serde(flatten)]
437 extra: Map<String, Value>,
438}
439
440impl Serialize for WebSocketPushDisable {
441 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
442 PushDisableOut {
443 ty: PUSH_DISABLE,
444 extra: &self.extra,
445 }
446 .serialize(s)
447 }
448}
449
450impl<'de> Deserialize<'de> for WebSocketPushDisable {
451 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
452 let r = PushDisableIn::deserialize(d)?;
453 check_type(r.ty, PUSH_DISABLE)?;
454 Ok(Self { extra: r.extra })
455 }
456}
457
458fn from_object<T: DeserializeOwned, E: de::Error>(obj: Map<String, Value>) -> Result<T, E> {
465 serde_json::from_value(Value::Object(obj)).map_err(E::custom)
466}
467
468fn take_tag<E: de::Error>(obj: &Map<String, Value>) -> Result<String, E> {
469 match obj.get("@type") {
470 Some(Value::String(s)) => Ok(s.clone()),
471 Some(_) => Err(E::custom("`@type` is not a string")),
472 None => Err(E::missing_field("@type")),
473 }
474}
475
476#[non_exhaustive]
484#[derive(Debug, Clone, PartialEq)]
485pub enum ClientMessage {
486 Request(WsRequest),
488 PushEnable(WebSocketPushEnable),
490 PushDisable(WebSocketPushDisable),
492}
493
494impl Serialize for ClientMessage {
495 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
496 match self {
497 Self::Request(m) => m.serialize(s),
498 Self::PushEnable(m) => m.serialize(s),
499 Self::PushDisable(m) => m.serialize(s),
500 }
501 }
502}
503
504impl<'de> Deserialize<'de> for ClientMessage {
505 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
506 let obj = Map::deserialize(d)?;
507 match take_tag::<D::Error>(&obj)?.as_str() {
508 REQUEST => from_object(obj).map(Self::Request),
509 PUSH_ENABLE => from_object(obj).map(Self::PushEnable),
510 PUSH_DISABLE => from_object(obj).map(Self::PushDisable),
511 other => Err(de::Error::unknown_variant(
512 other,
513 &[REQUEST, PUSH_ENABLE, PUSH_DISABLE],
514 )),
515 }
516 }
517}
518
519#[non_exhaustive]
525#[derive(Debug, Clone, PartialEq)]
526pub enum ServerMessage {
527 Response(WsResponse),
529 RequestError(WsRequestError),
531 StateChange(WsStateChange),
533}
534
535impl Serialize for ServerMessage {
536 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
537 match self {
538 Self::Response(m) => m.serialize(s),
539 Self::RequestError(m) => m.serialize(s),
540 Self::StateChange(m) => m.serialize(s),
541 }
542 }
543}
544
545impl<'de> Deserialize<'de> for ServerMessage {
546 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
547 let obj = Map::deserialize(d)?;
548 match take_tag::<D::Error>(&obj)?.as_str() {
549 RESPONSE => from_object(obj).map(Self::Response),
550 REQUEST_ERROR => from_object(obj).map(Self::RequestError),
551 STATE_CHANGE => from_object(obj).map(Self::StateChange),
552 other => Err(de::Error::unknown_variant(
553 other,
554 &[RESPONSE, REQUEST_ERROR, STATE_CHANGE],
555 )),
556 }
557 }
558}
559
560#[cfg(test)]
561mod tests;