Struct SyncClient 

pub struct SyncClient {
    api_configurations: Arc<ApiConfigurations>,
    sync_handlers: HandlerRegistry<dyn SyncHandler>,
    error_handlers: HandlerRegistry<dyn SyncErrorHandler>,
    sync_lock: Mutex<()>,
}

Client for performing sync operations with event support

This client wraps the core sync functionality and provides hooks for registering event handlers that can respond to sync operations.

Fields

api_configurations: Arc<ApiConfigurations>

sync_handlers: HandlerRegistry<dyn SyncHandler>

error_handlers: HandlerRegistry<dyn SyncErrorHandler>

sync_lock: Mutex<()>

Implementations

impl SyncClient

pub fn new(client: Client) -> Self

Create a new SyncClient from a Bitwarden client

pub fn register_sync_handler(&self, handler: Arc<dyn SyncHandler>)

Register a sync handler for sync operations

Handlers are called in registration order. If any handler returns an error, the sync operation is aborted immediately and subsequent handlers are not called.

pub fn register_error_handler(&self, handler: Arc<dyn SyncErrorHandler>)

Register an error handler for sync operations

Error handlers are called when any error occurs during sync, including API errors and handler errors. All error handlers are always called regardless of individual failures.

pub async fn sync( &self, request: SyncRequest, ) -> Result<SyncResponseModel, SyncError>

Perform a full sync operation

This method:

1. Performs the sync with the Bitwarden API
2. On success, dispatches on_sync with the sync response to all registered handlers
3. Dispatches on_sync_complete to all handlers for post-processing
4. On error (from API or handlers), notifies all registered error handlers

Handlers receive the raw API models and are responsible for converting to domain types as needed. This allows each handler to decide how to process the data.

If any error occurs, all registered error handlers are notified before the error is returned to the caller.

async fn run_handlers( &self, response: &SyncResponseModel, ) -> Result<(), SyncError>

Run sync handlers for a completed sync operation

Executes two phases sequentially:

1. Calls SyncHandler::on_sync on all handlers with the response
2. Calls SyncHandler::on_sync_complete on all handlers

Stops on first error and returns it immediately.

async fn run_error_handlers(&self, error: &SyncError)

Run all error handlers for a sync error

All error handlers are called sequentially in registration order.

async fn perform_sync( &self, input: &SyncRequest, ) -> Result<SyncResponseModel, SyncError>

Performs the actual sync operation with the Bitwarden API