Skip to main content

ton_connect_core/
bridge.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Deserializer, Serialize, de};
4use serde_json::Value;
5
6use crate::{Base64Value, ClientId, TraceId, ValueError};
7
8/// One encrypted message delivered by the HTTP bridge over SSE.
9///
10/// Deployment-specific fields are preserved because the bridge schema
11/// explicitly permits additional properties.
12#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
13pub struct BridgeMessage {
14    from: ClientId,
15    message: Base64Value,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    trace_id: Option<TraceId>,
18    #[serde(flatten)]
19    extensions: BTreeMap<String, Value>,
20}
21
22impl BridgeMessage {
23    /// Creates a schema-valid bridge envelope.
24    pub fn new(
25        from: ClientId,
26        message: Base64Value,
27        trace_id: Option<TraceId>,
28    ) -> Result<Self, ValueError> {
29        if message.as_str().is_empty() {
30            return Err(ValueError::InvalidBase64);
31        }
32        Ok(Self {
33            from,
34            message,
35            trace_id,
36            extensions: BTreeMap::new(),
37        })
38    }
39
40    /// Returns the sender's bridge client identifier.
41    #[must_use]
42    pub const fn from(&self) -> ClientId {
43        self.from
44    }
45
46    /// Returns the base64-encoded `nonce || ciphertext` payload.
47    #[must_use]
48    pub const fn message(&self) -> &Base64Value {
49        &self.message
50    }
51
52    /// Returns the optional analytics correlation identifier.
53    #[must_use]
54    pub const fn trace_id(&self) -> Option<&TraceId> {
55        self.trace_id.as_ref()
56    }
57
58    /// Returns deployment-specific bridge fields.
59    #[must_use]
60    pub const fn extensions(&self) -> &BTreeMap<String, Value> {
61        &self.extensions
62    }
63}
64
65#[derive(Deserialize)]
66struct BridgeMessageWire {
67    from: ClientId,
68    message: Base64Value,
69    #[serde(
70        default,
71        deserialize_with = "crate::value::deserialize_optional_non_null"
72    )]
73    trace_id: Option<TraceId>,
74    #[serde(flatten)]
75    extensions: BTreeMap<String, Value>,
76}
77
78impl<'de> Deserialize<'de> for BridgeMessage {
79    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
80    where
81        D: Deserializer<'de>,
82    {
83        let wire = BridgeMessageWire::deserialize(deserializer)?;
84        if wire.message.as_str().is_empty() {
85            return Err(de::Error::custom("bridge message must not be empty"));
86        }
87        Ok(Self {
88            from: wire.from,
89            message: wire.message,
90            trace_id: wire.trace_id,
91            extensions: wire.extensions,
92        })
93    }
94}
95
96#[cfg(test)]
97mod tests {
98    use super::*;
99
100    #[test]
101    fn bridge_extensions_are_tolerated_and_preserved() {
102        let json = r#"{
103            "from":"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
104            "message":"AA==",
105            "deployment":"edge-1"
106        }"#;
107        let parsed = serde_json::from_str::<BridgeMessage>(json);
108        assert_eq!(
109            parsed
110                .as_ref()
111                .ok()
112                .and_then(|message| message.extensions().get("deployment")),
113            Some(&Value::String("edge-1".to_owned()))
114        );
115        assert!(
116            parsed
117                .and_then(|message| serde_json::to_string(&message))
118                .is_ok()
119        );
120    }
121
122    #[test]
123    fn bridge_rejects_empty_or_noncanonical_sender() {
124        let empty = r#"{"from":"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef","message":""}"#;
125        let uppercase = r#"{"from":"0123456789ABCDEF0123456789abcdef0123456789abcdef0123456789abcdef","message":"AA=="}"#;
126        assert!(serde_json::from_str::<BridgeMessage>(empty).is_err());
127        assert!(serde_json::from_str::<BridgeMessage>(uppercase).is_err());
128    }
129
130    #[test]
131    fn constructor_and_accessors_preserve_every_bridge_field()
132    -> Result<(), Box<dyn std::error::Error>> {
133        let from = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef".parse()?;
134        let message = Base64Value::try_from("AA==")?;
135        let trace = TraceId::try_from("019d85ea-ca0e-7129-8155-05c7534ef894")?;
136        let envelope = BridgeMessage::new(from, message.clone(), Some(trace.clone()))?;
137        assert_eq!(envelope.from(), from);
138        assert_eq!(envelope.message(), &message);
139        assert_eq!(envelope.trace_id(), Some(&trace));
140        assert!(envelope.extensions().is_empty());
141
142        assert!(BridgeMessage::new(from, Base64Value::try_from("")?, None).is_err());
143        Ok(())
144    }
145}