1use std::collections::HashMap;
2
3use crate::{Error, transport::pagination::PaginatedResponse};
4
5use super::{Bar, Orderbook, Quote, Snapshot, Trade};
6
7#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
8pub struct BarsResponse {
9 pub bars: HashMap<String, Vec<Bar>>,
10 pub next_page_token: Option<String>,
11}
12
13#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
14pub struct QuotesResponse {
15 pub quotes: HashMap<String, Vec<Quote>>,
16 pub next_page_token: Option<String>,
17}
18
19#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
20pub struct TradesResponse {
21 pub trades: HashMap<String, Vec<Trade>>,
22 pub next_page_token: Option<String>,
23}
24
25#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
26pub struct LatestBarsResponse {
27 pub bars: HashMap<String, Bar>,
28}
29
30#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
31pub struct LatestQuotesResponse {
32 pub quotes: HashMap<String, Quote>,
33}
34
35#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
36pub struct LatestTradesResponse {
37 pub trades: HashMap<String, Trade>,
38}
39
40#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
41pub struct LatestOrderbooksResponse {
42 pub orderbooks: HashMap<String, Orderbook>,
43}
44
45#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize)]
46pub struct SnapshotsResponse {
47 pub snapshots: HashMap<String, Snapshot>,
48}
49
50fn merge_batch_page<Item>(
51 current: &mut HashMap<String, Vec<Item>>,
52 next: HashMap<String, Vec<Item>>,
53) {
54 for (symbol, mut items) in next {
55 current.entry(symbol).or_default().append(&mut items);
56 }
57}
58
59impl PaginatedResponse for BarsResponse {
60 fn next_page_token(&self) -> Option<&str> {
61 self.next_page_token.as_deref()
62 }
63
64 fn merge_page(&mut self, next: Self) -> Result<(), Error> {
65 merge_batch_page(&mut self.bars, next.bars);
66 self.next_page_token = next.next_page_token;
67 Ok(())
68 }
69
70 fn clear_next_page_token(&mut self) {
71 self.next_page_token = None;
72 }
73}
74
75impl PaginatedResponse for QuotesResponse {
76 fn next_page_token(&self) -> Option<&str> {
77 self.next_page_token.as_deref()
78 }
79
80 fn merge_page(&mut self, next: Self) -> Result<(), Error> {
81 merge_batch_page(&mut self.quotes, next.quotes);
82 self.next_page_token = next.next_page_token;
83 Ok(())
84 }
85
86 fn clear_next_page_token(&mut self) {
87 self.next_page_token = None;
88 }
89}
90
91impl PaginatedResponse for TradesResponse {
92 fn next_page_token(&self) -> Option<&str> {
93 self.next_page_token.as_deref()
94 }
95
96 fn merge_page(&mut self, next: Self) -> Result<(), Error> {
97 merge_batch_page(&mut self.trades, next.trades);
98 self.next_page_token = next.next_page_token;
99 Ok(())
100 }
101
102 fn clear_next_page_token(&mut self) {
103 self.next_page_token = None;
104 }
105}
106
107#[cfg(test)]
108mod tests {
109 use std::collections::HashMap;
110
111 use crate::transport::pagination::PaginatedResponse;
112
113 use super::{
114 Bar, BarsResponse, LatestBarsResponse, LatestOrderbooksResponse, LatestTradesResponse,
115 QuotesResponse, SnapshotsResponse, TradesResponse,
116 };
117
118 #[test]
119 fn historical_responses_deserialize_official_wrapper_shapes() {
120 let bars: BarsResponse = serde_json::from_str(
121 r#"{"bars":{"BTC/USD":[{"c":66926.1935,"h":66946.85,"l":66920.6075,"n":0,"o":66942.46,"t":"2026-04-04T00:00:00Z","v":0.02821505,"vw":66933.72875}]},"next_page_token":"page-2"}"#,
122 )
123 .expect("bars response should deserialize");
124 assert_eq!(bars.next_page_token.as_deref(), Some("page-2"));
125 assert_eq!(
126 bars.bars.get("BTC/USD").map(Vec::len).unwrap_or_default(),
127 1
128 );
129
130 let quotes: QuotesResponse = serde_json::from_str(
131 r#"{"quotes":{"BTC/USD":[{"ap":67005.5,"as":1.26733,"bp":66894.8,"bs":2.56753,"t":"2026-04-04T00:00:04.184229364Z"}]},"next_page_token":"page-3"}"#,
132 )
133 .expect("quotes response should deserialize");
134 assert_eq!(quotes.next_page_token.as_deref(), Some("page-3"));
135 assert_eq!(
136 quotes
137 .quotes
138 .get("BTC/USD")
139 .map(Vec::len)
140 .unwrap_or_default(),
141 1
142 );
143
144 let trades: TradesResponse = serde_json::from_str(
145 r#"{"trades":{"BTC/USD":[{"i":5536632919737126473,"p":66969.687,"s":0.000073,"t":"2026-04-04T00:01:02.445726428Z","tks":"B"}]},"next_page_token":"page-4"}"#,
146 )
147 .expect("trades response should deserialize");
148 assert_eq!(trades.next_page_token.as_deref(), Some("page-4"));
149 assert_eq!(
150 trades
151 .trades
152 .get("BTC/USD")
153 .map(Vec::len)
154 .unwrap_or_default(),
155 1
156 );
157 }
158
159 #[test]
160 fn historical_merge_combines_symbol_buckets_and_clears_next_page_token() {
161 let mut first = BarsResponse {
162 bars: HashMap::from([(
163 "BTC/USD".into(),
164 vec![Bar {
165 t: Some("2026-04-04T00:00:00Z".into()),
166 ..Bar::default()
167 }],
168 )]),
169 next_page_token: Some("page-2".into()),
170 };
171 let second = BarsResponse {
172 bars: HashMap::from([(
173 "ETH/USD".into(),
174 vec![Bar {
175 t: Some("2026-04-04T00:00:00Z".into()),
176 ..Bar::default()
177 }],
178 )]),
179 next_page_token: None,
180 };
181
182 first
183 .merge_page(second)
184 .expect("merge should combine pages without error");
185 first.clear_next_page_token();
186
187 assert_eq!(first.next_page_token, None);
188 assert_eq!(first.bars.len(), 2);
189 }
190
191 #[test]
192 fn quote_and_trade_merge_append_more_items() {
193 let mut quotes = QuotesResponse {
194 quotes: HashMap::from([(
195 "BTC/USD".into(),
196 vec![super::Quote {
197 t: Some("2026-04-04T00:00:04.184229364Z".into()),
198 ..super::Quote::default()
199 }],
200 )]),
201 next_page_token: Some("page-2".into()),
202 };
203 quotes
204 .merge_page(QuotesResponse {
205 quotes: HashMap::from([(
206 "BTC/USD".into(),
207 vec![super::Quote {
208 t: Some("2026-04-04T00:00:05.184229364Z".into()),
209 ..super::Quote::default()
210 }],
211 )]),
212 next_page_token: None,
213 })
214 .expect("quote merge should append items");
215 assert_eq!(
216 quotes
217 .quotes
218 .get("BTC/USD")
219 .map(Vec::len)
220 .unwrap_or_default(),
221 2
222 );
223
224 let mut trades = TradesResponse {
225 trades: HashMap::from([(
226 "BTC/USD".into(),
227 vec![super::Trade {
228 t: Some("2026-04-04T00:01:02.445726428Z".into()),
229 ..super::Trade::default()
230 }],
231 )]),
232 next_page_token: Some("page-3".into()),
233 };
234 trades
235 .merge_page(TradesResponse {
236 trades: HashMap::from([(
237 "BTC/USD".into(),
238 vec![super::Trade {
239 t: Some("2026-04-04T00:01:03.445726428Z".into()),
240 ..super::Trade::default()
241 }],
242 )]),
243 next_page_token: None,
244 })
245 .expect("trade merge should append items");
246 assert_eq!(
247 trades
248 .trades
249 .get("BTC/USD")
250 .map(Vec::len)
251 .unwrap_or_default(),
252 2
253 );
254 }
255
256 #[test]
257 fn latest_responses_deserialize_official_wrapper_shapes() {
258 let latest_bars: LatestBarsResponse = serde_json::from_str(
259 r#"{"bars":{"BTC/USD":{"c":66800.79,"h":66817.1675,"l":66800.79,"n":0,"o":66812.172,"t":"2026-04-04T04:13:00Z","v":0.0,"vw":66808.97875}}}"#,
260 )
261 .expect("latest bars response should deserialize");
262 assert!(latest_bars.bars.contains_key("BTC/USD"));
263
264 let latest_trades: LatestTradesResponse = serde_json::from_str(
265 r#"{"trades":{"BTC/USD":{"i":519366231866950988,"p":66842.8,"s":0.000828,"t":"2026-04-04T04:12:55.361347989Z","tks":"B"}}}"#,
266 )
267 .expect("latest trades response should deserialize");
268 assert!(latest_trades.trades.contains_key("BTC/USD"));
269
270 let latest_orderbooks: LatestOrderbooksResponse = serde_json::from_str(
271 r#"{"orderbooks":{"BTC/USD":{"a":[{"p":66819.4,"s":1.28052},{"p":66847.8,"s":2.5525}],"b":[{"p":66763.431,"s":1.272},{"p":66743.135,"s":2.5795}],"t":"2026-04-04T04:14:35.581059122Z"}}}"#,
272 )
273 .expect("latest orderbooks response should deserialize");
274 assert!(latest_orderbooks.orderbooks.contains_key("BTC/USD"));
275 }
276
277 #[test]
278 fn snapshots_response_deserializes_official_wrapper_shape() {
279 let snapshots: SnapshotsResponse = serde_json::from_str(
280 r#"{"snapshots":{"BTC/USD":{"dailyBar":{"c":66800.79,"h":66975.1,"l":66772.66,"n":87,"o":66942.46,"t":"2026-04-04T00:00:00Z","v":0.029938953,"vw":66854.9651939408},"latestQuote":{"ap":66819.4,"as":1.28052,"bp":66763.431,"bs":1.272,"t":"2026-04-04T04:14:35.580241652Z"},"latestTrade":{"i":7456836641300628344,"p":66832.6,"s":0.000946,"t":"2026-04-04T04:14:32.161121311Z","tks":"B"},"minuteBar":{"c":66800.79,"h":66817.1675,"l":66800.79,"n":0,"o":66812.172,"t":"2026-04-04T04:13:00Z","v":0.0,"vw":66808.97875},"prevDailyBar":{"c":66961.45,"h":67293.2523,"l":66252.479,"n":549,"o":66887.805,"t":"2026-04-03T00:00:00Z","v":1.117036142,"vw":66779.3688392417}}}}"#,
281 )
282 .expect("snapshots response should deserialize");
283
284 let snapshot = snapshots
285 .snapshots
286 .get("BTC/USD")
287 .expect("snapshot response should include the symbol");
288 assert!(snapshot.latestTrade.is_some());
289 assert!(snapshot.latestQuote.is_some());
290 assert!(snapshot.minuteBar.is_some());
291 assert!(snapshot.dailyBar.is_some());
292 assert!(snapshot.prevDailyBar.is_some());
293 }
294}