Add path change to server

sync-server/src/app_state/database.rs

@@ -16,6 +16,24 @@ pub mod models;
 #[error("Database is busy")]
 pub struct WriteBusyError;
 
+/// Tells [`Database::insert_document_version`] which WebSocket events the
+/// just-committed version should produce. The caller is the only party
+/// with enough context to decide this (the DB layer has no access to
+/// "what the client sent" or "what the prior version looked like").
+#[derive(Debug, Clone, Copy, Default)]
+pub struct InsertBroadcast {
+    /// Emit a `VaultUpdate` (filtered from the origin device). Set when
+    /// the stored bytes differ from the prior version's bytes — i.e.
+    /// peers need to pull new content.
+    pub content_changed: bool,
+
+    /// Emit a `PathChange` (delivered to every client, origin included).
+    /// Set when the stored path differs from the prior stored path *or*
+    /// from the path the origin client sent — i.e. someone needs to
+    /// reconcile a dedupe, rename, or first-rename-wins outcome.
+    pub path_changed: bool,
+}
+
 use sqlx::{
     Pool, Sqlite, pool::PoolConnection, sqlite::SqliteConnection, sqlite::SqlitePoolOptions,
 };
@@ -25,7 +43,10 @@ use uuid::fmt::Hyphenated;
 
 use super::websocket::{
     broadcasts::Broadcasts,
-    models::{WebSocketServerMessage, WebSocketServerMessageWithOrigin, WebSocketVaultUpdate},
+    models::{
+        WebSocketServerMessage, WebSocketServerMessageWithOrigin, WebSocketVaultPathChange,
+        WebSocketVaultUpdate,
+    },
 };
 use crate::config::database_config::DatabaseConfig;
 use crate::consts::IDLE_POOL_TIMEOUT;
@@ -669,6 +690,7 @@ impl Database {
         vault_id: &VaultId,
         version: &StoredDocumentVersion,
         mut transaction: WriteTransaction,
+        broadcast: InsertBroadcast,
     ) -> Result<()> {
         let document_id = version.document_id.as_hyphenated();
         let query = sqlx::query!(
@@ -712,18 +734,43 @@ impl Database {
             .await
             .context("Failed to commit transaction")?;
 
-        self.broadcasts
-            .send_document_update(
-                vault_id.clone(),
-                WebSocketServerMessageWithOrigin::with_origin(
-                    version.device_id.clone(),
-                    WebSocketServerMessage::VaultUpdate(WebSocketVaultUpdate {
-                        documents: vec![version.clone().into()],
-                        is_initial_sync: false,
-                    }),
-                ),
-            )
-            .await;
+        if broadcast.content_changed {
+            // Content events are filtered out for the origin device — the
+            // origin already has the content (or learns about the merge
+            // via the HTTP response).
+            self.broadcasts
+                .send_document_update(
+                    vault_id.clone(),
+                    WebSocketServerMessageWithOrigin::with_origin(
+                        version.device_id.clone(),
+                        WebSocketServerMessage::VaultUpdate(WebSocketVaultUpdate {
+                            documents: vec![version.clone().into()],
+                            is_initial_sync: false,
+                        }),
+                    ),
+                )
+                .await;
+        }
+
+        if broadcast.path_changed {
+            // Path change events intentionally carry no origin so *every*
+            // connected client (including the one that made the write)
+            // receives them. The create/update HTTP response no longer
+            // carries `relative_path`, so the origin device relies on this
+            // event to learn the server-canonical path.
+            self.broadcasts
+                .send_document_update(
+                    vault_id.clone(),
+                    WebSocketServerMessageWithOrigin::new(WebSocketServerMessage::PathChange(
+                        WebSocketVaultPathChange {
+                            vault_update_id: version.vault_update_id,
+                            document_id: version.document_id,
+                            relative_path: version.relative_path.clone(),
+                        },
+                    )),
+                )
+                .await;
+        }
 
         Ok(())
     }

sync-server/src/app_state/database/models.rs

@@ -77,6 +77,72 @@ pub struct DocumentVersion {
     pub device_id: DeviceId,
 }
 
+/// Like [`DocumentVersionWithoutContent`] but without the `relative_path`.
+/// Used only in create/update responses where the client already tracks
+/// the path locally (the server is the source of truth for the
+/// document identity, not its path).
+#[derive(TS, Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentUpdateMetadata {
+    #[ts(type = "number")]
+    pub vault_update_id: VaultUpdateId,
+
+    pub document_id: DocumentId,
+    pub updated_date: DateTime<Utc>,
+    pub is_deleted: bool,
+    pub user_id: UserId,
+    pub device_id: DeviceId,
+
+    #[ts(type = "number")]
+    pub content_size: u64,
+}
+
+impl From<StoredDocumentVersion> for DocumentUpdateMetadata {
+    fn from(value: StoredDocumentVersion) -> Self {
+        Self {
+            vault_update_id: value.vault_update_id,
+            document_id: value.document_id,
+            updated_date: value.updated_date,
+            is_deleted: value.is_deleted,
+            user_id: value.user_id,
+            device_id: value.device_id,
+            content_size: value.content.len() as u64,
+        }
+    }
+}
+
+/// Like [`DocumentVersion`] but without the `relative_path`.
+/// Used only in create/update responses when the server had to merge the
+/// client's content with a newer remote version and therefore must echo
+/// the merged content back.
+#[derive(TS, Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentUpdateMergedContent {
+    #[ts(type = "number")]
+    pub vault_update_id: VaultUpdateId,
+
+    pub document_id: DocumentId,
+    pub updated_date: DateTime<Utc>,
+    pub content_base64: String,
+    pub is_deleted: bool,
+    pub user_id: UserId,
+    pub device_id: DeviceId,
+}
+
+impl From<StoredDocumentVersion> for DocumentUpdateMergedContent {
+    fn from(value: StoredDocumentVersion) -> Self {
+        Self {
+            vault_update_id: value.vault_update_id,
+            document_id: value.document_id,
+            updated_date: value.updated_date,
+            content_base64: STANDARD.encode(&value.content),
+            is_deleted: value.is_deleted,
+            user_id: value.user_id,
+            device_id: value.device_id,
+        }
+    }
+}
+
 /// Row struct for vault history queries (used by `sqlx::query_as!`)
 #[derive(Debug)]
 pub struct VaultHistoryRow {

sync-server/src/app_state/websocket/models.rs

@@ -64,6 +64,15 @@ pub struct WebSocketVaultUpdate {
     pub is_initial_sync: bool,
 }
 
+#[derive(TS, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct WebSocketVaultPathChange {
+    #[ts(type = "number")]
+    pub vault_update_id: VaultUpdateId,
+    pub document_id: DocumentId,
+    pub relative_path: String,
+}
+
 #[derive(TS, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase", tag = "type")]
 #[ts(export)]
@@ -77,6 +86,7 @@ pub enum WebSocketClientMessage {
 #[ts(export)]
 pub enum WebSocketServerMessage {
     VaultUpdate(WebSocketVaultUpdate),
+    PathChange(WebSocketVaultPathChange),
     CursorPositions(CursorPositionFromServer),
 }