use serde::de::{self, DeserializeOwned};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{Map, Value};
use jmap_types::problem::ProblemDetails;
use jmap_types::{JmapRequest, JmapResponse, StateChange};
const REQUEST: &str = "Request";
const RESPONSE: &str = "Response";
const REQUEST_ERROR: &str = "RequestError";
const STATE_CHANGE: &str = "StateChange";
const PUSH_ENABLE: &str = "WebSocketPushEnable";
const PUSH_DISABLE: &str = "WebSocketPushDisable";
fn check_type<E: de::Error>(found: Option<String>, expected: &'static str) -> Result<(), E> {
match found {
None => Ok(()),
Some(t) if t == expected => Ok(()),
Some(t) => Err(E::invalid_value(de::Unexpected::Str(&t), &expected)),
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct WsRequest {
pub id: Option<String>,
pub request: JmapRequest,
}
impl WsRequest {
pub fn new(request: JmapRequest, id: Option<String>) -> Self {
Self { id, request }
}
}
#[derive(Serialize)]
struct RequestOut<'a> {
#[serde(rename = "@type")]
ty: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
id: Option<&'a str>,
#[serde(flatten)]
request: &'a JmapRequest,
}
#[derive(Deserialize)]
struct RequestIn {
#[serde(rename = "@type", default)]
ty: Option<String>,
#[serde(default)]
id: Option<String>,
#[serde(flatten)]
request: JmapRequest,
}
impl Serialize for WsRequest {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
RequestOut {
ty: REQUEST,
id: self.id.as_deref(),
request: &self.request,
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WsRequest {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = RequestIn::deserialize(d)?;
check_type(r.ty, REQUEST)?;
Ok(Self {
id: r.id,
request: r.request,
})
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct WsResponse {
pub request_id: Option<String>,
pub response: JmapResponse,
}
impl WsResponse {
pub fn new(response: JmapResponse, request_id: Option<String>) -> Self {
Self {
request_id,
response,
}
}
}
#[derive(Serialize)]
struct ResponseOut<'a> {
#[serde(rename = "@type")]
ty: &'static str,
#[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
request_id: Option<&'a str>,
#[serde(flatten)]
response: &'a JmapResponse,
}
#[derive(Deserialize)]
struct ResponseIn {
#[serde(rename = "@type", default)]
ty: Option<String>,
#[serde(rename = "requestId", default)]
request_id: Option<String>,
#[serde(flatten)]
response: JmapResponse,
}
impl Serialize for WsResponse {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
ResponseOut {
ty: RESPONSE,
request_id: self.request_id.as_deref(),
response: &self.response,
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WsResponse {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = ResponseIn::deserialize(d)?;
check_type(r.ty, RESPONSE)?;
Ok(Self {
request_id: r.request_id,
response: r.response,
})
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct WsRequestError {
pub request_id: Option<String>,
pub problem: ProblemDetails,
}
impl WsRequestError {
pub fn new(problem: ProblemDetails, request_id: Option<String>) -> Self {
Self {
request_id,
problem,
}
}
}
#[derive(Serialize)]
struct RequestErrorOut<'a> {
#[serde(rename = "@type")]
ty: &'static str,
#[serde(rename = "requestId")]
request_id: Option<&'a str>,
#[serde(flatten)]
problem: &'a ProblemDetails,
}
#[derive(Deserialize)]
struct RequestErrorIn {
#[serde(rename = "@type", default)]
ty: Option<String>,
#[serde(rename = "requestId", default)]
request_id: Option<String>,
#[serde(flatten)]
problem: ProblemDetails,
}
impl Serialize for WsRequestError {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
RequestErrorOut {
ty: REQUEST_ERROR,
request_id: self.request_id.as_deref(),
problem: &self.problem,
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WsRequestError {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = RequestErrorIn::deserialize(d)?;
check_type(r.ty, REQUEST_ERROR)?;
Ok(Self {
request_id: r.request_id,
problem: r.problem,
})
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WsStateChange {
pub push_state: Option<String>,
pub state_change: StateChange,
}
impl WsStateChange {
pub fn new(state_change: StateChange, push_state: Option<String>) -> Self {
Self {
push_state,
state_change,
}
}
}
#[derive(Serialize)]
struct StateChangeOut<'a> {
#[serde(flatten)]
state_change: &'a StateChange,
#[serde(rename = "pushState", skip_serializing_if = "Option::is_none")]
push_state: Option<&'a str>,
}
#[derive(Deserialize)]
struct StateChangeIn {
#[serde(rename = "pushState", default)]
push_state: Option<String>,
#[serde(flatten)]
state_change: StateChange,
}
impl Serialize for WsStateChange {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
StateChangeOut {
state_change: &self.state_change,
push_state: self.push_state.as_deref(),
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WsStateChange {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = StateChangeIn::deserialize(d)?;
Ok(Self {
push_state: r.push_state,
state_change: r.state_change,
})
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct WebSocketPushEnable {
pub data_types: Option<Vec<String>>,
pub push_state: Option<String>,
pub extra: Map<String, Value>,
}
impl WebSocketPushEnable {
pub fn new(data_types: Option<Vec<String>>, push_state: Option<String>) -> Self {
Self {
data_types,
push_state,
extra: Map::new(),
}
}
}
#[derive(Serialize)]
struct PushEnableOut<'a> {
#[serde(rename = "@type")]
ty: &'static str,
#[serde(rename = "dataTypes")]
data_types: Option<&'a [String]>,
#[serde(rename = "pushState", skip_serializing_if = "Option::is_none")]
push_state: Option<&'a str>,
#[serde(flatten)]
extra: &'a Map<String, Value>,
}
#[derive(Deserialize)]
struct PushEnableIn {
#[serde(rename = "@type", default)]
ty: Option<String>,
#[serde(rename = "dataTypes", default)]
data_types: Option<Vec<String>>,
#[serde(rename = "pushState", default)]
push_state: Option<String>,
#[serde(flatten)]
extra: Map<String, Value>,
}
impl Serialize for WebSocketPushEnable {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
PushEnableOut {
ty: PUSH_ENABLE,
data_types: self.data_types.as_deref(),
push_state: self.push_state.as_deref(),
extra: &self.extra,
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WebSocketPushEnable {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = PushEnableIn::deserialize(d)?;
check_type(r.ty, PUSH_ENABLE)?;
Ok(Self {
data_types: r.data_types,
push_state: r.push_state,
extra: r.extra,
})
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct WebSocketPushDisable {
pub extra: Map<String, Value>,
}
impl WebSocketPushDisable {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Serialize)]
struct PushDisableOut<'a> {
#[serde(rename = "@type")]
ty: &'static str,
#[serde(flatten)]
extra: &'a Map<String, Value>,
}
#[derive(Deserialize)]
struct PushDisableIn {
#[serde(rename = "@type", default)]
ty: Option<String>,
#[serde(flatten)]
extra: Map<String, Value>,
}
impl Serialize for WebSocketPushDisable {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
PushDisableOut {
ty: PUSH_DISABLE,
extra: &self.extra,
}
.serialize(s)
}
}
impl<'de> Deserialize<'de> for WebSocketPushDisable {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let r = PushDisableIn::deserialize(d)?;
check_type(r.ty, PUSH_DISABLE)?;
Ok(Self { extra: r.extra })
}
}
fn from_object<T: DeserializeOwned, E: de::Error>(obj: Map<String, Value>) -> Result<T, E> {
serde_json::from_value(Value::Object(obj)).map_err(E::custom)
}
fn take_tag<E: de::Error>(obj: &Map<String, Value>) -> Result<String, E> {
match obj.get("@type") {
Some(Value::String(s)) => Ok(s.clone()),
Some(_) => Err(E::custom("`@type` is not a string")),
None => Err(E::missing_field("@type")),
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub enum ClientMessage {
Request(WsRequest),
PushEnable(WebSocketPushEnable),
PushDisable(WebSocketPushDisable),
}
impl Serialize for ClientMessage {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
match self {
Self::Request(m) => m.serialize(s),
Self::PushEnable(m) => m.serialize(s),
Self::PushDisable(m) => m.serialize(s),
}
}
}
impl<'de> Deserialize<'de> for ClientMessage {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let obj = Map::deserialize(d)?;
match take_tag::<D::Error>(&obj)?.as_str() {
REQUEST => from_object(obj).map(Self::Request),
PUSH_ENABLE => from_object(obj).map(Self::PushEnable),
PUSH_DISABLE => from_object(obj).map(Self::PushDisable),
other => Err(de::Error::unknown_variant(
other,
&[REQUEST, PUSH_ENABLE, PUSH_DISABLE],
)),
}
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub enum ServerMessage {
Response(WsResponse),
RequestError(WsRequestError),
StateChange(WsStateChange),
}
impl Serialize for ServerMessage {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
match self {
Self::Response(m) => m.serialize(s),
Self::RequestError(m) => m.serialize(s),
Self::StateChange(m) => m.serialize(s),
}
}
}
impl<'de> Deserialize<'de> for ServerMessage {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let obj = Map::deserialize(d)?;
match take_tag::<D::Error>(&obj)?.as_str() {
RESPONSE => from_object(obj).map(Self::Response),
REQUEST_ERROR => from_object(obj).map(Self::RequestError),
STATE_CHANGE => from_object(obj).map(Self::StateChange),
other => Err(de::Error::unknown_variant(
other,
&[RESPONSE, REQUEST_ERROR, STATE_CHANGE],
)),
}
}
}
#[cfg(test)]
mod tests;