use event content in account_data service api instead of full events

This eliminates the possibility of passing an event that has a
mismatching type, reducing the space of possible invalid states.

src/api/client_server/account.rs

@@ -12,8 +12,7 @@ use ruma::{
         uiaa::{AuthFlow, AuthType, UiaaInfo},
     },
     events::{
-        room::message::RoomMessageEventContent, AnyGlobalAccountDataEvent,
-        GlobalAccountDataEventType,
+        room::message::RoomMessageEventContent, GlobalAccountDataEventType,
     },
     push,
     serde::Raw,
@@ -240,13 +239,13 @@ pub(crate) async fn register_route(
     services().account_data.update_global(
         &user_id,
         &GlobalAccountDataEventType::PushRules,
-        &Raw::new(&ruma::events::push_rules::PushRulesEvent {
-            content: ruma::events::push_rules::PushRulesEventContent {
+        &Raw::new(
+            &ruma::events::push_rules::PushRulesEventContent {
                 global: push::Ruleset::server_default(&user_id),
-            },
-        })
-        .expect("constructed event should be valid")
-        .cast::<AnyGlobalAccountDataEvent>(),
+            }
+            .into(),
+        )
+        .expect("constructed event should be valid"),
     )?;
 
     // Inhibit login does not work for guests

src/api/client_server/config.rs

@@ -1,19 +1,10 @@
-use ruma::{
-    api::client::{
-        config::{
-            get_global_account_data, get_room_account_data,
-            set_global_account_data, set_room_account_data,
-        },
-        error::ErrorKind,
+use ruma::api::client::{
+    config::{
+        get_global_account_data, get_room_account_data,
+        set_global_account_data, set_room_account_data,
     },
-    events::{
-        AnyGlobalAccountDataEvent, AnyGlobalAccountDataEventContent,
-        AnyRoomAccountDataEvent, AnyRoomAccountDataEventContent,
-    },
-    serde::Raw,
+    error::ErrorKind,
 };
-use serde::Deserialize;
-use serde_json::json;
 
 use crate::{services, Ar, Error, Ra, Result};
 
@@ -25,17 +16,10 @@ pub(crate) async fn set_global_account_data_route(
 ) -> Result<Ra<set_global_account_data::v3::Response>> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = Raw::new(&json!({
-        "type": &body.event_type,
-        "content": &body.data,
-    }))
-    .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?
-    .cast::<AnyGlobalAccountDataEvent>();
-
     services().account_data.update_global(
         sender_user,
         &body.event_type,
-        &event,
+        &body.data,
     )?;
 
     Ok(Ra(set_global_account_data::v3::Response {}))
@@ -49,18 +33,11 @@ pub(crate) async fn set_room_account_data_route(
 ) -> Result<Ra<set_room_account_data::v3::Response>> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = Raw::new(&json!({
-        "type": &body.event_type,
-        "content": &body.data,
-    }))
-    .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?
-    .cast::<AnyRoomAccountDataEvent>();
-
     services().account_data.update_room(
         &body.room_id,
         sender_user,
         &body.event_type,
-        &event,
+        &body.data,
     )?;
 
     Ok(Ra(set_room_account_data::v3::Response {}))
@@ -74,16 +51,11 @@ pub(crate) async fn get_global_account_data_route(
 ) -> Result<Ra<get_global_account_data::v3::Response>> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = services()
+    let account_data = services()
         .account_data
         .get_global(sender_user, &body.event_type)?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
 
-    let account_data = event
-        .deserialize_as::<ExtractGlobalEventContent>()
-        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
-        .content;
-
     Ok(Ra(get_global_account_data::v3::Response {
         account_data,
     }))
@@ -97,27 +69,12 @@ pub(crate) async fn get_room_account_data_route(
 ) -> Result<Ra<get_room_account_data::v3::Response>> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = services()
+    let account_data = services()
         .account_data
         .get_room(&body.room_id, sender_user, &body.event_type)?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
 
-    let account_data = event
-        .deserialize_as::<ExtractRoomEventContent>()
-        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
-        .content;
-
     Ok(Ra(get_room_account_data::v3::Response {
         account_data,
     }))
 }
-
-#[derive(Deserialize)]
-struct ExtractRoomEventContent {
-    content: Raw<AnyRoomAccountDataEventContent>,
-}
-
-#[derive(Deserialize)]
-struct ExtractGlobalEventContent {
-    content: Raw<AnyGlobalAccountDataEventContent>,
-}

src/api/client_server/push.rs

@@ -7,10 +7,7 @@ use ruma::{
             set_pushrule_actions, set_pushrule_enabled,
         },
     },
-    events::{
-        push_rules::PushRulesEvent, AnyGlobalAccountDataEvent,
-        GlobalAccountDataEventType,
-    },
+    events::{push_rules::PushRulesEventContent, GlobalAccountDataEventType},
     push::{AnyPushRuleRef, InsertPushRuleError, RemovePushRuleError},
     serde::Raw,
 };
