ton_connect_core/
bridge.rs1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Deserializer, Serialize, de};
4use serde_json::Value;
5
6use crate::{Base64Value, ClientId, TraceId, ValueError};
7
8#[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 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 #[must_use]
42 pub const fn from(&self) -> ClientId {
43 self.from
44 }
45
46 #[must_use]
48 pub const fn message(&self) -> &Base64Value {
49 &self.message
50 }
51
52 #[must_use]
54 pub const fn trace_id(&self) -> Option<&TraceId> {
55 self.trace_id.as_ref()
56 }
57
58 #[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}