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