@@ -33,10 +30,10 @@ pub(crate) async fn get_pushrules_all_route(
             "PushRules event not found.",
         ))?;
 
-    let account_data = event
-        .deserialize_as::<PushRulesEvent>()
-        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
-        .content;
+    let account_data =
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
+            Error::bad_database("Invalid account data event in db.")
+        })?;
 
     Ok(Ra(get_pushrules_all::v3::Response {
         global: account_data.global,
@@ -59,10 +56,10 @@ pub(crate) async fn get_pushrule_route(
             "PushRules event not found.",
         ))?;
 
-    let account_data = event
-        .deserialize_as::<PushRulesEvent>()
-        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
-        .content;
+    let account_data =
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
+            Error::bad_database("Invalid account data event in db.")
+        })?;
 
     let rule = account_data
         .global
@@ -96,11 +93,11 @@ pub(crate) async fn set_pushrule_route(
         ))?;
 
     let mut account_data =
-        event.deserialize_as::<PushRulesEvent>().map_err(|_| {
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
             Error::bad_database("Invalid account data event in db.")
         })?;
 
-    if let Err(error) = account_data.content.global.insert(
+    if let Err(error) = account_data.global.insert(
         body.rule.clone(),
         body.after.as_deref(),
         body.before.as_deref(),
@@ -139,9 +136,8 @@ pub(crate) async fn set_pushrule_route(
     services().account_data.update_global(
         sender_user,
         &GlobalAccountDataEventType::PushRules,
-        &Raw::new(&account_data)
-            .expect("json event serialization should always succeed")
-            .cast::<AnyGlobalAccountDataEvent>(),
+        &Raw::new(&account_data.into())
+            .expect("json event serialization should always succeed"),
     )?;
 
     Ok(Ra(set_pushrule::v3::Response {}))
@@ -163,10 +159,10 @@ pub(crate) async fn get_pushrule_actions_route(
             "PushRules event not found.",
         ))?;
 
-    let account_data = event
-        .deserialize_as::<PushRulesEvent>()
-        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
-        .content;
+    let account_data =
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
+            Error::bad_database("Invalid account data event in db.")
+        })?;
 
     let global = account_data.global;
     let actions = global
@@ -199,12 +195,11 @@ pub(crate) async fn set_pushrule_actions_route(
         ))?;
 
     let mut account_data =
-        event.deserialize_as::<PushRulesEvent>().map_err(|_| {
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
             Error::bad_database("Invalid account data event in db.")
         })?;
 
     if account_data
-        .content
         .global
         .set_actions(body.kind.clone(), &body.rule_id, body.actions.clone())
         .is_err()
@@ -218,9 +213,8 @@ pub(crate) async fn set_pushrule_actions_route(
     services().account_data.update_global(
         sender_user,
         &GlobalAccountDataEventType::PushRules,
-        &Raw::new(&account_data)
-            .expect("json event serialization should always suceed")
-            .cast::<AnyGlobalAccountDataEvent>(),
+        &Raw::new(&account_data.into())
+            .expect("json event serialization should always suceed"),
     )?;
 
     Ok(Ra(set_pushrule_actions::v3::Response {}))
@@ -243,11 +237,11 @@ pub(crate) async fn get_pushrule_enabled_route(
         ))?;
 
     let account_data =
-        event.deserialize_as::<PushRulesEvent>().map_err(|_| {
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
             Error::bad_database("Invalid account data event in db.")
         })?;
 
-    let global = account_data.content.global;
+    let global = account_data.global;
     let enabled = global
         .get(body.kind.clone(), &body.rule_id)
         .map(AnyPushRuleRef::enabled)
@@ -278,12 +272,11 @@ pub(crate) async fn set_pushrule_enabled_route(
         ))?;
 
     let mut account_data =
-        event.deserialize_as::<PushRulesEvent>().map_err(|_| {
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
             Error::bad_database("Invalid account data event in db.")
         })?;
 
     if account_data
-        .content
         .global
         .set_enabled(body.kind.clone(), &body.rule_id, body.enabled)
         .is_err()
