Struct SyncManager 

pub struct SyncManager { /* private fields */ }

SyncManager provides high-level document synchronization with automatic subdoc handling.

This manager automatically:

• Creates SyncProviders for subdocuments
• Tracks and cleans up subdoc providers
• Emits unified events for both main doc and subdocs

Example

use volt_client_grpc::{VoltClient, SyncManager};
use yrs::Doc;

let doc = Doc::new();
let (mut manager, mut events) = SyncManager::new(doc, "@my-sync-db", "my-document");

// Start syncing
manager.start(&client).await?;

// Handle events
while let Some(event) = events.recv().await {
    match event {
        SyncManagerEvent::Synced => println!("Document synced!"),
        SyncManagerEvent::SubdocUpdated { guid, doc } => {
            println!("Subdoc {} updated", guid);
        }
        _ => {}
    }
}

Implementations

impl SyncManager

pub fn new( doc: Doc, database_id: impl Into<String>, document_id: impl Into<String>, ) -> (Self, Receiver<SyncManagerEvent>)

Create a new SyncManager.

Arguments

• doc - The Y.js document to sync
• database_id - ID/alias of the sync database
• document_id - ID of the document to sync

Returns

A tuple of (SyncManager, event_receiver)

pub fn set_auto_sync_subdocs(&mut self, enabled: bool)

Enable or disable automatic subdoc syncing.

When enabled (default), the manager automatically creates SyncProviders for subdocuments detected in the main document.

pub fn doc(&self) -> &Doc

Get a reference to the main document.

pub fn doc_clone(&self) -> Doc

Get a clone of the main document.

pub fn database_id(&self) -> &str

Get the database ID.

pub fn document_id(&self) -> &str

Get the document ID.

pub fn subdoc_guids(&self) -> Vec<String>

Get the list of currently synced subdoc GUIDs.

pub fn is_subdoc_synced(&self, guid: &str) -> bool

Check if a subdoc is being synced.

pub fn get_subdoc(&self, guid: &str) -> Option<Doc>

Get a clone of a subdoc by GUID.

Returns None if the subdoc is not currently being synced.

pub async fn start(&mut self, client: &VoltClient) -> Result<()>

Start synchronization.

This starts the main document provider and sets up event handling. If auto_sync_subdocs is enabled, subdocs will be automatically synced.

Arguments

• client - The VoltClient to use for synchronization

pub async fn start_with_options( &mut self, client: &VoltClient, read_only: bool, read_only_fallback: bool, ) -> Result<()>

Start synchronization with options.

Arguments

• client - The VoltClient to use
• read_only - If true, only receive updates
• read_only_fallback - If true, downgrade to read-only if write access denied

pub async fn run_event_loop(&mut self, client: &VoltClient)

Run the event processing loop.

This should be called after start() to process events. It will run until the connection is closed or an error occurs.

Arguments

• client - The VoltClient (needed for starting subdoc providers)

Example

// In a spawned task:
manager.start(&client).await?;
manager.run_event_loop(&client).await;

pub async fn stop(&mut self)

Stop all synchronization.

pub fn root_map_to_json(&self) -> Value

Get the main document’s root map as JSON.

pub fn root_map_to_json_string(&self) -> String

Get the main document’s root map as a JSON string.