breez_sdk_spark/common/
sync_storage.rs

1use std::{collections::HashMap, sync::Arc};
2
3use serde::{Deserialize, Serialize};
4
5use crate::persist::{Storage, StorageError};
6
7pub(crate) struct SyncStorageWrapper {
8    pub inner: Arc<dyn Storage>,
9}
10
11impl SyncStorageWrapper {
12    pub fn new(inner: Arc<dyn Storage>) -> Self {
13        Self { inner }
14    }
15}
16
17fn storage_to_sync_error(value: StorageError) -> breez_sdk_common::sync::storage::SyncStorageError {
18    match value {
19        StorageError::Connection(msg) | StorageError::Implementation(msg) => {
20            breez_sdk_common::sync::storage::SyncStorageError::Implementation(msg)
21        }
22        StorageError::InitializationError(msg) => {
23            breez_sdk_common::sync::storage::SyncStorageError::InitializationError(msg)
24        }
25        StorageError::Serialization(msg) => {
26            breez_sdk_common::sync::storage::SyncStorageError::Serialization(msg)
27        }
28        StorageError::NotFound => {
29            breez_sdk_common::sync::storage::SyncStorageError::Implementation(
30                "Not found".to_string(),
31            )
32        }
33    }
34}
35
36#[macros::async_trait]
37impl breez_sdk_common::sync::storage::SyncStorage for SyncStorageWrapper {
38    async fn add_outgoing_change(
39        &self,
40        record: breez_sdk_common::sync::storage::UnversionedRecordChange,
41    ) -> Result<u64, breez_sdk_common::sync::storage::SyncStorageError> {
42        self.inner
43            .add_outgoing_change(record.into())
44            .await
45            .map_err(storage_to_sync_error)
46    }
47
48    async fn complete_outgoing_sync(
49        &self,
50        record: breez_sdk_common::sync::storage::Record,
51        local_revision: u64,
52    ) -> Result<(), breez_sdk_common::sync::storage::SyncStorageError> {
53        self.inner
54            .complete_outgoing_sync(record.into(), local_revision)
55            .await
56            .map_err(storage_to_sync_error)
57    }
58
59    async fn get_pending_outgoing_changes(
60        &self,
61        limit: u32,
62    ) -> Result<
63        Vec<breez_sdk_common::sync::storage::OutgoingChange>,
64        breez_sdk_common::sync::storage::SyncStorageError,
65    > {
66        let changes = self
67            .inner
68            .get_pending_outgoing_changes(limit)
69            .await
70            .map_err(storage_to_sync_error)?;
71        Ok(changes.into_iter().map(From::from).collect())
72    }
73
74    async fn get_last_revision(
75        &self,
76    ) -> Result<u64, breez_sdk_common::sync::storage::SyncStorageError> {
77        self.inner
78            .get_last_revision()
79            .await
80            .map_err(storage_to_sync_error)
81    }
82
83    async fn insert_incoming_records(
84        &self,
85        records: Vec<breez_sdk_common::sync::storage::Record>,
86    ) -> Result<(), breez_sdk_common::sync::storage::SyncStorageError> {
87        let recs: Vec<Record> = records.into_iter().map(From::from).collect();
88        self.inner
89            .insert_incoming_records(recs)
90            .await
91            .map_err(storage_to_sync_error)
92    }
93
94    async fn delete_incoming_record(
95        &self,
96        record: breez_sdk_common::sync::storage::Record,
97    ) -> Result<(), breez_sdk_common::sync::storage::SyncStorageError> {
98        self.inner
99            .delete_incoming_record(record.into())
100            .await
101            .map_err(storage_to_sync_error)
102    }
103
104    async fn get_incoming_records(
105        &self,
106        limit: u32,
107    ) -> Result<
108        Vec<breez_sdk_common::sync::storage::IncomingChange>,
109        breez_sdk_common::sync::storage::SyncStorageError,
110    > {
111        let changes = self
112            .inner
113            .get_incoming_records(limit)
114            .await
115            .map_err(storage_to_sync_error)?;
116        Ok(changes.into_iter().map(From::from).collect())
117    }
118
119    async fn get_latest_outgoing_change(
120        &self,
121    ) -> Result<
122        Option<breez_sdk_common::sync::storage::OutgoingChange>,
123        breez_sdk_common::sync::storage::SyncStorageError,
124    > {
125        let change = self
126            .inner
127            .get_latest_outgoing_change()
128            .await
129            .map_err(storage_to_sync_error)?;
130        Ok(change.map(From::from))
131    }
132
133    async fn update_record_from_incoming(
134        &self,
135        record: breez_sdk_common::sync::storage::Record,
136    ) -> Result<(), breez_sdk_common::sync::storage::SyncStorageError> {
137        self.inner
138            .update_record_from_incoming(record.into())
139            .await
140            .map_err(storage_to_sync_error)
141    }
142}
143
144#[derive(Debug, Clone, Deserialize, Serialize)]
145#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
146pub struct RecordId {
147    pub r#type: String,
148    pub data_id: String,
149}
150
151impl RecordId {
152    pub fn new(r#type: String, data_id: String) -> Self {
153        RecordId { r#type, data_id }
154    }
155}
156
157impl From<breez_sdk_common::sync::storage::RecordId> for RecordId {
158    fn from(value: breez_sdk_common::sync::storage::RecordId) -> Self {
159        RecordId {
160            r#type: value.r#type,
161            data_id: value.data_id,
162        }
163    }
164}
165
166impl From<RecordId> for breez_sdk_common::sync::storage::RecordId {
167    fn from(value: RecordId) -> Self {
168        breez_sdk_common::sync::storage::RecordId {
169            r#type: value.r#type,
170            data_id: value.data_id,
171        }
172    }
173}
174
175#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
176#[derive(Clone, Debug)]
177pub struct IncomingChange {
178    pub new_state: Record,
179    pub old_state: Option<Record>,
180}
181
182impl From<breez_sdk_common::sync::storage::IncomingChange> for IncomingChange {
183    fn from(value: breez_sdk_common::sync::storage::IncomingChange) -> Self {
184        IncomingChange {
185            new_state: value.new_state.into(),
186            old_state: value.old_state.map(From::from),
187        }
188    }
189}
190
191impl From<IncomingChange> for breez_sdk_common::sync::storage::IncomingChange {
192    fn from(value: IncomingChange) -> Self {
193        breez_sdk_common::sync::storage::IncomingChange {
194            new_state: value.new_state.into(),
195            old_state: value.old_state.map(From::from),
196        }
197    }
198}
199
200#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
201#[derive(Clone, Debug)]
202pub struct OutgoingChange {
203    pub change: RecordChange,
204    pub parent: Option<Record>,
205}
206
207impl From<breez_sdk_common::sync::storage::OutgoingChange> for OutgoingChange {
208    fn from(value: breez_sdk_common::sync::storage::OutgoingChange) -> Self {
209        OutgoingChange {
210            change: value.change.into(),
211            parent: value.parent.map(From::from),
212        }
213    }
214}
215
216impl From<OutgoingChange> for breez_sdk_common::sync::storage::OutgoingChange {
217    fn from(value: OutgoingChange) -> Self {
218        breez_sdk_common::sync::storage::OutgoingChange {
219            change: value.change.into(),
220            parent: value.parent.map(From::from),
221        }
222    }
223}
224
225#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
226#[derive(Clone, Debug)]
227pub struct UnversionedRecordChange {
228    pub id: RecordId,
229    pub schema_version: String,
230    pub updated_fields: HashMap<String, String>,
231}
232
233impl From<breez_sdk_common::sync::storage::UnversionedRecordChange> for UnversionedRecordChange {
234    fn from(value: breez_sdk_common::sync::storage::UnversionedRecordChange) -> Self {
235        UnversionedRecordChange {
236            id: value.id.into(),
237            schema_version: value.schema_version,
238            updated_fields: value.updated_fields,
239        }
240    }
241}
242
243impl From<UnversionedRecordChange> for breez_sdk_common::sync::storage::UnversionedRecordChange {
244    fn from(value: UnversionedRecordChange) -> Self {
245        breez_sdk_common::sync::storage::UnversionedRecordChange {
246            id: value.id.into(),
247            schema_version: value.schema_version,
248            updated_fields: value.updated_fields,
249        }
250    }
251}
252
253#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
254#[derive(Clone, Debug)]
255pub struct RecordChange {
256    pub id: RecordId,
257    pub schema_version: String,
258    pub updated_fields: HashMap<String, String>,
259    pub local_revision: u64,
260}
261
262impl From<breez_sdk_common::sync::storage::RecordChange> for RecordChange {
263    fn from(value: breez_sdk_common::sync::storage::RecordChange) -> Self {
264        RecordChange {
265            id: value.id.into(),
266            schema_version: value.schema_version,
267            updated_fields: value.updated_fields,
268            local_revision: value.local_revision,
269        }
270    }
271}
272
273impl From<RecordChange> for breez_sdk_common::sync::storage::RecordChange {
274    fn from(value: RecordChange) -> Self {
275        breez_sdk_common::sync::storage::RecordChange {
276            id: value.id.into(),
277            schema_version: value.schema_version,
278            updated_fields: value.updated_fields,
279            local_revision: value.local_revision,
280        }
281    }
282}
283
284#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
285#[derive(Clone, Debug)]
286pub struct Record {
287    pub id: RecordId,
288    pub revision: u64,
289    pub schema_version: String,
290    pub data: HashMap<String, String>,
291}
292
293impl From<breez_sdk_common::sync::storage::Record> for Record {
294    fn from(value: breez_sdk_common::sync::storage::Record) -> Self {
295        Record {
296            id: value.id.into(),
297            revision: value.revision,
298            schema_version: value.schema_version,
299            data: value.data,
300        }
301    }
302}
303
304impl From<Record> for breez_sdk_common::sync::storage::Record {
305    fn from(value: Record) -> Self {
306        breez_sdk_common::sync::storage::Record {
307            id: value.id.into(),
308            revision: value.revision,
309            schema_version: value.schema_version,
310            data: value.data,
311        }
312    }
313}
breez_sdk_spark/common/sync_storage.rs

breez_sdk_spark/common/
sync_storage.rs
