fluence_spell_dtos/
value.rs

1use eyre::WrapErr;
2use marine_rs_sdk::marine;
3use marine_sqlite_connector::Statement;
4use serde::Deserialize;
5
6use crate::error::SpellError;
7
8pub fn format_error(e: impl std::fmt::Debug) -> String {
9    format!("{:?}", e)
10}
11
12pub trait SpellValueT {
13    fn is_success(&self) -> bool;
14    fn take_error(self) -> String;
15}
16
17#[marine]
18#[derive(Debug, Clone, Deserialize)]
19#[allow(dead_code)]
20pub struct UnitValue {
21    pub success: bool,
22    pub error: String,
23}
24
25impl UnitValue {
26    pub fn ok() -> Self {
27        Self {
28            success: true,
29            error: String::new(),
30        }
31    }
32
33    pub fn error(error: impl AsRef<str>) -> Self {
34        Self {
35            success: false,
36            error: error.as_ref().to_string(),
37        }
38    }
39
40    pub fn spell_error(error: SpellError) -> Self {
41        Self::error(format_error(error))
42    }
43}
44
45impl From<eyre::Result<()>> for UnitValue {
46    fn from(value: eyre::Result<()>) -> Self {
47        match value {
48            Ok(_) => UnitValue::ok(),
49            Err(e) => UnitValue::error(format_error(e)),
50        }
51    }
52}
53
54impl SpellValueT for UnitValue {
55    fn is_success(&self) -> bool {
56        self.success
57    }
58
59    fn take_error(self) -> String {
60        self.error
61    }
62}
63
64impl From<SpellError> for UnitValue {
65    fn from(error: SpellError) -> Self {
66        UnitValue::spell_error(error)
67    }
68}
69
70#[marine]
71#[derive(Debug, Deserialize)]
72pub struct StringValue {
73    pub value: String,
74    pub success: bool,
75    pub error: String,
76    pub absent: bool,
77}
78
79impl From<eyre::Result<Option<String>>> for StringValue {
80    fn from(value: eyre::Result<Option<String>>) -> Self {
81        match value {
82            Ok(Some(value)) => StringValue {
83                value,
84                success: true,
85                error: String::new(),
86                absent: false,
87            },
88            Ok(None) => StringValue {
89                value: String::new(),
90                success: true,
91                error: String::new(),
92                absent: true,
93            },
94            Err(e) => StringValue {
95                value: String::new(),
96                success: false,
97                error: format_error(e),
98                absent: false,
99            },
100        }
101    }
102}
103
104impl SpellValueT for StringValue {
105    fn is_success(&self) -> bool {
106        self.success
107    }
108
109    fn take_error(self) -> String {
110        self.error
111    }
112}
113
114#[marine]
115#[derive(Debug, Deserialize)]
116pub struct StringListValue {
117    pub value: Vec<String>,
118    pub success: bool,
119    pub error: String,
120}
121
122impl From<eyre::Result<Vec<String>>> for StringListValue {
123    fn from(value: eyre::Result<Vec<String>>) -> Self {
124        match value {
125            Ok(value) => StringListValue {
126                value,
127                success: true,
128                error: String::new(),
129            },
130            Err(e) => StringListValue {
131                value: vec![],
132                success: false,
133                error: format_error(e),
134            },
135        }
136    }
137}
138
139impl SpellValueT for StringListValue {
140    fn is_success(&self) -> bool {
141        self.success
142    }
143
144    fn take_error(self) -> String {
145        self.error
146    }
147}
148
149#[marine]
150#[derive(Debug, Deserialize)]
151pub struct U32Value {
152    pub value: u32,
153    pub success: bool,
154    pub error: String,
155    pub absent: bool,
156}
157
158impl From<eyre::Result<Option<u32>>> for U32Value {
159    fn from(value: eyre::Result<Option<u32>>) -> Self {
160        match value {
161            Ok(Some(value)) => U32Value {
162                value,
163                success: true,
164                error: String::new(),
165                absent: false,
166            },
167            Ok(None) => U32Value {
168                value: u32::default(),
169                success: true,
170                error: String::new(),
171                absent: true,
172            },
173            Err(e) => U32Value {
174                value: u32::default(),
175                success: false,
176                error: format_error(e),
177                absent: false,
178            },
179        }
180    }
181}
182
183impl SpellValueT for U32Value {
184    fn is_success(&self) -> bool {
185        self.success
186    }
187
188    fn take_error(self) -> String {
189        self.error
190    }
191}
192
193#[marine]
194#[derive(Debug, Deserialize)]
195pub struct ScriptValue {
196    pub value: String,
197    pub success: bool,
198    pub error: String,
199}
200
201impl SpellValueT for ScriptValue {
202    fn is_success(&self) -> bool {
203        self.success
204    }
205
206    fn take_error(self) -> String {
207        self.error
208    }
209}
210
211#[marine]
212#[derive(Debug, Deserialize)]
213pub struct CIDv1Value {
214    pub value: String,
215    pub success: bool,
216    pub error: String,
217}
218
219impl SpellValueT for CIDv1Value {
220    fn is_success(&self) -> bool {
221        self.success
222    }
223
224    fn take_error(self) -> String {
225        self.error
226    }
227}
228
229#[marine]
230#[derive(Debug, Deserialize)]
231pub struct BoolValue {
232    pub value: bool,
233    pub success: bool,
234    pub error: String,
235}
236
237impl SpellValueT for BoolValue {
238    fn is_success(&self) -> bool {
239        self.success
240    }
241
242    fn take_error(self) -> String {
243        self.error
244    }
245}
246
247impl From<eyre::Result<bool>> for BoolValue {
248    fn from(value: eyre::Result<bool>) -> Self {
249        match value {
250            Ok(value) => BoolValue {
251                value,
252                success: true,
253                error: String::new(),
254            },
255            Err(e) => BoolValue {
256                value: false,
257                success: false,
258                error: format_error(e),
259            },
260        }
261    }
262}
263
264#[marine]
265#[derive(Debug)]
266pub struct MailboxMessage {
267    pub init_peer_id: String,
268    pub timestamp: u64,
269    pub message: String,
270}
271
272impl MailboxMessage {
273    pub fn read(statement: &mut Statement) -> eyre::Result<Self> {
274        Ok(MailboxMessage {
275            init_peer_id: statement
276                .read::<String>(0)
277                .context("failed to read `init_peer_id` field")?,
278            timestamp: statement
279                .read::<i64>(1)
280                .context("failed to read `timestamp` field")? as u64,
281            message: statement
282                .read::<String>(2)
283                .context("failed to read `message` field")?,
284        })
285    }
286}
287
288#[marine]
289#[derive(Debug)]
290/// `messages` contains up to `DEFAULT_MAX_MAILBOX` latest messages,
291/// sorted in the order they were pushed
292pub struct GetMailboxResult {
293    pub messages: Vec<MailboxMessage>,
294    pub success: bool,
295    pub error: String,
296}
297
298impl From<eyre::Result<Vec<MailboxMessage>>> for GetMailboxResult {
299    fn from(result: eyre::Result<Vec<MailboxMessage>>) -> Self {
300        match result {
301            Ok(messages) => GetMailboxResult {
302                messages,
303                success: true,
304                error: "".to_string(),
305            },
306            Err(e) => GetMailboxResult {
307                success: false,
308                error: format!("get_mailbox error: {}", e),
309                messages: vec![],
310            },
311        }
312    }
313}
314
315#[marine]
316#[derive(Debug)]
317// If there is no message, `message` is empty and `absent` is `true`.
318pub struct PopMailboxResult {
319    pub message: Vec<MailboxMessage>,
320    pub success: bool,
321    pub absent: bool,
322    pub error: String,
323}
324
325impl From<eyre::Result<Option<MailboxMessage>>> for PopMailboxResult {
326    fn from(value: eyre::Result<Option<MailboxMessage>>) -> Self {
327        match value {
328            Ok(Some(message)) => PopMailboxResult {
329                message: vec![message],
330                success: true,
331                error: String::new(),
332                absent: false,
333            },
334            Ok(None) => PopMailboxResult {
335                message: vec![],
336                success: true,
337                error: String::new(),
338                absent: true,
339            },
340            Err(e) => PopMailboxResult {
341                message: vec![],
342                success: false,
343                error: format_error(e),
344                absent: false,
345            },
346        }
347    }
348}
349
350#[marine]
351#[derive(Debug)]
352pub struct Log {
353    pub timestamp: u64,
354    pub message: String,
355}
356
357#[marine]
358#[derive(Debug)]
359/// `logs` contains up to `DEFAULT_MAX_LOGS` latest logs with timestamps,
360/// sorted in the order they were appeared
361pub struct GetLogsResult {
362    pub logs: Vec<Log>,
363    pub success: bool,
364    pub error: String,
365}
366
367impl From<eyre::Result<Vec<Log>>> for GetLogsResult {
368    fn from(result: eyre::Result<Vec<Log>>) -> Self {
369        match result {
370            Ok(logs) => GetLogsResult {
371                logs,
372                success: true,
373                error: "".to_string(),
374            },
375            Err(e) => GetLogsResult {
376                success: false,
377                error: format!("get_logs error: {}", e),
378                logs: vec![],
379            },
380        }
381    }
382}
fluence_spell_dtos/value.rs

fluence_spell_dtos/
value.rs
