Skip to main content

bitwarden_vault/folder/
folder_sync_handler.rs

1use std::sync::Arc;
2
3use bitwarden_core::{FromClient, require};
4use bitwarden_state::repository::{Repository, RepositoryOption};
5use bitwarden_sync::{SyncHandler, SyncHandlerError};
6
7use crate::{Folder, FolderId};
8
9/// Sync handler for folders
10///
11/// This handler persists folders to SDK-managed storage.
12#[derive(FromClient)]
13pub struct FolderSyncHandler {
14    repository: Option<Arc<dyn Repository<Folder>>>,
15}
16
17#[async_trait::async_trait]
18impl SyncHandler for FolderSyncHandler {
19    async fn on_sync(
20        &self,
21        response: &bitwarden_api_api::models::SyncResponseModel,
22    ) -> Result<(), SyncHandlerError> {
23        let repository = self.repository.require()?;
24        let api_folders = require!(response.folders.as_ref());
25
26        let folders: Vec<(FolderId, Folder)> = api_folders
27            .iter()
28            .filter_map(|f| {
29                Folder::try_from(f.clone())
30                    .inspect_err(
31                        |e| tracing::error!(id = ?f.id, error = ?e, "Failed to deserialize folder"),
32                    )
33                    .ok()
34                    .and_then(|folder| {
35                        let id = folder.id.or_else(|| {
36                            tracing::error!("Skipping folder with missing id");
37                            None
38                        })?;
39                        Some((id, folder))
40                    })
41            })
42            .collect();
43
44        repository.replace_all(folders).await?;
45
46        Ok(())
47    }
48}
49
50#[cfg(test)]
51mod tests {
52    use std::sync::Arc;
53
54    use bitwarden_api_api::models::{FolderResponseModel, SyncResponseModel};
55    use bitwarden_test::MemoryRepository;
56
57    use super::*;
58
59    /// Valid EncString in type 2 format (Aes256CbcHmac): `2.<iv>|<data>|<mac>`
60    const ENCRYPTED_NAME: &str = "2.AAAAAAAAAAAAAAAAAAAAAA==|AAAAAAAAAAAAAAAAAAAAAA==|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
61
62    fn make_folder_response(id: uuid::Uuid) -> FolderResponseModel {
63        FolderResponseModel {
64            object: Some("folder".to_string()),
65            id: Some(id),
66            name: Some(ENCRYPTED_NAME.to_string()),
67            revision_date: Some("2025-01-01T00:00:00Z".to_string()),
68        }
69    }
70
71    #[tokio::test]
72    async fn test_on_sync_replaces_existing_folders() {
73        let repository = Arc::new(MemoryRepository::<Folder>::default());
74        let handler = FolderSyncHandler {
75            repository: Some(repository.clone()),
76        };
77
78        // First sync with two folders
79        let id1 = uuid::Uuid::new_v4();
80        let id2 = uuid::Uuid::new_v4();
81        let response = SyncResponseModel {
82            folders: Some(vec![make_folder_response(id1), make_folder_response(id2)]),
83            ..Default::default()
84        };
85        handler.on_sync(&response).await.unwrap();
86        assert_eq!(repository.list().await.unwrap().len(), 2);
87
88        // Second sync with only one folder — old ones should be gone
89        let id3 = uuid::Uuid::new_v4();
90        let response = SyncResponseModel {
91            folders: Some(vec![make_folder_response(id3)]),
92            ..Default::default()
93        };
94        handler.on_sync(&response).await.unwrap();
95
96        let stored = repository.list().await.unwrap();
97        assert_eq!(stored.len(), 1);
98        assert!(repository.get(FolderId::new(id1)).await.unwrap().is_none());
99        assert!(repository.get(FolderId::new(id2)).await.unwrap().is_none());
100        assert!(repository.get(FolderId::new(id3)).await.unwrap().is_some());
101    }
102
103    #[tokio::test]
104    async fn test_on_sync_no_folders_returns_error() {
105        let repository = Arc::new(MemoryRepository::<Folder>::default());
106        let handler = FolderSyncHandler {
107            repository: Some(repository.clone()),
108        };
109
110        let response = SyncResponseModel::default();
111        let result = handler.on_sync(&response).await;
112        assert!(result.is_err());
113    }
114}