Skip to main content

bitwarden_send/
delete.rs

1use bitwarden_api_api::ResponseContent;
2use bitwarden_core::ApiError;
3use bitwarden_error::bitwarden_error;
4use bitwarden_state::{
5    PersistedValue, register_persisted_value,
6    repository::{Repository, RepositoryError},
7};
8use thiserror::Error;
9
10use crate::{Send, SendId, send_client::SendClient};
11
12// Durable queue of Sends whose server-side delete failed, retried later to avoid orphaned records.
13register_persisted_value!(PENDING_SEND_DELETIONS: Vec<SendId> = "pending_send_deletions");
14
15#[allow(missing_docs)]
16#[bitwarden_error(flat)]
17#[derive(Debug, Error)]
18pub enum DeleteSendError {
19    #[error(transparent)]
20    Api(#[from] ApiError),
21    #[error(transparent)]
22    Repository(#[from] RepositoryError),
23    #[error(transparent)]
24    State(#[from] bitwarden_state::PersistedValueError),
25}
26
27async fn delete_send<R: Repository<Send> + ?Sized>(
28    api_client: &bitwarden_api_api::apis::ApiClient,
29    repository: &R,
30    pending_deletions: &PersistedValue<PENDING_SEND_DELETIONS>,
31    send_id: SendId,
32) -> Result<(), DeleteSendError> {
33    if let Err(e) = api_client.sends_api().delete(&send_id.to_string()).await {
34        // Often an offline failure; queue for durable retry so the Send isn't orphaned in the list.
35        queue_pending_deletion(pending_deletions, send_id).await;
36        return Err(e.into());
37    }
38
39    repository.remove(send_id).await?;
40
41    Ok(())
42}
43
44/// Add `send_id` to the pending-deletion queue if not already present. State errors are
45/// swallowed so the caller still receives the original delete error unchanged.
46async fn queue_pending_deletion(
47    pending_deletions: &PersistedValue<PENDING_SEND_DELETIONS>,
48    send_id: SendId,
49) {
50    let Ok(queue) = pending_deletions.try_get().await else {
51        return;
52    };
53    let mut queue = queue.unwrap_or_default();
54
55    if queue.contains(&send_id) {
56        return;
57    }
58
59    queue.push(send_id);
60    let _ = pending_deletions.set(queue).await;
61}
62
63async fn retry_pending_deletions<R: Repository<Send> + ?Sized>(
64    api_client: &bitwarden_api_api::apis::ApiClient,
65    repository: &R,
66    pending_deletions: &PersistedValue<PENDING_SEND_DELETIONS>,
67) -> Result<(), DeleteSendError> {
68    let queue = pending_deletions.try_get().await?.unwrap_or_default();
69    if queue.is_empty() {
70        return Ok(());
71    }
72
73    let mut resolved = Vec::new();
74    for send_id in queue {
75        match api_client.sends_api().delete(&send_id.to_string()).await {
76            // A 404 means it's already gone server-side, so treat it the same as a success.
77            Ok(())
78            | Err(ApiError::Response(ResponseContent {
79                status: reqwest::StatusCode::NOT_FOUND,
80                ..
81            })) => {
82                // Repo may already be clean; ignore removal errors.
83                let _ = repository.remove(send_id).await;
84                resolved.push(send_id);
85            }
86            Err(_) => {}
87        }
88    }
89
90    if resolved.is_empty() {
91        return Ok(());
92    }
93
94    // Re-read before writing so a concurrent queue_pending_deletion isn't clobbered.
95    let mut current = pending_deletions.try_get().await?.unwrap_or_default();
96    current.retain(|id| !resolved.contains(id));
97    pending_deletions.set(current).await?;
98
99    Ok(())
100}
101
102#[bitwarden_ffi::wasm_export]
103impl SendClient {
104    /// Delete a [Send] from the server and remove it from local state.
105    pub async fn delete(&self, send_id: SendId) -> Result<(), DeleteSendError> {
106        let config = self.client.internal.get_api_configurations();
107        let repository = self.get_repository()?;
108        let pending_deletions = self
109            .client
110            .platform()
111            .state()
112            .value::<PENDING_SEND_DELETIONS>();
113
114        delete_send(
115            &config.api_client,
116            repository.as_ref(),
117            &pending_deletions,
118            send_id,
119        )
120        .await
121    }
122
123    /// Retry any [Send] deletions that previously failed (e.g. while offline), removing each from
124    /// the pending queue once the server confirms it is gone.
125    pub async fn retry_pending_deletions(&self) -> Result<(), DeleteSendError> {
126        let config = self.client.internal.get_api_configurations();
127        let repository = self.get_repository()?;
128        let pending_deletions = self
129            .client
130            .platform()
131            .state()
132            .value::<PENDING_SEND_DELETIONS>();
133
134        retry_pending_deletions(&config.api_client, repository.as_ref(), &pending_deletions).await
135    }
136}
137
138#[cfg(test)]
139mod tests {
140    use std::sync::Arc;
141
142    use bitwarden_api_api::apis::ApiClient;
143    use bitwarden_core::key_management::{KeySlotIds, SymmetricKeySlotId};
144    use bitwarden_crypto::{KeyStore, SymmetricKeyAlgorithm};
145    use bitwarden_test::{MemoryPersistedValue, MemoryRepository};
146    use uuid::uuid;
147
148    use super::*;
149    use crate::{AuthType, Send, SendId, SendTextView, SendType, SendView};
150
151    fn make_pending_deletions() -> PersistedValue<PENDING_SEND_DELETIONS> {
152        MemoryPersistedValue::create()
153    }
154
155    async fn make_store_with_send(
156        send_id: uuid::Uuid,
157    ) -> (KeyStore<KeySlotIds>, MemoryRepository<Send>) {
158        let store: KeyStore<KeySlotIds> = KeyStore::default();
159        {
160            let mut ctx = store.context_mut();
161            let local_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
162            ctx.persist_symmetric_key(local_key_id, SymmetricKeySlotId::User)
163                .unwrap();
164        }
165
166        let repository = MemoryRepository::<Send>::default();
167        let send_view = SendView {
168            id: None,
169            access_id: None,
170            name: "Test Send".to_string(),
171            notes: None,
172            key: None,
173            new_password: None,
174            has_password: false,
175            r#type: SendType::Text,
176            file: None,
177            text: Some(SendTextView {
178                text: Some("Secret text".to_string()),
179                hidden: false,
180            }),
181            data: None,
182            max_access_count: None,
183            access_count: 0,
184            disabled: false,
185            hide_email: false,
186            revision_date: "2025-01-01T00:00:00Z".parse().unwrap(),
187            deletion_date: "2025-01-10T00:00:00Z".parse().unwrap(),
188            expiration_date: None,
189            emails: Vec::new(),
190            auth_type: AuthType::None,
191        };
192        let mut send = store.encrypt(send_view).unwrap();
193        send.id = Some(SendId::new(send_id));
194        repository.set(SendId::new(send_id), send).await.unwrap();
195
196        (store, repository)
197    }
198
199    #[tokio::test]
200    async fn test_delete_send() {
201        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
202        let (_store, repository) = make_store_with_send(send_id).await;
203        let pending = make_pending_deletions();
204
205        let api_client = ApiClient::new_mocked(move |mock| {
206            mock.sends_api
207                .expect_delete()
208                .returning(move |_id| Ok(()))
209                .once();
210        });
211
212        let result = delete_send(&api_client, &repository, &pending, SendId::new(send_id)).await;
213
214        assert!(result.is_ok());
215        assert!(
216            repository
217                .get(SendId::new(send_id))
218                .await
219                .unwrap()
220                .is_none()
221        );
222    }
223
224    #[tokio::test]
225    async fn test_delete_send_http_error() {
226        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
227        let (_store, repository) = make_store_with_send(send_id).await;
228        let pending = make_pending_deletions();
229
230        let api_client = ApiClient::new_mocked(move |mock| {
231            mock.sends_api
232                .expect_delete()
233                .returning(move |_id| {
234                    Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
235                        "Simulated error",
236                    )))
237                })
238                .once();
239        });
240
241        let result = delete_send(&api_client, &repository, &pending, SendId::new(send_id)).await;
242
243        assert!(result.is_err());
244        assert!(matches!(result.unwrap_err(), DeleteSendError::Api(_)));
245        // Send should still be in the repository since API call failed
246        assert!(
247            repository
248                .get(SendId::new(send_id))
249                .await
250                .unwrap()
251                .is_some()
252        );
253    }
254
255    #[tokio::test]
256    async fn test_delete_send_failure_queues_pending_deletion() {
257        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
258        let (_store, repository) = make_store_with_send(send_id).await;
259        let pending = make_pending_deletions();
260
261        let api_client = ApiClient::new_mocked(move |mock| {
262            mock.sends_api.expect_delete().returning(move |_id| {
263                Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
264                    "Simulated error",
265                )))
266            });
267        });
268
269        let result = delete_send(&api_client, &repository, &pending, SendId::new(send_id)).await;
270        assert!(result.is_err());
271
272        let queue = pending.try_get().await.unwrap().unwrap_or_default();
273        assert_eq!(queue, vec![SendId::new(send_id)]);
274    }
275
276    #[tokio::test]
277    async fn test_delete_send_failure_does_not_duplicate_queue_entry() {
278        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
279        let (_store, repository) = make_store_with_send(send_id).await;
280        let pending = make_pending_deletions();
281
282        let api_client = ApiClient::new_mocked(move |mock| {
283            mock.sends_api.expect_delete().returning(move |_id| {
284                Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
285                    "Simulated error",
286                )))
287            });
288        });
289
290        assert!(
291            delete_send(&api_client, &repository, &pending, SendId::new(send_id))
292                .await
293                .is_err()
294        );
295        assert!(
296            delete_send(&api_client, &repository, &pending, SendId::new(send_id))
297                .await
298                .is_err()
299        );
300
301        let queue = pending.try_get().await.unwrap().unwrap_or_default();
302        assert_eq!(queue, vec![SendId::new(send_id)]);
303    }
304
305    #[tokio::test]
306    async fn test_retry_pending_deletions_success_removes_from_queue_and_repository() {
307        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
308        let (_store, repository) = make_store_with_send(send_id).await;
309        let pending = make_pending_deletions();
310        pending.set(vec![SendId::new(send_id)]).await.unwrap();
311
312        let api_client = ApiClient::new_mocked(move |mock| {
313            mock.sends_api
314                .expect_delete()
315                .returning(move |_id| Ok(()))
316                .once();
317        });
318
319        retry_pending_deletions(&api_client, &repository, &pending)
320            .await
321            .unwrap();
322
323        let queue = pending.try_get().await.unwrap().unwrap_or_default();
324        assert!(queue.is_empty());
325        assert!(
326            repository
327                .get(SendId::new(send_id))
328                .await
329                .unwrap()
330                .is_none()
331        );
332    }
333
334    #[tokio::test]
335    async fn test_retry_pending_deletions_not_found_is_resolved() {
336        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
337        let (_store, repository) = make_store_with_send(send_id).await;
338        let pending = make_pending_deletions();
339        pending.set(vec![SendId::new(send_id)]).await.unwrap();
340
341        let api_client = ApiClient::new_mocked(move |mock| {
342            mock.sends_api
343                .expect_delete()
344                .returning(move |_id| {
345                    Err(bitwarden_api_api::ApiError::Response(ResponseContent {
346                        status: reqwest::StatusCode::NOT_FOUND,
347                        message: "not found".to_string(),
348                    }))
349                })
350                .once();
351        });
352
353        retry_pending_deletions(&api_client, &repository, &pending)
354            .await
355            .unwrap();
356
357        let queue = pending.try_get().await.unwrap().unwrap_or_default();
358        assert!(queue.is_empty());
359        assert!(
360            repository
361                .get(SendId::new(send_id))
362                .await
363                .unwrap()
364                .is_none()
365        );
366    }
367
368    #[tokio::test]
369    async fn test_retry_pending_deletions_other_error_stays_queued() {
370        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
371        let (_store, repository) = make_store_with_send(send_id).await;
372        let pending = make_pending_deletions();
373        pending.set(vec![SendId::new(send_id)]).await.unwrap();
374
375        let api_client = ApiClient::new_mocked(move |mock| {
376            mock.sends_api
377                .expect_delete()
378                .returning(move |_id| {
379                    Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
380                        "Simulated error",
381                    )))
382                })
383                .once();
384        });
385
386        retry_pending_deletions(&api_client, &repository, &pending)
387            .await
388            .unwrap();
389
390        let queue = pending.try_get().await.unwrap().unwrap_or_default();
391        assert_eq!(queue, vec![SendId::new(send_id)]);
392        // Still present server-side (from the client's view), so it must remain locally too.
393        assert!(
394            repository
395                .get(SendId::new(send_id))
396                .await
397                .unwrap()
398                .is_some()
399        );
400    }
401
402    #[tokio::test]
403    async fn test_retry_pending_deletions_mixed_batch() {
404        let resolved_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
405        let failing_id = uuid!("3b8e0f2a-1c4d-4e6f-9a7b-2d5c8e1f0a3b");
406        let (store, repository) = make_store_with_send(resolved_id).await;
407        // Add a second send sharing the same store so both live in one repository.
408        let mut send = store
409            .encrypt(SendView {
410                id: None,
411                access_id: None,
412                name: "Test Send".to_string(),
413                notes: None,
414                key: None,
415                new_password: None,
416                has_password: false,
417                r#type: SendType::Text,
418                file: None,
419                text: Some(SendTextView {
420                    text: Some("Secret text".to_string()),
421                    hidden: false,
422                }),
423                data: None,
424                max_access_count: None,
425                access_count: 0,
426                disabled: false,
427                hide_email: false,
428                revision_date: "2025-01-01T00:00:00Z".parse().unwrap(),
429                deletion_date: "2025-01-10T00:00:00Z".parse().unwrap(),
430                expiration_date: None,
431                emails: Vec::new(),
432                auth_type: AuthType::None,
433            })
434            .unwrap();
435        send.id = Some(SendId::new(failing_id));
436        repository.set(SendId::new(failing_id), send).await.unwrap();
437
438        let pending = make_pending_deletions();
439        pending
440            .set(vec![SendId::new(resolved_id), SendId::new(failing_id)])
441            .await
442            .unwrap();
443
444        let resolved_id_str = resolved_id.to_string();
445        let api_client = ApiClient::new_mocked(move |mock| {
446            mock.sends_api.expect_delete().returning(move |id| {
447                if id == resolved_id_str {
448                    Ok(())
449                } else {
450                    Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
451                        "Simulated error",
452                    )))
453                }
454            });
455        });
456
457        retry_pending_deletions(&api_client, &repository, &pending)
458            .await
459            .unwrap();
460
461        let queue = pending.try_get().await.unwrap().unwrap_or_default();
462        assert_eq!(queue, vec![SendId::new(failing_id)]);
463        assert!(
464            repository
465                .get(SendId::new(resolved_id))
466                .await
467                .unwrap()
468                .is_none()
469        );
470        assert!(
471            repository
472                .get(SendId::new(failing_id))
473                .await
474                .unwrap()
475                .is_some()
476        );
477    }
478
479    #[tokio::test]
480    async fn test_retry_pending_deletions_empty_queue_is_noop() {
481        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
482        let (_store, repository) = make_store_with_send(send_id).await;
483        let pending = make_pending_deletions();
484
485        // No delete calls expected for an empty queue.
486        let api_client = ApiClient::new_mocked(|_mock| {});
487
488        retry_pending_deletions(&api_client, &repository, &pending)
489            .await
490            .unwrap();
491    }
492
493    #[tokio::test]
494    async fn test_delete_send_failure_then_retry_success_resolves_orphan() {
495        let send_id = uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1");
496        let (_store, repository) = make_store_with_send(send_id).await;
497        let pending = make_pending_deletions();
498
499        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
500        let api_client = ApiClient::new_mocked(move |mock| {
501            let attempts = attempts.clone();
502            mock.sends_api.expect_delete().returning(move |_id| {
503                if attempts.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0 {
504                    Err(bitwarden_api_api::ApiError::Io(std::io::Error::other(
505                        "offline",
506                    )))
507                } else {
508                    Ok(())
509                }
510            });
511        });
512
513        // Create-then-upload-fails rollback: the delete itself fails, e.g. still offline.
514        let result = delete_send(&api_client, &repository, &pending, SendId::new(send_id)).await;
515        assert!(result.is_err());
516        assert!(
517            repository
518                .get(SendId::new(send_id))
519                .await
520                .unwrap()
521                .is_some(),
522            "orphaned Send stays visible until a retry resolves it"
523        );
524
525        // Next sync retries once connectivity is back.
526        retry_pending_deletions(&api_client, &repository, &pending)
527            .await
528            .unwrap();
529
530        assert!(
531            repository
532                .get(SendId::new(send_id))
533                .await
534                .unwrap()
535                .is_none()
536        );
537        assert!(
538            pending
539                .try_get()
540                .await
541                .unwrap()
542                .unwrap_or_default()
543                .is_empty()
544        );
545    }
546}