Integrate generic event types and EventContent trait with TryFromRaw

ruma-events-macros/src/collection.rs

@@ -28,8 +28,8 @@ pub fn expand_collection(input: RumaCollectionInput) -> syn::Result<TokenStream>
 
     let collection = quote! {
         #( #attrs )*
-        #[derive(Clone, Debug, Serialize)]
+        #[derive(Clone, Debug, /*Serialize*/)]
-        #[serde(untagged)]
+        //#[serde(untagged)]
         #[allow(clippy::large_enum_variant)]
         pub enum #ident {
             #( #variants ),*

ruma-events-macros/src/event_content.rs

@@ -52,19 +52,18 @@ fn expand_room_event(input: DeriveInput) -> syn::Result<TokenStream> {
             fn event_type(&self) -> &str {
                 #event_type
             }
+        }
 
+        impl ::ruma_events::RawEventContent for raw::#ident {
             fn from_parts(
                 ev_type: &str,
                 content: Box<::serde_json::value::RawValue>
-            ) -> Result<Self, ::ruma_events::InvalidEvent> {
+            ) -> Result<Self, String> {
                 if ev_type != #event_type {
-                    return Err(
+                    return Err(format!("expected `{}` found {}", #event_type, ev_type));
-                        ::ruma_events::InvalidEvent::wrong_event_type(#event_type, ev_type)
-                    );
                 }
 
-                let ev_json = ::ruma_events::EventJson::from(content);
+                ::serde_json::from_str(content.get()).map_err(|e| e.to_string())
-                ev_json.deserialize()
             }
         }
     };

src/from_raw.rs

@@ -9,7 +9,7 @@ use serde::de::DeserializeOwned;
 /// [try]: trait.TryFromRaw.html
 pub trait FromRaw: Sized {
     /// The raw type.
-    type Raw: DeserializeOwned;
+    type Raw;
 
     /// Converts the raw type to `Self`.
     fn from_raw(_: Self::Raw) -> Self;
@@ -19,7 +19,7 @@ pub trait FromRaw: Sized {
 /// corresponding 'raw' type, a potentially invalid representation that can be converted to `Self`.
 pub trait TryFromRaw: Sized {
     /// The raw type.
-    type Raw: DeserializeOwned;
+    type Raw;
     /// The error type returned if conversion fails.
     type Err: Display;
 

src/json.rs

@@ -5,14 +5,14 @@ use std::{
 };
 
 use serde::{
-    de::{Deserialize, Deserializer},
+    de::{Deserialize, DeserializeOwned, Deserializer},
     ser::{Serialize, Serializer},
 };
 use serde_json::value::RawValue;
 
 use crate::{
     error::{InvalidEvent, InvalidEventKind},
-    TryFromRaw,
+    EventContent, RawEventContent, TryFromRaw,
 };
 
 /// A wrapper around `Box<RawValue>`, to be used in place of event [content] [collection] types in
@@ -42,7 +42,10 @@ impl<T> EventJson<T> {
     }
 }
 
-impl<T: TryFromRaw> EventJson<T> {
+impl<T: TryFromRaw> EventJson<T>
+where
+    T::Raw: DeserializeOwned,
+{
     /// Try to deserialize the JSON into the expected event type.
     pub fn deserialize(&self) -> Result<T, InvalidEvent> {
         let raw_ev: T::Raw = match serde_json::from_str(self.json.get()) {
@@ -65,6 +68,32 @@ impl<T: TryFromRaw> EventJson<T> {
     }
 }
 
+impl<T: EventContent> EventJson<T>
+where
+    T::Raw: RawEventContent,
+{
+    /// Try to deserialize the JSON as event content
+    pub fn deserialize_content(self, event_type: &str) -> Result<T, InvalidEvent> {
+        let raw_content = match T::Raw::from_parts(event_type, self.json) {
+            Ok(raw) => raw,
+            Err(message) => {
+                return Err(InvalidEvent {
+                    message,
+                    kind: InvalidEventKind::Deserialization,
+                });
+            }
+        };
+
+        match T::try_from_raw(raw_content) {
+            Ok(value) => Ok(value),
+            Err(err) => Err(InvalidEvent {
+                message: err.to_string(),
+                kind: InvalidEventKind::Validation,
+            }),
+        }
+    }
+}
+
 impl<T: Serialize> From<&T> for EventJson<T> {
     fn from(val: &T) -> Self {
         Self::new(serde_json::value::to_raw_value(val).unwrap())

src/lib.rs

@@ -168,7 +168,7 @@ pub use self::{
     event_type::EventType,
     from_raw::{FromRaw, TryFromRaw},
     json::EventJson,
-    state::{AnyStateEventContent, StateEvent},
+    state::StateEvent,
 };
 
 /// Extra information about an event that is not incorporated into the event's
@@ -207,19 +207,37 @@ impl UnsignedData {
 /// The base trait that all event content types implement.
 ///
 /// Implementing this trait allows content types to be serialized as well as deserialized.
-pub trait EventContent: Sized + Serialize {
+pub trait EventContent: TryFromRaw + Serialize
-    /// Constructs the given event content.
+where
-    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, InvalidEvent>;
+    Self::Raw: RawEventContent,
-
+{
     /// A matrix event identifier, like `m.room.message`.
     fn event_type(&self) -> &str;
 }
 
+#[doc(hidden)]
+pub trait RawEventContent: Sized {
+    /// Constructs the given event content.
+    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, String>;
+}
+
 /// Marker trait for the content of a room event.
-pub trait RoomEventContent: EventContent {}
+pub trait RoomEventContent: EventContent
+where
+    Self::Raw: RawEventContent,
+{
+}
 
 /// Marker trait for the content of a message event.
-pub trait MessageEventContent: RoomEventContent {}
+pub trait MessageEventContent: RoomEventContent
+where
+    Self::Raw: RawEventContent,
+{
+}
 
 /// Marker trait for the content of a state event.
-pub trait StateEventContent: RoomEventContent {}
+pub trait StateEventContent: RoomEventContent
+where
+    Self::Raw: RawEventContent,
+{
+}

src/room.rs

@@ -16,7 +16,7 @@ pub mod encryption;
 pub mod guest_access;
 pub mod history_visibility;
 pub mod join_rules;
-// pub mod member;
+pub mod member;
 // pub mod message;
 // pub mod name;
 // pub mod pinned_events;

src/room/member.rs

@@ -7,6 +7,8 @@ use ruma_identifiers::UserId;
 use serde::{Deserialize, Serialize};
 use strum::{Display, EnumString};
 
+use crate::StateEvent;
+
 /// The current membership state of a user in the room.
 ///
 /// Adjusts the membership state for a user in a room. It is preferable to use the membership
@@ -150,44 +152,44 @@ pub enum MembershipChange {
     NotImplemented,
 }
 
-// impl MemberEvent {
+impl StateEvent<MemberEventContent> {
-//     /// Helper function for membership change. Check [the specification][spec] for details.
+    /// Helper function for membership change. Check [the specification][spec] for details.
-//     ///
+    ///
-//     /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
+    /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
-//     pub fn membership_change(&self) -> MembershipChange {
+    pub fn membership_change(&self) -> MembershipChange {
-//         use MembershipState::*;
+        use MembershipState::*;
-//         let prev_membership = if let Some(prev_content) = &self.prev_content {
+        let prev_membership = if let Some(prev_content) = &self.prev_content {
-//             prev_content.membership
+            prev_content.membership
-//         } else {
+        } else {
-//             Leave
+            Leave
-//         };
+        };
-//         match (prev_membership, &self.content.membership) {
+        match (prev_membership, &self.content.membership) {
-//             (Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None,
+            (Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None,
-//             (Invite, Join) | (Leave, Join) => MembershipChange::Joined,
+            (Invite, Join) | (Leave, Join) => MembershipChange::Joined,
-//             (Invite, Leave) => {
+            (Invite, Leave) => {
-//                 if self.sender == self.state_key {
+                if self.sender == self.state_key {
-//                     MembershipChange::InvitationRevoked
+                    MembershipChange::InvitationRevoked
-//                 } else {
+                } else {
-//                     MembershipChange::InvitationRejected
+                    MembershipChange::InvitationRejected
-//                 }
+                }
-//             }
+            }
-//             (Invite, Ban) | (Leave, Ban) => MembershipChange::Banned,
+            (Invite, Ban) | (Leave, Ban) => MembershipChange::Banned,
-//             (Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error,
+            (Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error,
-//             (Join, Join) => MembershipChange::ProfileChanged,
+            (Join, Join) => MembershipChange::ProfileChanged,
-//             (Join, Leave) => {
+            (Join, Leave) => {
-//                 if self.sender == self.state_key {
+                if self.sender == self.state_key {
-//                     MembershipChange::Left
+                    MembershipChange::Left
-//                 } else {
+                } else {
-//                     MembershipChange::Kicked
+                    MembershipChange::Kicked
-//                 }
+                }
-//             }
+            }
-//             (Join, Ban) => MembershipChange::KickedAndBanned,
+            (Join, Ban) => MembershipChange::KickedAndBanned,
-//             (Leave, Invite) => MembershipChange::Invited,
+            (Leave, Invite) => MembershipChange::Invited,
-//             (Ban, Leave) => MembershipChange::Unbanned,
+            (Ban, Leave) => MembershipChange::Unbanned,
-//             (Knock, _) | (_, Knock) => MembershipChange::NotImplemented,
+            (Knock, _) | (_, Knock) => MembershipChange::NotImplemented,
-//         }
+        }
-//     }
+    }
-// }
+}
 
 #[cfg(test)]
 mod tests {
@@ -197,10 +199,8 @@ mod tests {
     use matches::assert_matches;
     use serde_json::{from_value as from_json_value, json};
 
-    use super::{
+    use super::{MemberEventContent, MembershipState, SignedContent, ThirdPartyInvite};
-        MemberEvent, MemberEventContent, MembershipState, SignedContent, ThirdPartyInvite,
+    use crate::{EventJson, StateEvent};
-    };
-    use crate::EventJson;
 
     #[test]
     fn serde_with_no_prev_content() {
@@ -217,11 +217,11 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<EventJson<MemberEvent>>(json)
+            from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
                 .unwrap()
                 .deserialize()
                 .unwrap(),
-            MemberEvent {
+            StateEvent::<MemberEventContent> {
                 content: MemberEventContent {
                     avatar_url: None,
                     displayname: None,
@@ -231,7 +231,7 @@ mod tests {
                 },
                 event_id,
                 origin_server_ts,
-                room_id: Some(room_id),
+                room_id,
                 sender,
                 state_key,
                 unsigned,
@@ -263,11 +263,11 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<EventJson<MemberEvent>>(json)
+            from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
                 .unwrap()
                 .deserialize()
                 .unwrap(),
-            MemberEvent {
+            StateEvent::<MemberEventContent> {
                 content: MemberEventContent {
                     avatar_url: None,
                     displayname: None,
@@ -277,7 +277,7 @@ mod tests {
                 },
                 event_id,
                 origin_server_ts,
-                room_id: Some(room_id),
+                room_id,
                 sender,
                 state_key,
                 unsigned,
@@ -327,11 +327,11 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<EventJson<MemberEvent>>(json)
+            from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
                 .unwrap()
                 .deserialize()
                 .unwrap(),
-            MemberEvent {
+            StateEvent::<MemberEventContent> {
                 content: MemberEventContent {
                     avatar_url: Some(avatar_url),
                     displayname: Some(displayname),
@@ -344,7 +344,7 @@ mod tests {
                 },
                 event_id,
                 origin_server_ts,
-                room_id: Some(room_id),
+                room_id,
                 sender,
                 state_key,
                 unsigned,
@@ -401,11 +401,11 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<EventJson<MemberEvent>>(json)
+            from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
                 .unwrap()
                 .deserialize()
                 .unwrap(),
-            MemberEvent {
+            StateEvent::<MemberEventContent> {
                 content: MemberEventContent {
                     avatar_url: None,
                     displayname: None,
@@ -415,7 +415,7 @@ mod tests {
                 },
                 event_id,
                 origin_server_ts,
-                room_id: Some(room_id),
+                room_id,
                 sender,
                 state_key,
                 unsigned,

src/state.rs

@@ -20,7 +20,8 @@ use serde_json::value::RawValue as RawJsonValue;
 use crate::{
     error::{InvalidEvent, InvalidEventKind},
     room::{aliases::AliasesEventContent, avatar::AvatarEventContent},
-    EventContent, RoomEventContent, StateEventContent, TryFromRaw, UnsignedData,
+    EventContent, FromRaw, RawEventContent, RoomEventContent, StateEventContent, TryFromRaw,
+    UnsignedData,
 };
 use ruma_events_macros::event_content_collection;
 
@@ -32,7 +33,10 @@ event_content_collection! {
 
 /// State event.
 #[derive(Clone, Debug)]
-pub struct StateEvent<C: StateEventContent> {
+pub struct StateEvent<C: StateEventContent>
+where
+    C::Raw: RawEventContent,
+{
     /// Data specific to the event type.
     pub content: C,
 
@@ -61,6 +65,31 @@ pub struct StateEvent<C: StateEventContent> {
     pub unsigned: UnsignedData,
 }
 
+impl FromRaw for AnyStateEventContent {
+    type Raw = raw::AnyStateEventContent;
+
+    fn from_raw(raw: Self::Raw) -> Self {
+        use raw::AnyStateEventContent::*;
+
+        match raw {
+            RoomAliases(c) => Self::RoomAliases(FromRaw::from_raw(c)),
+            RoomAvatar(c) => Self::RoomAvatar(FromRaw::from_raw(c)),
+        }
+    }
+}
+
+impl Serialize for AnyStateEventContent {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            AnyStateEventContent::RoomAliases(content) => content.serialize(serializer),
+            AnyStateEventContent::RoomAvatar(content) => content.serialize(serializer),
+        }
+    }
+}
+
 impl EventContent for AnyStateEventContent {
     fn event_type(&self) -> &str {
         match self {
@@ -68,41 +97,38 @@ impl EventContent for AnyStateEventContent {
             AnyStateEventContent::RoomAvatar(content) => content.event_type(),
         }
     }
-
-    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, InvalidEvent> {
-        fn deserialize_variant<T: StateEventContent>(
-            ev_type: &str,
-            input: Box<RawJsonValue>,
-            variant: fn(T) -> AnyStateEventContent,
-        ) -> Result<AnyStateEventContent, InvalidEvent> {
-            let content = T::from_parts(ev_type, input)?;
-            Ok(variant(content))
-        }
-
-        match event_type {
-            "m.room.avatar" => deserialize_variant::<AvatarEventContent>(
-                event_type,
-                content,
-                AnyStateEventContent::RoomAvatar,
-            ),
-            "m.room.aliases" => deserialize_variant::<AliasesEventContent>(
-                event_type,
-                content,
-                AnyStateEventContent::RoomAliases,
-            ),
-            ev => Err(InvalidEvent {
-                kind: InvalidEventKind::Deserialization,
-                message: format!("event not supported {}", ev),
-            }),
-        }
-    }
 }
 
 impl RoomEventContent for AnyStateEventContent {}
 
 impl StateEventContent for AnyStateEventContent {}
 
-impl<C: StateEventContent> Serialize for StateEvent<C> {
+impl<C> TryFromRaw for StateEvent<C>
+where
+    C: StateEventContent + TryFromRaw,
+    C::Raw: RawEventContent,
+{
+    type Raw = raw::StateEvent<C::Raw>;
+    type Err = C::Err;
+
+    fn try_from_raw(raw: Self::Raw) -> Result<Self, Self::Err> {
+        Ok(Self {
+            content: C::try_from_raw(raw.content)?,
+            event_id: raw.event_id,
+            sender: raw.sender,
+            origin_server_ts: raw.origin_server_ts,
+            room_id: raw.room_id,
+            state_key: raw.state_key,
+            prev_content: raw.prev_content.map(C::try_from_raw).transpose()?,
+            unsigned: raw.unsigned,
+        })
+    }
+}
+
+impl<C: StateEventContent> Serialize for StateEvent<C>
+where
+    C::Raw: RawEventContent,
+{
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -130,7 +156,95 @@ impl<C: StateEventContent> Serialize for StateEvent<C> {
     }
 }
 
-impl<'de, C: StateEventContent> Deserialize<'de> for StateEvent<C> {
+mod raw {
+    use std::{
+        fmt,
+        marker::PhantomData,
+        time::{Duration, SystemTime, UNIX_EPOCH},
+    };
+
+    use js_int::UInt;
+    use ruma_events_macros::event_content_collection;
+    use ruma_identifiers::{EventId, RoomId, UserId};
+    use serde::{
+        de::{self, Deserialize, Deserializer, Error as _, MapAccess, Visitor},
+        Serialize,
+    };
+    use serde_json::value::RawValue as RawJsonValue;
+
+    use crate::{
+        room::{aliases::raw::AliasesEventContent, avatar::raw::AvatarEventContent},
+        RawEventContent, UnsignedData,
+    };
+
+    event_content_collection! {
+        /// A state event.
+        name: AnyStateEventContent,
+        events: ["m.room.aliases", "m.room.avatar"]
+    }
+
+    impl RawEventContent for AnyStateEventContent {
+        fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, String> {
+            fn deserialize_variant<T: RawEventContent>(
+                ev_type: &str,
+                input: Box<RawJsonValue>,
+                variant: fn(T) -> AnyStateEventContent,
+            ) -> Result<AnyStateEventContent, String> {
+                let content = T::from_parts(ev_type, input)?;
+                Ok(variant(content))
+            }
+
+            match event_type {
+                "m.room.avatar" => deserialize_variant::<AvatarEventContent>(
+                    event_type,
+                    content,
+                    AnyStateEventContent::RoomAvatar,
+                ),
+                "m.room.aliases" => deserialize_variant::<AliasesEventContent>(
+                    event_type,
+                    content,
+                    AnyStateEventContent::RoomAliases,
+                ),
+                ev => Err(format!("event not supported {}", ev)),
+            }
+        }
+    }
+
+    /// State event.
+    #[derive(Clone, Debug)]
+    pub struct StateEvent<C> {
+        /// Data specific to the event type.
+        pub content: C,
+
+        /// The globally unique event identifier for the user who sent the event.
+        pub event_id: EventId,
+
+        /// Contains the fully-qualified ID of the user who sent this event.
+        pub sender: UserId,
+
+        /// Timestamp in milliseconds on originating homeserver when this event was sent.
+        pub origin_server_ts: SystemTime,
+
+        /// The ID of the room associated with this event.
+        pub room_id: RoomId,
+
+        /// A unique key which defines the overwriting semantics for this piece of room state.
+        ///
+        /// This is often an empty string, but some events send a `UserId` to show
+        /// which user the event affects.
+        pub state_key: String,
+
+        /// Optional previous content for this event.
+        pub prev_content: Option<C>,
+
+        /// Additional key-value pairs not signed by the homeserver.
+        pub unsigned: UnsignedData,
+    }
+
+    impl<'de, C> Deserialize<'de> for StateEvent<C>
+    where
+        C: RawEventContent,
+    {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where
             D: Deserializer<'de>,
@@ -155,9 +269,12 @@ enum Field {
 
     /// Visits the fields of a StateEvent<C> to handle deserialization of
     /// the `content` and `prev_content` fields.
-struct StateEventVisitor<C: StateEventContent>(PhantomData<C>);
+    struct StateEventVisitor<C>(PhantomData<C>);
 
-impl<'de, C: StateEventContent> Visitor<'de> for StateEventVisitor<C> {
+    impl<'de, C> Visitor<'de> for StateEventVisitor<C>
+    where
+        C: RawEventContent,
+    {
         type Value = StateEvent<C>;
 
         fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -272,6 +389,7 @@ impl<'de, C: StateEventContent> Visitor<'de> for StateEventVisitor<C> {
             })
         }
     }
+}
 
 #[cfg(test)]
 mod tests {
@@ -288,7 +406,7 @@ mod tests {
     use super::{AliasesEventContent, AnyStateEventContent, AvatarEventContent, StateEvent};
     use crate::{
         room::{ImageInfo, ThumbnailInfo},
-        UnsignedData,
+        EventJson, UnsignedData,
     };
 
     #[test]
@@ -358,6 +476,22 @@ mod tests {
         assert_eq!(actual, expected);
     }
 
+    #[test]
+    fn deserialize_aliases_content() {
+        let json_data = json!({
+            "aliases": [ "#somewhere:localhost" ]
+        });
+
+        assert_matches!(
+            from_json_value::<EventJson<AnyStateEventContent>>(json_data)
+                .unwrap()
+                .deserialize_content("m.room.aliases")
+                .unwrap(),
+            AnyStateEventContent::RoomAliases(content)
+            if content.aliases == vec![RoomAliasId::try_from("#somewhere:localhost").unwrap()]
+        );
+    }
+
     #[test]
     fn deserialize_aliases_with_prev_content() {
         let json_data = json!({
@@ -376,7 +510,10 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<AnyStateEventContent>>(json_data).unwrap(),
+            from_json_value::<EventJson<StateEvent<AnyStateEventContent>>>(json_data)
+                .unwrap()
+                .deserialize()
+                .unwrap(),
             StateEvent {
                 content: AnyStateEventContent::RoomAliases(content),
                 event_id,
@@ -425,7 +562,10 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<AnyStateEventContent>>(json_data).unwrap(),
+            from_json_value::<EventJson<StateEvent<AnyStateEventContent>>>(json_data)
+                .unwrap()
+                .deserialize()
+                .unwrap(),
             StateEvent {
                 content: AnyStateEventContent::RoomAvatar(AvatarEventContent {
                     info: Some(info),