@@ -297,9 +290,8 @@ pub(crate) async fn set_pushrule_enabled_route(
     services().account_data.update_global(
         sender_user,
         &GlobalAccountDataEventType::PushRules,
-        &Raw::new(&account_data)
-            .expect("json event serialization should always succeed")
-            .cast::<AnyGlobalAccountDataEvent>(),
+        &Raw::new(&account_data.into())
+            .expect("json event serialization should always succeed"),
     )?;
 
     Ok(Ra(set_pushrule_enabled::v3::Response {}))
@@ -322,12 +314,12 @@ pub(crate) async fn delete_pushrule_route(
         ))?;
 
     let mut account_data =
-        event.deserialize_as::<PushRulesEvent>().map_err(|_| {
+        event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
             Error::bad_database("Invalid account data event in db.")
         })?;
 
     if let Err(error) =
-        account_data.content.global.remove(body.kind.clone(), &body.rule_id)
+        account_data.global.remove(body.kind.clone(), &body.rule_id)
     {
         let err = match error {
             RemovePushRuleError::ServerDefault => Error::BadRequest(
@@ -346,9 +338,8 @@ pub(crate) async fn delete_pushrule_route(
     services().account_data.update_global(
         sender_user,
         &GlobalAccountDataEventType::PushRules,
-        &Raw::new(&account_data)
-            .expect("json event serialization should always suceed")
-            .cast::<AnyGlobalAccountDataEvent>(),
+        &Raw::new(&account_data.into())
+            .expect("json event serialization should always suceed"),
     )?;
 
     Ok(Ra(delete_pushrule::v3::Response {}))

src/api/client_server/read_marker.rs

@@ -6,7 +6,7 @@ use ruma::{
     },
     events::{
         receipt::{ReceiptThread, ReceiptType},
-        AnyRoomAccountDataEvent, RoomAccountDataEventType,
+        RoomAccountDataEventType,
     },
     serde::Raw,
     MilliSecondsSinceUnixEpoch,
@@ -29,18 +29,16 @@ pub(crate) async fn set_read_marker_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     if let Some(fully_read) = &body.fully_read {
-        let fully_read_event = ruma::events::fully_read::FullyReadEvent {
-            content: ruma::events::fully_read::FullyReadEventContent {
+        let fully_read_event =
+            ruma::events::fully_read::FullyReadEventContent {
                 event_id: fully_read.clone(),
-            },
-        };
+            };
         services().account_data.update_room(
             &body.room_id,
             sender_user,
             &RoomAccountDataEventType::FullyRead,
-            &Raw::new(&fully_read_event)
-                .expect("json event serialization should always suceed")
-                .cast::<AnyRoomAccountDataEvent>(),
+            &Raw::new(&fully_read_event.into())
+                .expect("json event serialization should always suceed"),
         )?;
     }
 
@@ -126,18 +124,16 @@ pub(crate) async fn create_receipt_route(
 
     match body.receipt_type {
         create_receipt::v3::ReceiptType::FullyRead => {
-            let fully_read_event = ruma::events::fully_read::FullyReadEvent {
-                content: ruma::events::fully_read::FullyReadEventContent {
+            let fully_read_event =
+                ruma::events::fully_read::FullyReadEventContent {
                     event_id: body.event_id.clone(),
-                },
-            };
+                };
             services().account_data.update_room(
                 &body.room_id,
                 sender_user,
                 &RoomAccountDataEventType::FullyRead,
-                &Raw::new(&fully_read_event)
-                    .expect("json event serialization should always succeed")
-                    .cast::<AnyRoomAccountDataEvent>(),
+                &Raw::new(&fully_read_event.into())
+                    .expect("json event serialization should always succeed"),
             )?;
         }
         create_receipt::v3::ReceiptType::Read => {

src/api/client_server/sync/msc3575.rs

@@ -25,7 +25,8 @@ use tracing::{debug, error};
 
 use super::{load_timeline, share_encrypted_room};
 use crate::{
-    service::rooms::timeline::PduCount, services, Ar, Error, Ra, Result,
+    service::{account_data, rooms::timeline::PduCount},
+    services, Ar, Error, Ra, Result,
 };
 
 #[allow(clippy::too_many_lines)]
@@ -645,7 +646,13 @@ pub(crate) async fn sync_events_v4_route(
                     services()
                         .account_data
                         .global_changes_since(&sender_user, globalsince)?
-                        .into_values()
+                        .into_iter()
+                        .map(|(event_type, content)| {
+                            account_data::raw_global_event_from_parts(
+                                &event_type,
+                                &content,
+                            )
+                        })
                         .collect()
                 } else {
                     Vec::new()

src/api/client_server/sync/v3.rs

@@ -27,7 +27,7 @@ use tracing::{debug, error, field};
 
 use super::{load_timeline, share_encrypted_room};
 use crate::{
-    service::{pdu::EventHash, rooms::timeline::PduCount},
+    service::{account_data, pdu::EventHash, rooms::timeline::PduCount},
     services, utils, Ar, Error, PduEvent, Ra, Result,
 };
 
@@ -235,7 +235,13 @@ pub(crate) async fn sync_events_route(
             events: services()
                 .account_data
                 .global_changes_since(ctx.sender_user, ctx.since)?
-                .into_values()
+                .into_iter()
+                .map(|(event_type, content)| {
+                    account_data::raw_global_event_from_parts(
+                        &event_type,
+                        &content,
+                    )
+                })
                 .collect(),
         },
         device_lists: DeviceLists {
@@ -872,7 +878,13 @@ async fn load_joined_room(
             events: services()
                 .account_data
                 .room_changes_since(ctx.sender_user, room_id, ctx.since)?
-                .into_values()
+                .into_iter()
+                .map(|(event_type, content)| {
+                    account_data::raw_room_event_from_parts(
+                        &event_type,
+                        &content,
+                    )
+                })
                 .collect(),
         },
         summary: RoomSummary {

src/api/client_server/tag.rs

@@ -2,10 +2,7 @@ use std::collections::BTreeMap;
 
 use ruma::{
     api::client::tag::{create_tag, delete_tag, get_tags},
-    events::{
-        tag::{TagEvent, TagEventContent},
-        AnyRoomAccountDataEvent, RoomAccountDataEventType,
-    },
+    events::{tag::TagEventContent, RoomAccountDataEventType},
     serde::Raw,
 };
 
@@ -29,31 +26,25 @@ pub(crate) async fn update_tag_route(
 
     let mut tags_event = event.map_or_else(
         || {
-            Ok(TagEvent {
-                content: TagEventContent {
-                    tags: BTreeMap::new(),
-                },
+            Ok(TagEventContent {
+                tags: BTreeMap::new(),
             })
         },
         |e| {
-            e.deserialize_as::<TagEvent>().map_err(|_| {
+            e.deserialize_as::<TagEventContent>().map_err(|_| {
                 Error::bad_database("Invalid account data event in db.")
             })
         },
     )?;
 
-    tags_event
-        .content
-        .tags
-        .insert(body.tag.clone().into(), body.tag_info.clone());
+    tags_event.tags.insert(body.tag.clone().into(), body.tag_info.clone());
 
     services().account_data.update_room(
         &body.room_id,
         sender_user,
         &RoomAccountDataEventType::Tag,
-        &Raw::new(&tags_event)
-            .expect("json event serialization should always suceed")
-            .cast::<AnyRoomAccountDataEvent>(),
+        &Raw::new(&tags_event.into())
+            .expect("json event serialization should always suceed"),
     )?;
 
     Ok(Ra(create_tag::v3::Response {}))
@@ -77,28 +68,25 @@ pub(crate) async fn delete_tag_route(
 
     let mut tags_event = event.map_or_else(
         || {
-            Ok(TagEvent {
-                content: TagEventContent {
-                    tags: BTreeMap::new(),
-                },
+            Ok(TagEventContent {
+                tags: BTreeMap::new(),
             })
         },
         |e| {
-            e.deserialize_as::<TagEvent>().map_err(|_| {
+            e.deserialize_as::<TagEventContent>().map_err(|_| {
                 Error::bad_database("Invalid account data event in db.")
             })
         },
     )?;
 
-    tags_event.content.tags.remove(&body.tag.clone().into());
+    tags_event.tags.remove(&body.tag.clone().into());
 
     services().account_data.update_room(
         &body.room_id,
         sender_user,
         &RoomAccountDataEventType::Tag,
-        &Raw::new(&tags_event)
-            .expect("json value serialization should always succeed")
-            .cast::<AnyRoomAccountDataEvent>(),
+        &Raw::new(&tags_event.into())
+            .expect("json value serialization should always succeed"),
     )?;
 
     Ok(Ra(delete_tag::v3::Response {}))
@@ -122,20 +110,18 @@ pub(crate) async fn get_tags_route(
 
     let tags_event = event.map_or_else(
         || {
-            Ok(TagEvent {
-                content: TagEventContent {
-                    tags: BTreeMap::new(),
-                },
+            Ok(TagEventContent {
+                tags: BTreeMap::new(),
             })
         },
         |e| {
-            e.deserialize_as::<TagEvent>().map_err(|_| {
+            e.deserialize_as::<TagEventContent>().map_err(|_| {
                 Error::bad_database("Invalid account data event in db.")
             })
         },
     )?;
 
     Ok(Ra(get_tags::v3::Response {
-        tags: tags_event.content.tags,
+        tags: tags_event.tags,
     }))
 }