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
12register_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 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
44async 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 Ok(())
78 | Err(ApiError::Response(ResponseContent {
79 status: reqwest::StatusCode::NOT_FOUND,
80 ..
81 })) => {
82 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 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 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 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 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 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 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 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 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 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}