ruma-federation-api 0.14.0

Types for the endpoints in the Matrix server-server API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! `POST /_matrix/federation/*/get_missing_events/{roomId}`
//!
//! Retrieves previous events that the sender is missing.

pub mod v1 {
    //! `/v1/` ([spec])
    //!
    //! [spec]: https://spec.matrix.org/v1.18/server-server-api/#post_matrixfederationv1get_missing_eventsroomid

    use js_int::{UInt, uint};
    use ruma_common::{
        OwnedEventId, OwnedRoomId,
        api::{request, response},
        metadata,
    };
    use serde_json::value::RawValue as RawJsonValue;

    use crate::authentication::ServerSignatures;

    metadata! {
        method: POST,
        rate_limited: false,
        authentication: ServerSignatures,
        path: "/_matrix/federation/v1/get_missing_events/{room_id}",
    }

    /// Request type for the `get_missing_events` endpoint.
    #[request]
    pub struct Request {
        /// The room ID to search in.
        #[ruma_api(path)]
        pub room_id: OwnedRoomId,

        /// The maximum number of events to retrieve.
        ///
        /// Defaults to 10.
        #[serde(default = "default_limit", skip_serializing_if = "is_default_limit")]
        pub limit: UInt,

        /// The minimum depth of events to retrieve.
        ///
        /// Defaults to 0.
        #[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
        pub min_depth: UInt,

        /// The latest event IDs that the sender already has.
        ///
        /// These are skipped when retrieving the previous events of `latest_events`.
        pub earliest_events: Vec<OwnedEventId>,

        /// The event IDs to retrieve the previous events for.
        pub latest_events: Vec<OwnedEventId>,
    }

    /// Response type for the `get_missing_events` endpoint.
    #[response]
    #[derive(Default)]
    pub struct Response {
        /// The missing PDUs.
        pub events: Vec<Box<RawJsonValue>>,
    }

    impl Request {
        /// Creates a new `Request` for events in the given room with the given constraints.
        pub fn new(
            room_id: OwnedRoomId,
            earliest_events: Vec<OwnedEventId>,
            latest_events: Vec<OwnedEventId>,
        ) -> Self {
            Self {
                room_id,
                limit: default_limit(),
                min_depth: UInt::default(),
                earliest_events,
                latest_events,
            }
        }
    }

    impl Response {
        /// Creates a new `Response` with the given events.
        pub fn new(events: Vec<Box<RawJsonValue>>) -> Self {
            Self { events }
        }
    }

    fn default_limit() -> UInt {
        uint!(10)
    }

    #[cfg(feature = "client")]
    fn is_default_limit(val: &UInt) -> bool {
        *val == default_limit()
    }
}