Add API for propagating cursor locations (#61)

backend/sync_server/Cargo.toml

@@ -18,25 +18,23 @@ log = { version = "0.4.27" }
 anyhow =  { version = "1.0.98", features = ["backtrace"] }
 axum = { version = "0.7.4", features = ["ws", "macros", "tracing", "multipart"]}
 axum-extra = { version = "0.9.6", features = ["typed-header"] }
-aide-axum-typed-multipart = "0.13.0"
 axum_typed_multipart = "0.11.0"
 tower-http = { version = "0.6.1", features = ["cors", "trace", "limit", "timeout"] }
+tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["fmt", "env-filter"]}
-serde_yaml = "0.9.34"
 sqlx = { version = "0.8.6", features = ["sqlite", "runtime-tokio", "uuid", "chrono"] }
 chrono = { version = "0.4.41", features = ["serde"] }
-aide = { version = "0.13.5", features = ["axum", "axum-ws", "scalar", "axum-headers"] }
-schemars = { version = "0.8.22", features = ["chrono", "uuid1", "bytes"] }
-tracing = "0.1.41"
 rand = "0.9.0"
 sanitize-filename = "0.6.0"
-axum-jsonschema = { version = "0.8.0", features = ["aide"] }
 regex = "1.11.1"
 clap = { version = "4.5.38", features = ["derive"] }
 futures = "0.3.31"
+serde_yaml = "0.9.34"
 serde_json = "1.0.140"
 clap-verbosity-flag = "3.0.3"
 bimap = "0.6.3"
+ts-rs =  { version = "10.1", features = ["uuid-impl", "chrono-impl"] }
+serde_with = "3.12.0"
 
 [lints]
 workspace = true

backend/sync_server/src/app_state.rs

@@ -1,11 +1,13 @@
-pub mod broadcasts;
+pub mod cursors;
 pub mod database;
+pub mod websocket;
 
 use std::ffi::OsString;
 
 use anyhow::Result;
-use broadcasts::Broadcasts;
+use cursors::Cursors;
 use database::Database;
+use websocket::broadcasts::Broadcasts;
 
 use crate::{config::Config, consts::DEFAULT_CONFIG_PATH};
 
@@ -13,6 +15,7 @@ use crate::{config::Config, consts::DEFAULT_CONFIG_PATH};
 pub struct AppState {
     pub config: Config,
     pub database: Database,
+    pub cursors: Cursors,
     pub broadcasts: Broadcasts,
 }
 
@@ -22,12 +25,16 @@ impl AppState {
         let path = std::path::PathBuf::from(config_path);
 
         let config = Config::read_or_create(&path).await?;
-        let database = Database::try_new(&config.database).await?;
         let broadcasts = Broadcasts::new(&config.server);
+        let database = Database::try_new(&config.database, &broadcasts).await?;
+        let cursors: Cursors = Cursors::new(&config.database, &broadcasts);
+
+        Cursors::start_background_task(cursors.clone());
 
         Ok(Self {
             config,
             database,
+            cursors,
             broadcasts,
         })
     }

backend/sync_server/src/app_state/cursors.rs

