1use serde::{Deserialize, Serialize};
2use sonic_rs::Value;
3use std::collections::BTreeMap;
4
5#[derive(Debug, Clone, Default)]
6pub struct HistoryParams {
7 pub limit: Option<u32>,
8 pub direction: Option<String>,
9 pub cursor: Option<String>,
10 pub start_serial: Option<u64>,
11 pub end_serial: Option<u64>,
12 pub start_time_ms: Option<i64>,
13 pub end_time_ms: Option<i64>,
14}
15
16impl HistoryParams {
17 pub fn to_map(&self) -> BTreeMap<String, String> {
18 let mut params = BTreeMap::new();
19 if let Some(limit) = self.limit {
20 params.insert("limit".to_string(), limit.to_string());
21 }
22 if let Some(direction) = self.direction.as_ref() {
23 params.insert("direction".to_string(), direction.clone());
24 }
25 if let Some(cursor) = self.cursor.as_ref() {
26 params.insert("cursor".to_string(), cursor.clone());
27 }
28 if let Some(start_serial) = self.start_serial {
29 params.insert("start_serial".to_string(), start_serial.to_string());
30 }
31 if let Some(end_serial) = self.end_serial {
32 params.insert("end_serial".to_string(), end_serial.to_string());
33 }
34 if let Some(start_time_ms) = self.start_time_ms {
35 params.insert("start_time_ms".to_string(), start_time_ms.to_string());
36 }
37 if let Some(end_time_ms) = self.end_time_ms {
38 params.insert("end_time_ms".to_string(), end_time_ms.to_string());
39 }
40 params
41 }
42}
43
44#[derive(Debug, Clone, Deserialize)]
45pub struct HistoryPage {
46 pub items: Vec<HistoryItem>,
47 pub direction: String,
48 pub limit: usize,
49 pub has_more: bool,
50 pub next_cursor: Option<String>,
51 pub bounds: HistoryBounds,
52 pub continuity: HistoryContinuity,
53}
54
55#[derive(Debug, Clone, Deserialize)]
56pub struct HistoryItem {
57 pub stream_id: Option<String>,
58 pub serial: Option<u64>,
59 pub published_at_ms: Option<i64>,
60 pub message_id: Option<String>,
61 pub event_name: Option<String>,
62 pub operation_kind: Option<String>,
63 pub payload_size_bytes: Option<usize>,
64 pub message: Option<Value>,
65}
66
67#[derive(Debug, Clone, Deserialize, Default)]
68pub struct HistoryBounds {
69 pub start_serial: Option<u64>,
70 pub end_serial: Option<u64>,
71 pub start_time_ms: Option<i64>,
72 pub end_time_ms: Option<i64>,
73}
74
75#[derive(Debug, Clone, Deserialize, Default)]
76pub struct HistoryContinuity {
77 pub stream_id: Option<String>,
78 pub oldest_available_serial: Option<u64>,
79 pub newest_available_serial: Option<u64>,
80 pub oldest_available_published_at_ms: Option<i64>,
81 pub newest_available_published_at_ms: Option<i64>,
82 pub retained_messages: u64,
83 pub retained_bytes: u64,
84 pub complete: bool,
85 pub truncated_by_retention: bool,
86}
87
88#[derive(Debug, Clone, Default)]
89pub struct MessageVersionsParams {
90 pub limit: Option<u32>,
91 pub direction: Option<String>,
92 pub cursor: Option<String>,
93}
94
95impl MessageVersionsParams {
96 pub fn to_map(&self) -> BTreeMap<String, String> {
97 let mut params = BTreeMap::new();
98 if let Some(limit) = self.limit {
99 params.insert("limit".to_string(), limit.to_string());
100 }
101 if let Some(direction) = self.direction.as_ref() {
102 params.insert("direction".to_string(), direction.clone());
103 }
104 if let Some(cursor) = self.cursor.as_ref() {
105 params.insert("cursor".to_string(), cursor.clone());
106 }
107 params
108 }
109}
110
111#[derive(Debug, Clone, Deserialize)]
112pub struct MutationResponse {
113 pub channel: String,
114 pub message_serial: String,
115 pub action: String,
116 pub accepted: bool,
117 pub version_serial: Option<String>,
118 pub status: String,
119}
120
121#[derive(Debug, Clone, Deserialize)]
122pub struct GetMessageResponse {
123 pub channel: String,
124 pub item: Value,
125}
126
127#[derive(Debug, Clone, Deserialize)]
128pub struct ListMessageVersionsResponse {
129 pub channel: String,
130 pub direction: String,
131 pub limit: usize,
132 pub has_more: bool,
133 pub next_cursor: Option<String>,
134 pub items: Vec<Value>,
135}
136
137#[derive(Debug, Clone, Default)]
138pub struct AnnotationEventsParams {
139 pub annotation_type: Option<String>,
140 pub from_serial: Option<String>,
141 pub limit: Option<u32>,
142 pub socket_id: Option<String>,
143}
144
145impl AnnotationEventsParams {
146 pub fn to_map(&self) -> BTreeMap<String, String> {
147 let mut params = BTreeMap::new();
148 if let Some(annotation_type) = self.annotation_type.as_ref() {
149 params.insert("type".to_string(), annotation_type.clone());
150 }
151 if let Some(from_serial) = self.from_serial.as_ref() {
152 params.insert("from_serial".to_string(), from_serial.clone());
153 }
154 if let Some(limit) = self.limit {
155 params.insert("limit".to_string(), limit.to_string());
156 }
157 if let Some(socket_id) = self.socket_id.as_ref() {
158 params.insert("socket_id".to_string(), socket_id.clone());
159 }
160 params
161 }
162}
163
164#[derive(Debug, Clone, Serialize)]
165#[serde(rename_all = "camelCase")]
166pub struct PublishAnnotationRequest {
167 #[serde(rename = "type")]
168 pub annotation_type: String,
169 #[serde(skip_serializing_if = "Option::is_none")]
170 pub name: Option<String>,
171 #[serde(skip_serializing_if = "Option::is_none")]
172 pub client_id: Option<String>,
173 #[serde(skip_serializing_if = "Option::is_none")]
174 pub socket_id: Option<String>,
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub count: Option<u64>,
177 #[serde(skip_serializing_if = "Option::is_none")]
178 pub data: Option<Value>,
179 #[serde(skip_serializing_if = "Option::is_none")]
180 pub encoding: Option<String>,
181}
182
183#[derive(Debug, Clone, Deserialize)]
184#[serde(rename_all = "camelCase")]
185pub struct PublishAnnotationResponse {
186 pub annotation_serial: String,
187}
188
189#[derive(Debug, Clone, Deserialize)]
190#[serde(rename_all = "camelCase")]
191pub struct DeleteAnnotationResponse {
192 pub annotation_serial: String,
193 pub deleted_annotation_serial: String,
194}
195
196#[derive(Debug, Clone, Deserialize)]
197#[serde(rename_all = "camelCase")]
198pub struct AnnotationEventsResponse {
199 pub channel: String,
200 pub message_serial: String,
201 pub limit: usize,
202 pub has_more: bool,
203 pub next_cursor: Option<String>,
204 pub items: Vec<Value>,
205}