@@ -0,0 +1,128 @@
+use core::time::Duration;
+use std::{collections::HashMap, sync::Arc};
+
+use tokio::sync::Mutex;
+
+use super::{
+    database::models::{DeviceId, VaultId},
+    websocket::{
+        broadcasts::Broadcasts,
+        models::{
+            ClientCursors, CursorPositionFromServer, CursorSpan, WebSocketServerMessage,
+            WebSocketServerMessageWithOrigin,
+        },
+    },
+};
+use crate::config::database_config::DatabaseConfig;
+
+#[derive(Clone, Debug)]
+pub struct Cursors {
+    config: DatabaseConfig,
+    broadcasts: Broadcasts,
+    vault_to_cursors: Arc<Mutex<HashMap<VaultId, Vec<ClientCursorsWithTimeToLive>>>>,
+}
+
+impl Cursors {
+    pub fn new(config: &DatabaseConfig, broadcasts: &Broadcasts) -> Self {
+        Self {
+            config: config.clone(),
+            broadcasts: broadcasts.clone(),
+            vault_to_cursors: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub async fn update_cursors(
+        &self,
+        vault_id: VaultId,
+        user_name: String,
+        device_id: &DeviceId,
+        document_to_cursors: HashMap<String, Vec<CursorSpan>>,
+    ) {
+        let mut vault_to_cursors = self.vault_to_cursors.lock().await;
+
+        let all_device_cursors = vault_to_cursors.entry(vault_id).or_insert_with(Vec::new);
+
+        all_device_cursors.retain(|c| &c.client_cursors.device_id != device_id);
+        all_device_cursors.push(ClientCursorsWithTimeToLive::new(ClientCursors {
+            user_name,
+            device_id: device_id.to_string(),
+            cursors: document_to_cursors,
+        }));
+
+        drop(vault_to_cursors); // Explicitly drop the lock before broadcasting to avoid deadlock
+        self.broadcast_cursors().await;
+    }
+
+    pub async fn get_cursors(&self, vault_id: &VaultId) -> Vec<ClientCursors> {
+        let vault_to_cursors = self.vault_to_cursors.lock().await;
+        vault_to_cursors
+            .get(vault_id)
+            .map(|cursors| {
+                cursors
+                    .iter()
+                    .cloned()
+                    .map(|with_ttl| with_ttl.client_cursors)
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default()
+    }
+
+    pub fn start_background_task(self) {
+        tokio::spawn(async move {
+            loop {
+                self.remove_expired_cursors().await;
+                tokio::time::sleep(Duration::from_secs(1)).await;
+            }
+        });
+    }
+
+    async fn remove_expired_cursors(&self) {
+        let mut vault_to_cursors = self.vault_to_cursors.lock().await;
+
+        for (_vault_id, cursors) in vault_to_cursors.iter_mut() {
+            cursors.retain(|cursor| !cursor.is_expired(self.config.cursor_timeout));
+        }
+    }
+
+    async fn broadcast_cursors(&self) {
+        let vault_to_cursors = self.vault_to_cursors.lock().await;
+
+        for (vault_id, cursors) in vault_to_cursors.iter() {
+            self.broadcasts
+                .send_document_update(
+                    vault_id.clone(),
+                    WebSocketServerMessageWithOrigin::new(WebSocketServerMessage::CursorPositions(
+                        CursorPositionFromServer {
+                            clients: cursors.iter().map(|c| c.client_cursors.clone()).collect(),
+                        },
+                    )),
+                )
+                .await;
+        }
+    }
+
+    pub async fn remove_cursors_of_device(&self, vault_id: &str, device_id: &str) {
+        let mut vault_to_cursors = self.vault_to_cursors.lock().await;
+
+        if let Some(cursors) = vault_to_cursors.get_mut(vault_id) {
+            cursors.retain(|c| c.client_cursors.device_id != device_id);
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ClientCursorsWithTimeToLive {
+    client_cursors: ClientCursors,
+    last_updated: std::time::Instant,
+}
+
+impl ClientCursorsWithTimeToLive {
+    fn new(client_cursors: ClientCursors) -> Self {
+        Self {
+            client_cursors,
+            last_updated: std::time::Instant::now(),
+        }
+    }
+
+    pub fn is_expired(&self, ttl: Duration) -> bool { self.last_updated.elapsed() > ttl }
+}

backend/sync_server/src/app_state/database.rs

@@ -6,23 +6,29 @@ use models::{
     DocumentId, DocumentVersionWithoutContent, StoredDocumentVersion, VaultId, VaultUpdateId,
 };
 use sqlx::{sqlite::SqliteConnectOptions, types::chrono::Utc};
+
 pub mod models;
 use sqlx::{Pool, Sqlite, sqlite::SqlitePoolOptions};
 use tokio::sync::Mutex;
 use uuid::fmt::Hyphenated;
 
+use super::websocket::{
+    broadcasts::Broadcasts,
+    models::{WebSocketServerMessage, WebSocketServerMessageWithOrigin, WebSocketVaultUpdate},
+};
 use crate::config::database_config::DatabaseConfig;
 
 #[derive(Clone, Debug)]
 pub struct Database {
     config: DatabaseConfig,
+    broadcasts: Broadcasts,
     connection_pools: Arc<Mutex<HashMap<VaultId, Pool<Sqlite>>>>,
 }
 
 pub type Transaction<'a> = sqlx::Transaction<'a, Sqlite>;
 
 impl Database {
-    pub async fn try_new(config: &DatabaseConfig) -> Result<Self> {
+    pub async fn try_new(config: &DatabaseConfig, broadcasts: &Broadcasts) -> Result<Self> {
         tokio::fs::create_dir_all(&config.databases_directory_path)
             .await
             .with_context(|| {
@@ -55,6 +61,7 @@ impl Database {
         Ok(Self {
             config: config.clone(),
             connection_pools: Arc::new(Mutex::new(connection_pools)),
+            broadcasts: broadcasts.clone(),
         })
     }
 
@@ -362,7 +369,7 @@ impl Database {
 
     pub async fn insert_document_version(
         &self,
-        vault: &VaultId,
+        vault_id: &VaultId,
         version: &StoredDocumentVersion,
         transaction: Option<&mut Transaction<'_>>,
     ) -> Result<()> {
@@ -394,10 +401,25 @@ impl Database {
         if let Some(transaction) = transaction {
             query.execute(&mut **transaction).await
         } else {
-            query.execute(&self.get_connection_pool(vault).await?).await
+            query
+                .execute(&self.get_connection_pool(vault_id).await?)
+                .await
         }
         .context("Cannot insert document version")?;
 
+        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;
+
         Ok(())
     }
 }

backend/sync_server/src/app_state/database/models.rs

@@ -1,10 +1,11 @@
 use chrono::{DateTime, Utc};
-use schemars::JsonSchema;
 use serde::Serialize;
 use sync_lib::bytes_to_base64;
+use ts_rs::TS;
 
 pub type VaultId = String;
 pub type VaultUpdateId = i64;
+
 pub type DocumentId = uuid::Uuid;
 pub type UserId = String;
 pub type DeviceId = String;
@@ -25,16 +26,20 @@ impl PartialEq<Self> for StoredDocumentVersion {
     fn eq(&self, other: &Self) -> bool { self.vault_update_id == other.vault_update_id }
 }
 
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DocumentVersionWithoutContent {
+    #[ts(as = "i32")]
     pub vault_update_id: VaultUpdateId,
+
     pub document_id: DocumentId,
     pub relative_path: String,
     pub updated_date: DateTime<Utc>,
     pub is_deleted: bool,
     pub user_id: UserId,
     pub device_id: DeviceId,
+
+    #[ts(as = "i32")]
     pub content_size: u64,
 }
 
@@ -53,10 +58,12 @@ impl From<StoredDocumentVersion> for DocumentVersionWithoutContent {
     }
 }
 
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DocumentVersion {
+    #[ts(as = "i32")]
     pub vault_update_id: VaultUpdateId,
+
     pub document_id: DocumentId,
     pub relative_path: String,
     pub updated_date: DateTime<Utc>,

backend/sync_server/src/app_state/websocket.rs

@@ -0,0 +1,3 @@
+pub mod broadcasts;
+pub mod models;
+pub mod utils;

backend/sync_server/src/app_state/websocket/broadcasts.rs

@@ -3,19 +3,15 @@ use std::{collections::HashMap, sync::Arc};
 use anyhow::Context;
 use tokio::sync::{Mutex, broadcast};
 
-use super::database::models::{DeviceId, DocumentVersionWithoutContent, VaultId};
-use crate::{config::server_config::ServerConfig, errors::server_error};
+use super::models::WebSocketServerMessageWithOrigin;
+use crate::{
+    app_state::database::models::VaultId, config::server_config::ServerConfig, errors::server_error,
+};
 
 #[derive(Debug, Clone)]
 pub struct Broadcasts {
     max_clients_per_vault: usize,
-    tx: Arc<Mutex<HashMap<VaultId, broadcast::Sender<VaultUpdate>>>>,
-}
-
-#[derive(Debug, Clone)]
-pub struct VaultUpdate {
-    pub origin_device_id: Option<DeviceId>,
-    pub document: DocumentVersionWithoutContent,
+    tx: Arc<Mutex<HashMap<VaultId, broadcast::Sender<WebSocketServerMessageWithOrigin>>>>,
 }
 
 impl Broadcasts {
@@ -26,20 +22,27 @@ impl Broadcasts {
         }
     }
 
-    pub async fn get_receiver(&self, vault: VaultId) -> broadcast::Receiver<VaultUpdate> {
+    pub async fn get_receiver(
+        &self,
+        vault: VaultId,
+    ) -> broadcast::Receiver<WebSocketServerMessageWithOrigin> {
         let tx = self.get_or_create(vault).await;
 
         tx.subscribe()
     }
 
-    /// Sent a document update to all clients subscribed to the vault.
-    /// We ignore & log failures.
-    pub async fn send(&self, vault: VaultId, document: VaultUpdate) {
+    /// Notify all clients (who are subscribed to the vault) about an update.
+    /// We only log failures.
+    pub async fn send_document_update(
+        &self,
+        vault: VaultId,
+        document: WebSocketServerMessageWithOrigin,
+    ) {
         let tx = self.get_or_create(vault).await;
 
         let result = tx
             .send(document)
-            .context("Cannot broadcast update message to websocket listeners")
+            .context("Cannot broadcast server message to websocket listeners")
             .map_err(server_error);
 
         if result.is_err() {
@@ -47,7 +50,10 @@ impl Broadcasts {
         }
     }
 
-    async fn get_or_create(&self, vault: VaultId) -> broadcast::Sender<VaultUpdate> {
+    async fn get_or_create(
+        &self,
+        vault: VaultId,
+    ) -> broadcast::Sender<WebSocketServerMessageWithOrigin> {
         let mut tx = self.tx.lock().await;
 
         tx.entry(vault)

backend/sync_server/src/app_state/websocket/models.rs

@@ -0,0 +1,88 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+use crate::app_state::database::models::{DeviceId, DocumentVersionWithoutContent, VaultUpdateId};
+
+#[derive(TS, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct WebSocketHandshake {
+    pub token: String,
+    pub device_id: DeviceId,
+
+    #[ts(as = "Option<i32>")]
+    pub last_seen_vault_update_id: Option<VaultUpdateId>,
+}
+
+#[derive(TS, Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CursorSpan {
+    pub start: usize,
+    pub end: usize,
+}
+
+#[derive(TS, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CursorPositionFromClient {
+    pub document_to_cursors: HashMap<String, Vec<CursorSpan>>,
+}
+
+#[derive(TS, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ClientCursors {
+    pub user_name: String,
+    pub device_id: DeviceId,
+    pub cursors: HashMap<String, Vec<CursorSpan>>,
+}
+
+#[derive(TS, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CursorPositionFromServer {
+    pub clients: Vec<ClientCursors>,
+}
+
+#[derive(TS, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct WebSocketVaultUpdate {
+    pub documents: Vec<DocumentVersionWithoutContent>,
+    pub is_initial_sync: bool,
+}
+
+#[derive(TS, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase", tag = "type")]
+#[ts(export)]
+pub enum WebSocketClientMessage {
+    Handshake(WebSocketHandshake),
+    CursorPositions(CursorPositionFromClient),
+}
+
+#[derive(TS, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase", tag = "type")]
+#[ts(export)]
+pub enum WebSocketServerMessage {
+    VaultUpdate(WebSocketVaultUpdate),
+    CursorPositions(CursorPositionFromServer),
+}
+
+#[derive(Clone, Debug)]
+pub struct WebSocketServerMessageWithOrigin {
+    pub origin_device_id: Option<DeviceId>,
+    pub message: WebSocketServerMessage,
+}
+
+impl WebSocketServerMessageWithOrigin {
+    pub fn new(message: WebSocketServerMessage) -> Self {
+        Self {
+            origin_device_id: None,
+            message,
+        }
+    }
+
+    pub fn with_origin(origin_device_id: DeviceId, message: WebSocketServerMessage) -> Self {
+        Self {
+            origin_device_id: Some(origin_device_id),
+            message,
+        }
+    }
+}

backend/sync_server/src/app_state/websocket/utils.rs

@@ -0,0 +1,80 @@
+use anyhow::Context;
+use axum::extract::ws::{Message, WebSocket};
+use futures::{sink::SinkExt, stream::SplitSink};
+
+use super::models::{WebSocketClientMessage, WebSocketHandshake, WebSocketServerMessage};
+use crate::{
+    app_state::{
+        AppState,
+        database::models::{DocumentVersionWithoutContent, VaultId, VaultUpdateId},
+    },
+    config::user_config::User,
+    errors::{SyncServerError, server_error, unauthenticated_error},
+    server::auth::auth,
+};
+
+pub struct AuthenticatedWebSocketHandshake {
+    pub handshake: WebSocketHandshake,
+    pub user: User,
+}
+
+pub fn get_authenticated_handshake(
+    state: &AppState,
+    vault_id: &VaultId,
+    message: Option<Message>,
+) -> Result<AuthenticatedWebSocketHandshake, SyncServerError> {
+    if let Some(Message::Text(message)) = message {
+        let message: WebSocketClientMessage = serde_json::from_str(&message)
+            .context("Failed to parse message")
+            .map_err(server_error)?;
+
+        match message {
+            WebSocketClientMessage::Handshake(handshake) => {
+                let user = auth(state, handshake.token.trim(), vault_id)?;
+                Ok(AuthenticatedWebSocketHandshake { handshake, user })
+            }
+            WebSocketClientMessage::CursorPositions(_) => Err(unauthenticated_error(
+                anyhow::anyhow!("Expected a handshake message"),
+            )),
+        }
+    } else {
+        Err(unauthenticated_error(anyhow::anyhow!(
+            "Failed to authenticate due to invalid message"
+        )))
+    }
+}
+
+pub async fn get_unseen_documents(
+    state: &AppState,
+    vault_id: &VaultId,
+    last_seen_vault_update_id: Option<VaultUpdateId>,
+) -> Result<Vec<DocumentVersionWithoutContent>, SyncServerError> {
+    if let Some(update_id) = last_seen_vault_update_id {
+        state
+            .database
+            .get_latest_documents_since(vault_id, update_id, None)
+            .await
+            .map_err(server_error)
+    } else {
+        state
+            .database
+            .get_latest_documents(vault_id, None)
+            .await
+            .map_err(server_error)
+    }
+}
+
+pub async fn send_update_over_websocket(
+    update: &WebSocketServerMessage,
+    sender: &mut SplitSink<WebSocket, Message>,
+) -> Result<(), SyncServerError> {
+    let serialized_update = serde_json::to_string(update)
+        .context("Failed to serialize update")
+        .map_err(server_error)?;
+
+    sender
+        .send(Message::Text(serialized_update))
+        .await
+        .context("Failed to send message over websocket")
+        .map_err(server_error)
+}

backend/sync_server/src/config.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use anyhow::{Context as _, Result};
 use database_config::DatabaseConfig;
-use log::{info, warn};
+use log::info;
 use serde::{Deserialize, Serialize};
 use server_config::ServerConfig;
 use tokio::fs;
@@ -24,21 +24,23 @@ pub struct Config {
 
 impl Config {
     pub async fn read_or_create(path: &Path) -> Result<Self> {
-        if path.exists() {
+        let config = if path.exists() {
             info!(
                 "Loading configuration from '{}'",
                 path.canonicalize().unwrap().display()
             );
-            Self::load_from_file(path).await
+            Self::load_from_file(path).await?
         } else {
-            let config = Self::default();
-            config.write(path).await?;
-            warn!(
-                "Configuration file not found, wrote default configuration to '{}'",
-                path.canonicalize().unwrap().display()
-            );
-            Ok(config)
-        }
+            Self::default()
+        };
+
+        config.write(path).await?;
+        info!(
+            "Updated configuration at '{}'",
+            path.canonicalize().unwrap().display()
+        );
+
+        Ok(config)
     }
 
     pub async fn load_from_file(path: &Path) -> Result<Self> {

backend/sync_server/src/config/database_config.rs

@@ -1,10 +1,14 @@
-use std::path::PathBuf;
+use std::{path::PathBuf, time::Duration};
 
 use log::debug;
 use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
 
-use crate::consts::{DEFAULT_DATABASES_DIRECTORY_PATH, DEFAULT_MAX_CONNECTIONS_PER_VAULT};
+use crate::consts::{
+    DEFAULT_CURSOR_TIMEOUT, DEFAULT_DATABASES_DIRECTORY_PATH, DEFAULT_MAX_CONNECTIONS_PER_VAULT,
+};
 
+#[serde_with::serde_as]
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct DatabaseConfig {
     #[serde(default = "default_databases_directory_path")]
@@ -12,6 +16,10 @@ pub struct DatabaseConfig {
 
     #[serde(default = "default_max_connections_per_vault")]
     pub max_connections_per_vault: u32,
+
+    #[serde(default = "default_cursor_timeout", rename = "cursor_timeout_seconds")]
+    #[serde_as(as = "serde_with::DurationSeconds<u64>")]
+    pub cursor_timeout: Duration,
 }
 
 fn default_databases_directory_path() -> PathBuf {
@@ -24,11 +32,17 @@ fn default_max_connections_per_vault() -> u32 {
     DEFAULT_MAX_CONNECTIONS_PER_VAULT
 }
 
+fn default_cursor_timeout() -> Duration {
+    debug!("Using default cursor timeout: {DEFAULT_CURSOR_TIMEOUT:?}");
+    DEFAULT_CURSOR_TIMEOUT
+}
+
 impl Default for DatabaseConfig {
     fn default() -> Self {
         Self {
             databases_directory_path: default_databases_directory_path(),
             max_connections_per_vault: default_max_connections_per_vault(),
+            cursor_timeout: default_cursor_timeout(),
         }
     }
 }

backend/sync_server/src/consts.rs

@@ -1,8 +1,13 @@
+use std::time::Duration;
+
 pub const DEFAULT_CONFIG_PATH: &str = "config.yml";
+
 pub const DEFAULT_DATABASES_DIRECTORY_PATH: &str = "databases";
+pub const DEFAULT_MAX_CONNECTIONS_PER_VAULT: u32 = 12;
+pub const DEFAULT_CURSOR_TIMEOUT: Duration = Duration::from_secs(60);
+
 pub const DEFAULT_HOST: &str = "127.0.0.1";
 pub const DEFAULT_PORT: u16 = 3000;
-pub const DEFAULT_MAX_CONNECTIONS_PER_VAULT: u32 = 12;
 pub const DEFAULT_MAX_BODY_SIZE_MB: usize = 4096;
 pub const DEFAULT_RESPONSE_TIMEOUT_SECONDS: u64 = 60;
 pub const DEFAULT_MAX_CLIENTS_PER_VAULT: usize = 256;

backend/sync_server/src/errors.rs

@@ -1,15 +1,14 @@
 use std::fmt::Display;
 
-use aide::OperationOutput;
 use axum::{
     Json,
     http::StatusCode,
     response::{IntoResponse, Response},
 };
-use log::{error, info};
-use schemars::JsonSchema;
+use log::{debug, error};
 use serde::Serialize;
 use thiserror::Error;
+use ts_rs::TS;
 
 #[derive(Error, Debug)]
 pub enum SyncServerError {
@@ -45,8 +44,11 @@ impl SyncServerError {
     }
 }
 
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct SerializedError {
+    pub error_type: &'static str,
     pub message: String,
     pub causes: Vec<String>,
 }
@@ -90,41 +92,49 @@ impl From<&anyhow::Error> for SerializedError {
         }
 
         SerializedError {
+            error_type: error.downcast_ref::<SyncServerError>().map_or(
+                "UnknownError",
+                |e| match e {
+                    SyncServerError::InitError(_) => "InitError",
+                    SyncServerError::ClientError(_) => "ClientError",
+                    SyncServerError::ServerError(_) => "ServerError",
+                    SyncServerError::NotFound(_) => "NotFound",
+                    SyncServerError::Unauthenticated(_) => "Unauthenticated",
+                    SyncServerError::PermissionDeniedError(_) => "PermissionDeniedError",
+                },
+            ),
             message: error.to_string(),
             causes,
         }
     }
 }
 
-impl OperationOutput for SyncServerError {
-    type Inner = Self;
-}
-
-pub const fn init_error(error: anyhow::Error) -> SyncServerError {
+pub fn init_error(error: anyhow::Error) -> SyncServerError {
+    debug!("Initialization error: {error:?}");
     SyncServerError::InitError(error)
 }
 
 pub fn server_error(error: anyhow::Error) -> SyncServerError {
-    error!("Server error: {error:?}");
+    debug!("Server error: {error:?}");
     SyncServerError::ServerError(error)
 }
 
 pub fn client_error(error: anyhow::Error) -> SyncServerError {
-    info!("Client error: {error:?}");
+    debug!("Client error: {error:?}");
     SyncServerError::ClientError(error)
 }
 
 pub fn not_found_error(error: anyhow::Error) -> SyncServerError {
-    info!("Not found: {error:?}");
+    debug!("Not found: {error:?}");
     SyncServerError::NotFound(error)
 }
 
 pub fn unauthenticated_error(error: anyhow::Error) -> SyncServerError {
-    info!("Unauthenticated user: {error:?}");
+    debug!("Unauthenticated user: {error:?}");
     SyncServerError::Unauthenticated(error)
 }
 
 pub fn permission_denied_error(error: anyhow::Error) -> SyncServerError {
-    info!("Permission denied: {error:?}");
+    debug!("Permission denied: {error:?}");
     SyncServerError::PermissionDeniedError(error)
 }

backend/sync_server/src/server.rs

@@ -1,4 +1,4 @@
-mod auth;
+pub mod auth;
 mod create_document;
 mod delete_document;
 mod device_id_header;
@@ -6,35 +6,27 @@ mod fetch_document_version;
 mod fetch_document_version_content;
 mod fetch_latest_document_version;
 mod fetch_latest_documents;
+mod index;
 mod ping;
 mod requests;
 mod responses;
 mod update_document;
 mod websocket;
 
-use std::{ffi::OsString, sync::Arc, time::Duration};
+use std::{ffi::OsString, time::Duration};
 
-use aide::{
-    axum::{
-        ApiRouter,
-        routing::{delete, get, post, put},
-    },
-    openapi::{Info, OpenApi},
-    scalar::Scalar,
-    transform::TransformOpenApi,
-};
 use anyhow::{Context as _, Result, anyhow};
 use auth::auth_middleware;
 use axum::{
-    Extension, Json,
+    Router,
     extract::{DefaultBodyLimit, Request},
     http::{self, HeaderValue, Method},
     middleware,
     response::IntoResponse,
-    routing::IntoMakeService,
+    routing::{IntoMakeService, delete, get, post, put},
 };
 use device_id_header::DEVICE_ID_HEADER_NAME;
-use log::{error, info};
+use log::info;
 use tokio::signal;
 use tower_http::{
     LatencyUnit,
@@ -51,26 +43,21 @@ use tracing::{Level, info_span};
 use crate::{
     app_state::AppState,
     config::server_config::ServerConfig,
-    errors::{SerializedError, client_error, not_found_error},
+    errors::{client_error, not_found_error},
 };
 
 pub async fn create_server(config_path: Option<OsString>) -> Result<()> {
-    aide::r#gen::on_error(|err| error!("{err}"));
-    aide::r#gen::extract_schemas(true);
-
     let app_state = AppState::try_new(config_path)
         .await
         .context("Failed to initialise app state")?;
 
     let server_config = app_state.config.server.clone();
 
-    let mut api = create_open_api();
-    let app = ApiRouter::new()
+    let app = Router::new()
         .nest("/", get_authed_routes(app_state.clone()))
-        .api_route("/vaults/:vault_id/ping", get(ping::ping))
+        .route("/", get(index::index))
+        .route("/vaults/:vault_id/ping", get(ping::ping))
         .route("/vaults/:vault_id/ws", get(websocket::websocket_handler))
-        .route("/", Scalar::new("/api.json").axum_route())
-        .route("/api.json", axum::routing::get(serve_api))
         .layer(DefaultBodyLimit::disable())
         .layer(RequestBodyLimitLayer::new(
             app_state.config.server.max_body_size_mb * 1024 * 1024,
@@ -108,8 +95,6 @@ pub async fn create_server(config_path: Option<OsString>) -> Result<()> {
                 .on_failure(DefaultOnFailure::new().level(Level::ERROR)),
         )
         .with_state(app_state)
-        .finish_api_with(&mut api, add_api_docs_error_example)
-        .layer(Extension(Arc::new(api))) // https://github.com/tamasfe/aide/blob/507f4a8822bc0c13cbda0f589da1e0f4cbcdb812/examples/example-axum/src/main.rs#L39
         .fallback(handle_404)
         .fallback(handle_405)
         .into_make_service();
@@ -117,67 +102,33 @@ pub async fn create_server(config_path: Option<OsString>) -> Result<()> {
     start_server(app, &server_config).await
 }
 
-async fn serve_api(Extension(api): Extension<Arc<OpenApi>>) -> impl IntoResponse { Json(api) }
-
-fn create_open_api() -> OpenApi {
-    OpenApi {
-        info: Info {
-            title: "VaultLink sync server".to_owned(),
-            summary: Some(
-                "Simple API for syncing documents between concurrent clients.".to_owned(),
-            ),
-            description: Some(include_str!("../README.md").to_owned()),
-            version: env!("CARGO_PKG_VERSION").to_owned(),
-            ..Info::default()
-        },
-        ..OpenApi::default()
-    }
-}
-
-fn add_api_docs_error_example(api: TransformOpenApi<'_>) -> TransformOpenApi<'_> {
-    api.default_response_with::<Json<SerializedError>, _>(|res| {
-        res.example(SerializedError {
-            message: "An error has occurred".to_owned(),
-            causes: vec![],
-        })
-    })
-}
-
-fn get_authed_routes(app_state: AppState) -> ApiRouter<AppState> {
-    ApiRouter::new()
-        .api_route(
+fn get_authed_routes(app_state: AppState) -> Router<AppState> {
+    Router::new()
+        .route(
             "/vaults/:vault_id/documents",
             get(fetch_latest_documents::fetch_latest_documents),
         )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents",
-            post(create_document::create_document_multipart),
+            post(create_document::create_document),
         )
-        .api_route(
-            "/vaults/:vault_id/documents/json",
-            post(create_document::create_document_json),
-        )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents/:document_id",
             get(fetch_latest_document_version::fetch_latest_document_version),
         )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents/:document_id",
-            put(update_document::update_document_multipart),
+            put(update_document::update_document),
         )
-        .api_route(
-            "/vaults/:vault_id/documents/:document_id/json",
-            put(update_document::update_document_json),
-        )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents/:document_id/versions/:version_id",
             put(fetch_document_version::fetch_document_version),
         )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents/:document_id/versions/:version_id/content",
             put(fetch_document_version_content::fetch_document_version_content),
         )
-        .api_route(
+        .route(
             "/vaults/:vault_id/documents/:document_id",
             delete(delete_document::delete_document),
         )

backend/sync_server/src/server/assets/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>VaultLink</title>
+    </head>
+    <body>
+        <h1>VaultLink server</h1>
+    </body>
+</html>

backend/sync_server/src/server/auth.rs

@@ -47,19 +47,22 @@ pub fn auth(state: &AppState, token: &str, vault_id: &VaultId) -> Result<User, S
         .cloned()
         .ok_or_else(|| unauthenticated_error(anyhow::anyhow!("Invalid token")))?;
 
-    info!("User `{}` authenticated", user.name);
-
     if match user.vault_access {
         VaultAccess::AllowAccessToAll => true,
         VaultAccess::AllowList(AllowListedVaults { ref allowed }) => allowed.contains(vault_id),
     } {
         info!(
-            "User `{}` is authorised to access to vault `{}`",
-            user.name, vault_id
+            "User '{}' is authenticated and is authorised to access to vault '{vault_id}'",
+            user.name
         );
 
         Ok(user)
     } else {
+        info!(
+            "User '{}' is authenticated but is not authorised to access vault '{vault_id}'",
+            user.name
+        );
+
         Err(permission_denied_error(anyhow::anyhow!(
             "Permission denied for vault `{vault_id}`"
         )))

backend/sync_server/src/server/create_document.rs

@@ -1,34 +1,24 @@
-use aide_axum_typed_multipart::TypedMultipart;
 use anyhow::Context as _;
 use axum::{
-    Extension,
+    Extension, Json,
     extract::{Path, State},
 };
 use axum_extra::TypedHeader;
-use axum_jsonschema::Json;
-use schemars::JsonSchema;
+use axum_typed_multipart::TypedMultipart;
 use serde::Deserialize;
-use sync_lib::base64_to_bytes;
 
-use super::{
-    device_id_header::DeviceIdHeader,
-    requests::{CreateDocumentVersion, CreateDocumentVersionMultipart},
-};
+use super::{device_id_header::DeviceIdHeader, requests::CreateDocumentVersion};
 use crate::{
     app_state::{
         AppState,
-        broadcasts::VaultUpdate,
-        database::models::{
-            DeviceId, DocumentId, DocumentVersionWithoutContent, StoredDocumentVersion, VaultId,
-        },
+        database::models::{DocumentVersionWithoutContent, StoredDocumentVersion, VaultId},
     },
     config::user_config::User,
     errors::{SyncServerError, client_error, server_error},
     utils::{normalize::normalize, sanitize_path::sanitize_path},
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct CreateDocumentPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,
@@ -38,66 +28,12 @@ pub struct CreateDocumentPathParams {
 /// already. If a document with the same path exists, a new version is created
 /// with their content merged.
 #[axum::debug_handler]
-pub async fn create_document_multipart(
+pub async fn create_document(
     Path(CreateDocumentPathParams { vault_id }): Path<CreateDocumentPathParams>,
     Extension(user): Extension<User>,
-    TypedHeader(user_agent): TypedHeader<DeviceIdHeader>,
+    TypedHeader(device_id): TypedHeader<DeviceIdHeader>,
     State(state): State<AppState>,
-    TypedMultipart(axum_typed_multipart::TypedMultipart(request)): TypedMultipart<
-        CreateDocumentVersionMultipart,
-    >,
-) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
-    internal_create_document(
-        user,
-        user_agent,
-        state,
-        vault_id,
-        request.document_id,
-        request.relative_path,
-        request.device_id,
-        request.content.contents.to_vec(),
-    )
-    .await
-}
-
-/// Create a new document in case a document with the same doesn't exist
-/// already. If a document with the same path exists, a new version is created
-/// with their content merged.
-#[axum::debug_handler]
-pub async fn create_document_json(
-    Path(CreateDocumentPathParams { vault_id }): Path<CreateDocumentPathParams>,
-    Extension(user): Extension<User>,
-    TypedHeader(user_agent): TypedHeader<DeviceIdHeader>,
-    State(state): State<AppState>,
-    Json(request): Json<CreateDocumentVersion>,
-) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
-    let content_bytes = base64_to_bytes(&request.content_base64)
-        .context("Failed to decode base64 content in request")
-        .map_err(client_error)?;
-
-    internal_create_document(
-        user,
-        user_agent,
-        state,
-        vault_id,
-        request.document_id,
-        request.relative_path,
-        request.device_id,
-        content_bytes,
-    )
-    .await
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn internal_create_document(
-    user: User,
-    user_agent: DeviceIdHeader,
-    state: AppState,
-    vault_id: VaultId,
-    document_id: Option<DocumentId>,
-    relative_path: String,
-    device_id: Option<DeviceId>,
-    content: Vec<u8>,
+    TypedMultipart(request): TypedMultipart<CreateDocumentVersion>,
 ) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
     let mut transaction = state
         .database
@@ -105,7 +41,7 @@ async fn internal_create_document(
         .await
         .map_err(server_error)?;
 
-    let document_id = match document_id {
+    let document_id = match request.document_id {
         Some(document_id) => {
             let existing_version = state
                 .database
@@ -130,17 +66,17 @@ async fn internal_create_document(
         .await
         .map_err(server_error)?;
 
-    let sanitized_relative_path = sanitize_path(&relative_path);
+    let sanitized_relative_path = sanitize_path(&request.relative_path);
 
     let new_version = StoredDocumentVersion {
         vault_update_id: last_update_id + 1,
         document_id,
         relative_path: sanitized_relative_path,
-        content,
+        content: request.content.contents.to_vec(),
         updated_date: chrono::Utc::now(),
         is_deleted: false,
         user_id: user.name,
-        device_id: user_agent.0,
+        device_id: device_id.0,
     };
 
     state
@@ -155,16 +91,5 @@ async fn internal_create_document(
         .context("Failed to commit successful transaction")
         .map_err(server_error)?;
 
-    state
-        .broadcasts
-        .send(
-            vault_id,
-            VaultUpdate {
-                origin_device_id: device_id,
-                document: new_version.clone().into(),
-            },
-        )
-        .await;
-
     Ok(Json(new_version.into()))
 }

backend/sync_server/src/server/delete_document.rs

@@ -1,18 +1,15 @@
 use anyhow::Context as _;
 use axum::{
-    Extension,
+    Extension, Json,
     extract::{Path, State},
 };
 use axum_extra::TypedHeader;
-use axum_jsonschema::Json;
-use schemars::JsonSchema;
 use serde::Deserialize;
 
 use super::{device_id_header::DeviceIdHeader, requests::DeleteDocumentVersion};
 use crate::{
     app_state::{
         AppState,
-        broadcasts::VaultUpdate,
         database::models::{
             DocumentId, DocumentVersionWithoutContent, StoredDocumentVersion, VaultId,
         },
@@ -22,8 +19,7 @@ use crate::{
     utils::{normalize::normalize, sanitize_path::sanitize_path},
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct DeleteDocumentPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,
@@ -38,7 +34,7 @@ pub async fn delete_document(
         document_id,
     }): Path<DeleteDocumentPathParams>,
     Extension(user): Extension<User>,
-    TypedHeader(user_agent): TypedHeader<DeviceIdHeader>,
+    TypedHeader(device_id): TypedHeader<DeviceIdHeader>,
     State(state): State<AppState>,
     Json(request): Json<DeleteDocumentVersion>,
 ) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
@@ -69,7 +65,7 @@ pub async fn delete_document(
         updated_date: chrono::Utc::now(),
         is_deleted: true,
         user_id: user.name,
-        device_id: user_agent.0,
+        device_id: device_id.0,
     };
 
     state
@@ -84,16 +80,5 @@ pub async fn delete_document(
         .context("Failed to commit successful transaction")
         .map_err(server_error)?;
 
-    state
-        .broadcasts
-        .send(
-            vault_id,
-            VaultUpdate {
-                origin_device_id: request.device_id,
-                document: new_version.clone().into(),
-            },
-        )
-        .await;
-
     Ok(Json(new_version.into()))
 }

backend/sync_server/src/server/fetch_document_version.rs

@@ -1,7 +1,8 @@
 use anyhow::anyhow;
-use axum::extract::{Path, State};
-use axum_jsonschema::Json;
-use schemars::JsonSchema;
+use axum::{
+    Json,
+    extract::{Path, State},
+};
 use serde::Deserialize;
 
 use crate::{
@@ -13,8 +14,7 @@ use crate::{
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct FetchDocumentVersionPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,

backend/sync_server/src/server/fetch_document_version_content.rs

@@ -3,7 +3,6 @@ use axum::{
     body::Bytes,
     extract::{Path, State},
 };
-use schemars::JsonSchema;
 use serde::Deserialize;
 
 use crate::{
@@ -15,8 +14,7 @@ use crate::{
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct FetchDocumentVersionContentPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,

backend/sync_server/src/server/fetch_latest_document_version.rs

@@ -1,7 +1,8 @@
 use anyhow::anyhow;
-use axum::extract::{Path, State};
-use axum_jsonschema::Json;
-use schemars::JsonSchema;
+use axum::{
+    Json,
+    extract::{Path, State},
+};
 use serde::Deserialize;
 
 use crate::{
@@ -13,8 +14,7 @@ use crate::{
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct FetchLatestDocumentVersionPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,

backend/sync_server/src/server/fetch_latest_documents.rs

@@ -1,6 +1,7 @@
-use axum::extract::{Path, Query, State};
-use axum_jsonschema::Json;
-use schemars::JsonSchema;
+use axum::{
+    Json,
+    extract::{Path, Query, State},
+};
 use serde::Deserialize;
 
 use super::responses::FetchLatestDocumentsResponse;
@@ -13,15 +14,13 @@ use crate::{
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct FetchLatestDocumentsPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,
 }
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct QueryParams {
     since_update_id: Option<VaultUpdateId>,
 }

backend/sync_server/src/server/index.rs

@@ -0,0 +1,7 @@
+use axum::response::{Html, IntoResponse};
+
+pub async fn index() -> impl IntoResponse {
+    const HTML_CONTENT: &str = include_str!("./assets/index.html");
+    let html_content = HTML_CONTENT;
+    Html(html_content)
+}

backend/sync_server/src/server/ping.rs

@@ -6,7 +6,6 @@ use axum_extra::{
     TypedHeader,
     headers::{Authorization, authorization::Bearer},
 };
-use schemars::JsonSchema;
 use serde::Deserialize;
 
 use super::{auth::auth, responses::PingResponse};
@@ -16,8 +15,7 @@ use crate::{
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct PingPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,

backend/sync_server/src/server/requests.rs

@@ -1,13 +1,12 @@
-use aide_axum_typed_multipart::FieldData;
 use axum::body::Bytes;
-use axum_typed_multipart::TryFromMultipart;
-use schemars::JsonSchema;
+use axum_typed_multipart::{FieldData, TryFromMultipart};
 use serde::{self, Deserialize};
+use ts_rs::TS;
 
-use crate::app_state::database::models::{DeviceId, DocumentId, VaultUpdateId};
+use crate::app_state::database::models::{DocumentId, VaultUpdateId};
 
-#[derive(Debug, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
+#[derive(TS, Debug, TryFromMultipart)]
+#[ts(export)]
 pub struct CreateDocumentVersion {
     /// The client can decide the document id (if it wishes to) in order
     /// to help with syncing. If the client does not provide a document id,
@@ -15,41 +14,26 @@ pub struct CreateDocumentVersion {
     /// it must not already exist in the database.
     pub document_id: Option<DocumentId>,
     pub relative_path: String,
-    pub content_base64: String,
-    pub device_id: Option<DeviceId>,
-}
 
-#[derive(Debug, TryFromMultipart, JsonSchema)]
-pub struct CreateDocumentVersionMultipart {
-    pub document_id: Option<DocumentId>,
-    pub relative_path: String,
+    #[ts(as = "Vec<u8>")]
     #[form_data(limit = "unlimited")]
     pub content: FieldData<Bytes>,
-    pub device_id: Option<DeviceId>,
 }
 
-#[derive(Debug, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
+#[derive(TS, Debug, TryFromMultipart)]
+#[ts(export)]
 pub struct UpdateDocumentVersion {
     pub parent_version_id: VaultUpdateId,
     pub relative_path: String,
-    pub content_base64: String,
-    pub device_id: Option<DeviceId>,
-}
 
-#[derive(Debug, TryFromMultipart, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateDocumentVersionMultipart {
-    pub parent_version_id: VaultUpdateId,
-    pub relative_path: String,
+    #[ts(as = "Vec<u8>")]
     #[form_data(limit = "unlimited")]
     pub content: FieldData<Bytes>,
-    pub device_id: Option<DeviceId>,
 }
 
-#[derive(Debug, Deserialize, JsonSchema)]
+#[derive(TS, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct DeleteDocumentVersion {
     pub relative_path: String,
-    pub device_id: Option<DeviceId>,
 }

backend/sync_server/src/server/responses.rs

@@ -1,13 +1,14 @@
-use schemars::JsonSchema;
 use serde::{self, Serialize};
+use ts_rs::TS;
 
 use crate::app_state::database::models::{
     DocumentVersion, DocumentVersionWithoutContent, VaultUpdateId,
 };
 
 /// Response to a ping request.
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct PingResponse {
     /// Semantic version of the server.
     pub server_version: String,
@@ -18,8 +19,9 @@ pub struct PingResponse {
 }
 
 /// Response to a fetch latest documents request.
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct FetchLatestDocumentsResponse {
     pub latest_documents: Vec<DocumentVersionWithoutContent>,
 
@@ -28,8 +30,9 @@ pub struct FetchLatestDocumentsResponse {
 }
 
 /// Response to an update document request.
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(TS, Debug, Clone, Serialize)]
 #[serde(tag = "type")]
+#[ts(export)]
 pub enum DocumentUpdateResponse {
     /// Returned when the created/updated document's content is the same as was
     /// sent in the create/update request and thus the response doesn't contain

backend/sync_server/src/server/update_document.rs

@@ -1,34 +1,29 @@
-use aide_axum_typed_multipart::TypedMultipart;
 use anyhow::{Context as _, anyhow};
 use axum::{
-    Extension,
+    Extension, Json,
     extract::{Path, State},
 };
 use axum_extra::TypedHeader;
-use axum_jsonschema::Json;
+use axum_typed_multipart::TypedMultipart;
 use log::info;
-use schemars::JsonSchema;
 use serde::Deserialize;
-use sync_lib::{base64_to_bytes, is_file_type_mergable, merge};
+use sync_lib::{is_file_type_mergable, merge};
 
 use super::{
-    device_id_header::DeviceIdHeader,
-    requests::{UpdateDocumentVersion, UpdateDocumentVersionMultipart},
+    device_id_header::DeviceIdHeader, requests::UpdateDocumentVersion,
     responses::DocumentUpdateResponse,
 };
 use crate::{
     app_state::{
         AppState,
-        broadcasts::VaultUpdate,
-        database::models::{DeviceId, DocumentId, StoredDocumentVersion, VaultId, VaultUpdateId},
+        database::models::{DocumentId, StoredDocumentVersion, VaultId},
     },
     config::user_config::User,
-    errors::{SyncServerError, client_error, not_found_error, server_error},
+    errors::{SyncServerError, not_found_error, server_error},
     utils::{dedup_paths::dedup_paths, normalize::normalize, sanitize_path::sanitize_path},
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
+#[derive(Deserialize)]
 pub struct UpdateDocumentPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,
@@ -37,90 +32,34 @@ pub struct UpdateDocumentPathParams {
 }
 
 #[axum::debug_handler]
-pub async fn update_document_multipart(
+#[allow(clippy::too_many_lines)]
+pub async fn update_document(
     Path(UpdateDocumentPathParams {
         vault_id,
         document_id,
     }): Path<UpdateDocumentPathParams>,
     Extension(user): Extension<User>,
-    TypedHeader(user_agent): TypedHeader<DeviceIdHeader>,
+    TypedHeader(device_id): TypedHeader<DeviceIdHeader>,
     State(state): State<AppState>,
-    TypedMultipart(axum_typed_multipart::TypedMultipart(request)): TypedMultipart<
-        UpdateDocumentVersionMultipart,
-    >,
-) -> Result<Json<DocumentUpdateResponse>, SyncServerError> {
-    internal_update_document(
-        user,
-        user_agent,
-        state,
-        vault_id,
-        document_id,
-        request.parent_version_id,
-        request.relative_path,
-        request.device_id,
-        request.content.contents.to_vec(),
-    )
-    .await
-}
-
-#[axum::debug_handler]
-pub async fn update_document_json(
-    Path(UpdateDocumentPathParams {
-        vault_id,
-        document_id,
-    }): Path<UpdateDocumentPathParams>,
-    Extension(user): Extension<User>,
-    TypedHeader(user_agent): TypedHeader<DeviceIdHeader>,
-    State(state): State<AppState>,
-    Json(request): Json<UpdateDocumentVersion>,
-) -> Result<Json<DocumentUpdateResponse>, SyncServerError> {
-    let content_bytes = base64_to_bytes(&request.content_base64)
-        .context("Failed to decode base64 content in request")
-        .map_err(client_error)?;
-
-    internal_update_document(
-        user,
-        user_agent,
-        state,
-        vault_id,
-        document_id,
-        request.parent_version_id,
-        request.relative_path,
-        request.device_id,
-        content_bytes,
-    )
-    .await
-}
-
-#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
-async fn internal_update_document(
-    user: User,
-    user_agent: DeviceIdHeader,
-    state: AppState,
-    vault_id: VaultId,
-    document_id: DocumentId,
-    parent_version_id: VaultUpdateId,
-    relative_path: String,
-    device_id: Option<DeviceId>,
-    content: Vec<u8>,
+    TypedMultipart(request): TypedMultipart<UpdateDocumentVersion>,
 ) -> Result<Json<DocumentUpdateResponse>, SyncServerError> {
     // No need for a transaction as document versions are immutable
     let parent_document = state
         .database
-        .get_document_version(&vault_id, parent_version_id, None)
+        .get_document_version(&vault_id, request.parent_version_id, None)
         .await
         .map_err(server_error)?
         .map_or_else(
             || {
                 Err(not_found_error(anyhow!(
                     "Parent version with id `{}` not found",
-                    parent_version_id
+                    request.parent_version_id
                 )))
             },
             Ok,
         )?;
 
-    let sanitized_relative_path = sanitize_path(&relative_path);
+    let sanitized_relative_path = sanitize_path(&request.relative_path);
 
     let mut transaction = state
         .database
@@ -160,6 +99,8 @@ async fn internal_update_document(
         )));
     }
 
+    let content = request.content.contents.to_vec();
+
     // Return the latest version if the content and path are the same as the latest
     // version
     if content == latest_version.content && sanitized_relative_path == latest_version.relative_path
@@ -215,7 +156,7 @@ async fn internal_update_document(
         updated_date: chrono::Utc::now(),
         is_deleted: false,
         user_id: user.name,
-        device_id: user_agent.0,
+        device_id: device_id.0,
     };
 
     state
@@ -230,17 +171,6 @@ async fn internal_update_document(
         .context("Failed to commit successful transaction")
         .map_err(server_error)?;
 
-    state
-        .broadcasts
-        .send(
-            vault_id,
-            VaultUpdate {
-                origin_device_id: device_id,
-                document: new_version.clone().into(),
-            },
-        )
-        .await;
-
     Ok(Json(if is_different_from_request_content {
         DocumentUpdateResponse::MergingUpdate(new_version.into())
     } else {

backend/sync_server/src/server/websocket.rs

@@ -6,165 +6,176 @@ use axum::{
     },
     response::Response,
 };
-use futures::{
-    sink::SinkExt,
-    stream::{SplitSink, StreamExt},
-};
-use log::{error, info, warn};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use futures::stream::StreamExt;
+use log::{debug, info};
+use serde::Deserialize;
 
-use super::auth::auth;
 use crate::{
     app_state::{
         AppState,
-        database::models::{DeviceId, DocumentVersionWithoutContent, VaultId, VaultUpdateId},
+        database::models::VaultId,
+        websocket::{
+            models::{
+                CursorPositionFromServer, WebSocketClientMessage, WebSocketServerMessage,
+                WebSocketVaultUpdate,
+            },
+            utils::{
+                get_authenticated_handshake, get_unseen_documents, send_update_over_websocket,
+            },
+        },
     },
-    errors::{SyncServerError, server_error, unauthenticated_error},
+    errors::{SyncServerError, client_error, server_error},
     utils::normalize::normalize,
 };
 
-// This is required for aide to infer the path parameter types and names
-#[derive(Deserialize, JsonSchema)]
-pub struct WebsocketPathParams {
+#[derive(Deserialize)]
+pub struct WebSocketPathParams {
     #[serde(deserialize_with = "normalize")]
     vault_id: VaultId,
 }
 
 pub async fn websocket_handler(
     ws: WebSocketUpgrade,
-    Path(WebsocketPathParams { vault_id }): Path<WebsocketPathParams>,
+    Path(WebSocketPathParams { vault_id }): Path<WebSocketPathParams>,
     State(state): State<AppState>,
 ) -> Result<Response, SyncServerError> {
     Ok(ws.on_upgrade(move |socket| websocket_wrapped(state, socket, vault_id)))
 }
 
 async fn websocket_wrapped(state: AppState, stream: WebSocket, vault_id: VaultId) {
-    info!("Websocket connection opened on vault '{vault_id}'");
+    info!("WebSocket connection opened on vault '{vault_id}'");
 
     let result = websocket(state, stream, vault_id.clone()).await;
 
     if let Err(err) = result {
-        error!("Websocket connection error on vault '{vault_id}': {err}");
+        debug!("WebSocket connection error on vault '{vault_id}': {err}");
     }
-
-    warn!("Websocket connection closed on vault '{vault_id}'");
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct WebsocketHandshake {
-    pub token: String,
-    pub device_id: DeviceId,
-    pub last_seen_vault_update_id: Option<VaultUpdateId>,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct WebsocketVaultUpdate {
-    pub documents: Vec<DocumentVersionWithoutContent>,
-    pub is_initial_sync: bool,
 }
 
+#[allow(clippy::too_many_lines)]
 async fn websocket(
     state: AppState,
     stream: WebSocket,
     vault_id: VaultId,
 ) -> Result<(), SyncServerError> {
-    let (mut sender, mut receiver) = stream.split();
+    let (mut sender, mut websocket_receiver) = stream.split();
 
-    let handshake = if let Some(Ok(Message::Text(token))) = receiver.next().await {
-        let handshake: WebsocketHandshake = serde_json::from_str(&token)
-            .context("Failed to parse token")
-            .map_err(server_error)?;
-
-        auth(&state, handshake.token.trim(), &vault_id)?;
-
-        handshake
-    } else {
-        return Err(unauthenticated_error(anyhow::anyhow!(
-            "Failed to authenticate"
-        )));
-    };
-
-    let mut rx = state.broadcasts.get_receiver(vault_id.clone()).await;
-
-    let documents = if let Some(update_id) = handshake.last_seen_vault_update_id {
-        state
-            .database
-            .get_latest_documents_since(&vault_id, update_id, None)
+    let authed_handshake = get_authenticated_handshake(
+        &state,
+        &vault_id,
+        websocket_receiver
+            .next()
             .await
-            .map_err(server_error)
-    } else {
-        state
-            .database
-            .get_latest_documents(&vault_id, None)
-            .await
-            .map_err(server_error)
-    }?;
+            .transpose()
+            .unwrap_or_default(),
+    )?;
+
+    info!(
+        "WebSocket handshake successful for vault '{vault_id}' for '{}'",
+        authed_handshake.handshake.device_id
+    );
+
+    let mut broadcast_receiver = state.broadcasts.get_receiver(vault_id.clone()).await;
 
     send_update_over_websocket(
-        &WebsocketVaultUpdate {
-            documents,
+        &WebSocketServerMessage::VaultUpdate(WebSocketVaultUpdate {
+            documents: get_unseen_documents(
+                &state,
+                &vault_id,
+                authed_handshake.handshake.last_seen_vault_update_id,
+            )
+            .await?,
             is_initial_sync: true,
-        },
+        }),
         &mut sender,
     )
     .await?;
 
+    send_update_over_websocket(
+        &WebSocketServerMessage::CursorPositions(CursorPositionFromServer {
+            clients: state.cursors.get_cursors(&vault_id).await,
+        }),
+        &mut sender,
+    )
+    .await?;
+
+    let device_id = authed_handshake.handshake.device_id.clone();
     let mut send_task = tokio::spawn(async move {
-        while let Ok(update) = rx.recv().await {
-            if Some(&handshake.device_id) == update.origin_device_id.as_ref() {
+        while let Ok(update) = broadcast_receiver.recv().await {
+            if Some(&device_id) == update.origin_device_id.as_ref() {
                 continue;
             }
 
-            send_update_over_websocket(
-                &WebsocketVaultUpdate {
-                    documents: vec![update.document],
-                    is_initial_sync: false,
-                },
-                &mut sender,
-            )
-            .await?;
+            send_update_over_websocket(&update.message, &mut sender).await?;
         }
 
         Ok::<(), SyncServerError>(())
     });
 
-    let mut recv_task =
-        tokio::spawn(
-            async move { while let Some(Ok(Message::Text(_text))) = receiver.next().await {} },
-        );
+    let device_id = authed_handshake.handshake.device_id.clone();
+    let vault_id_clone = vault_id.clone();
+    let cursor_manager = state.cursors.clone();
+    let mut receive_task = tokio::spawn(async move {
+        while let Some(Ok(Message::Text(message))) = websocket_receiver.next().await {
+            let message: WebSocketClientMessage = serde_json::from_str(&message)
+                .context("Failed to parse WebSocket message from client")
+                .map_err(server_error)?;
+
+            match message {
+                WebSocketClientMessage::Handshake(_) => {
+                    return Err(client_error(anyhow::anyhow!(
+                        "Unexpected handshake message"
+                    )));
+                }
+                WebSocketClientMessage::CursorPositions(cursors) => {
+                    cursor_manager
+                        .update_cursors(
+                            vault_id_clone.clone(),
+                            authed_handshake.user.name.clone(),
+                            &device_id,
+                            cursors.document_to_cursors,
+                        )
+                        .await;
+                }
+            }
+        }
+
+        Ok::<(), SyncServerError>(())
+    });
 
     tokio::select! {
-        _ = &mut send_task => recv_task.abort(),
-        _ = &mut recv_task => send_task.abort(),
+        _ = &mut send_task => receive_task.abort(),
+        _ = &mut receive_task => send_task.abort(),
     };
 
-    send_task
-        .await
-        .context("Websocket send task failed")
-        .map_err(server_error)??;
+    let result: Result<(), SyncServerError> = (async {
+        send_task
+            .await
+            .context("WebSocket send task failed")
+            .map_err(client_error)
+            .and_then(|err| err)?;
 
-    recv_task
-        .await
-        .context("Websocket receive task failed")
-        .map_err(server_error)?;
+        receive_task
+            .await
+            .context("WebSocket receive task failed")
+            .map_err(client_error)
+            .and_then(|err| err)?;
 
-    Ok(())
-}
-
-async fn send_update_over_websocket(
-    update: &WebsocketVaultUpdate,
-    sender: &mut SplitSink<WebSocket, Message>,
-) -> Result<(), SyncServerError> {
-    let serialized_update = serde_json::to_string(update)
-        .context("Failed to serialize update")
-        .map_err(server_error)?;
-
-    sender
-        .send(Message::Text(serialized_update))
-        .await
-        .context("Failed to send message over websocket")
-        .map_err(server_error)
+        Ok(())
+    })
+    .await;
+
+    state
+        .cursors
+        .remove_cursors_of_device(&vault_id, &authed_handshake.handshake.device_id)
+        .await;
+
+    if result.is_err() {
+        info!(
+            "WebSocket disconnected on vault '{vault_id}' for '{}'",
+            authed_handshake.handshake.device_id
+        );
+    }
+
+    result
 }