feat: Implement autosave functionality and room management

- Added autosave snapshot creation and updating in LocalStorage and ServerStorage.
- Introduced RoomRegistry interface for managing active rooms.
- Implemented room deletion with confirmation in the API.
- Updated room settings to use a 60-second autosave interval by default.
- Enhanced the SQLite document store to support room activity tracking and deletion.
- Added tests for autosave snapshot handling and room deletion.
- Modified WebSocket handlers to touch room activity on user interactions.

Author: isaaclins

excalidraw-app/src-tauri/src/commands.rs

@@ -1,23 +1,27 @@
-use crate::db::{Drawing, Snapshot, RoomSettings, DB};
+use crate::db::{Drawing, RoomSettings, Snapshot, DB};
 use std::time::{SystemTime, UNIX_EPOCH};
 
+const AUTOSAVE_CREATED_BY: &str = "__autosave__";
+const AUTOSAVE_DEFAULT_NAME: &str = "Latest autosave snapshot";
+const AUTOSAVE_DEFAULT_DESCRIPTION: &str = "Automatically saved by Excalidraw";
+
 #[tauri::command]
 pub fn save_drawing(name: String, data: String) -> Result<String, String> {
     let timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs() as i64;
-    
+
     let id = uuid::Uuid::new_v4().to_string();
-    
+
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     conn.execute(
         "INSERT INTO drawings (id, name, data, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, ?5)",
         rusqlite::params![&id, &name, &data, timestamp, timestamp],
     )
     .map_err(|e| e.to_string())?;
-    
+
     Ok(id)
 }
 
@@ -27,22 +31,22 @@ pub fn update_drawing(id: String, name: String, data: String) -> Result<(), Stri
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs() as i64;
-    
+
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     conn.execute(
         "UPDATE drawings SET name = ?1, data = ?2, updated_at = ?3 WHERE id = ?4",
         rusqlite::params![&name, &data, timestamp, &id],
     )
     .map_err(|e| e.to_string())?;
-    
+
     Ok(())
 }
 
 #[tauri::command]
 pub fn load_drawing(id: String) -> Result<Drawing, String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     let drawing = conn
         .query_row(
             "SELECT id, name, data, created_at, updated_at FROM drawings WHERE id = ?1",
@@ -58,18 +62,20 @@ pub fn load_drawing(id: String) -> Result<Drawing, String> {
             },
         )
         .map_err(|e| e.to_string())?;
-    
+
     Ok(drawing)
 }
 
 #[tauri::command]
 pub fn list_drawings() -> Result<Vec<Drawing>, String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     let mut stmt = conn
-        .prepare("SELECT id, name, data, created_at, updated_at FROM drawings ORDER BY updated_at DESC")
+        .prepare(
+            "SELECT id, name, data, created_at, updated_at FROM drawings ORDER BY updated_at DESC",
+        )
         .map_err(|e| e.to_string())?;
-    
+
     let drawings = stmt
         .query_map([], |row| {
             Ok(Drawing {
@@ -83,17 +89,17 @@ pub fn list_drawings() -> Result<Vec<Drawing>, String> {
         .map_err(|e| e.to_string())?
         .collect::<Result<Vec<_>, _>>()
         .map_err(|e| e.to_string())?;
-    
+
     Ok(drawings)
 }
 
 #[tauri::command]
 pub fn delete_drawing(id: String) -> Result<(), String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     conn.execute("DELETE FROM drawings WHERE id = ?1", rusqlite::params![&id])
         .map_err(|e| e.to_string())?;
-    
+
     Ok(())
 }
 
@@ -112,14 +118,14 @@ pub fn save_snapshot(
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs() as i64;
-    
+
     let id = uuid::Uuid::new_v4().to_string();
-    
+
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     // Get room settings to check max snapshots
     let settings = get_room_settings_internal(&conn, &room_id)?;
-    
+
     // Count existing snapshots
     let count: i32 = conn
         .query_row(
@@ -128,7 +134,7 @@ pub fn save_snapshot(
             |row| row.get(0),
         )
         .map_err(|e| e.to_string())?;
-    
+
     // If at limit, delete oldest snapshot
     if count >= settings.max_snapshots {
         conn.execute(
@@ -137,25 +143,25 @@ pub fn save_snapshot(
         )
         .map_err(|e| e.to_string())?;
     }
-    
+
     // Insert new snapshot
     conn.execute(
         "INSERT INTO snapshots (id, room_id, name, description, thumbnail, created_by, created_at, data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
         rusqlite::params![&id, &room_id, &name, &description, &thumbnail, &created_by, timestamp, &data],
     )
     .map_err(|e| e.to_string())?;
-    
+
     Ok(id)
 }
 
 #[tauri::command]
 pub fn list_snapshots(room_id: String) -> Result<Vec<Snapshot>, String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     let mut stmt = conn
         .prepare("SELECT id, room_id, name, description, thumbnail, created_by, created_at, '' as data FROM snapshots WHERE room_id = ?1 ORDER BY created_at DESC")
         .map_err(|e| e.to_string())?;
-    
+
     let snapshots = stmt
         .query_map(rusqlite::params![&room_id], |row| {
             Ok(Snapshot {
@@ -172,14 +178,14 @@ pub fn list_snapshots(room_id: String) -> Result<Vec<Snapshot>, String> {
         .map_err(|e| e.to_string())?
         .collect::<Result<Vec<_>, _>>()
         .map_err(|e| e.to_string())?;
-    
+
     Ok(snapshots)
 }
 
 #[tauri::command]
 pub fn load_snapshot(id: String) -> Result<Snapshot, String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     let snapshot = conn
         .query_row(
             "SELECT id, room_id, name, description, thumbnail, created_by, created_at, data FROM snapshots WHERE id = ?1",
@@ -198,36 +204,111 @@ pub fn load_snapshot(id: String) -> Result<Snapshot, String> {
             },
         )
         .map_err(|e| e.to_string())?;
-    
+
     Ok(snapshot)
 }
 
 #[tauri::command]
 pub fn delete_snapshot(id: String) -> Result<(), String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
-    conn.execute("DELETE FROM snapshots WHERE id = ?1", rusqlite::params![&id])
-        .map_err(|e| e.to_string())?;
-    
+
+    conn.execute(
+        "DELETE FROM snapshots WHERE id = ?1",
+        rusqlite::params![&id],
+    )
+    .map_err(|e| e.to_string())?;
+
     Ok(())
 }
 
 #[tauri::command]
-pub fn update_snapshot_metadata(id: String, name: String, description: String) -> Result<(), String> {
+pub fn update_snapshot_metadata(
+    id: String,
+    name: String,
+    description: String,
+) -> Result<(), String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     conn.execute(
         "UPDATE snapshots SET name = ?1, description = ?2 WHERE id = ?3",
         rusqlite::params![&name, &description, &id],
     )
     .map_err(|e| e.to_string())?;
-    
+
     Ok(())
 }
 
+#[tauri::command]
+pub fn save_autosave_snapshot(
+    room_id: String,
+    name: Option<String>,
+    description: Option<String>,
+    thumbnail: Option<String>,
+    data: String,
+) -> Result<String, String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs() as i64;
+
+    let final_name = name.unwrap_or_else(|| AUTOSAVE_DEFAULT_NAME.to_string());
+    let final_description = description.unwrap_or_else(|| AUTOSAVE_DEFAULT_DESCRIPTION.to_string());
+    let final_thumbnail = thumbnail.unwrap_or_default();
+
+    let existing_id_result: Result<String, rusqlite::Error> = conn.query_row(
+        "SELECT id FROM snapshots WHERE room_id = ?1 AND created_by = ?2 LIMIT 1",
+        rusqlite::params![&room_id, AUTOSAVE_CREATED_BY],
+        |row| row.get(0),
+    );
+
+    match existing_id_result {
+        Ok(existing_id) => {
+            conn.execute(
+                "UPDATE snapshots SET name = ?1, description = ?2, thumbnail = ?3, data = ?4, created_at = ?5 WHERE id = ?6",
+                rusqlite::params![
+                    &final_name,
+                    &final_description,
+                    &final_thumbnail,
+                    &data,
+                    timestamp,
+                    &existing_id,
+                ],
+            )
+            .map_err(|e| e.to_string())?;
+
+            Ok(existing_id)
+        }
+        Err(rusqlite::Error::QueryReturnedNoRows) => {
+            let id = uuid::Uuid::new_v4().to_string();
+            conn.execute(
+                "INSERT INTO snapshots (id, room_id, name, description, thumbnail, created_by, created_at, data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
+                rusqlite::params![
+                    &id,
+                    &room_id,
+                    &final_name,
+                    &final_description,
+                    &final_thumbnail,
+                    AUTOSAVE_CREATED_BY,
+                    timestamp,
+                    &data,
+                ],
+            )
+            .map_err(|e| e.to_string())?;
+
+            Ok(id)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
 // Room settings commands
 
-fn get_room_settings_internal(conn: &rusqlite::Connection, room_id: &str) -> Result<RoomSettings, String> {
+fn get_room_settings_internal(
+    conn: &rusqlite::Connection,
+    room_id: &str,
+) -> Result<RoomSettings, String> {
     conn.query_row(
         "SELECT room_id, max_snapshots, auto_save_interval FROM room_settings WHERE room_id = ?1",
         rusqlite::params![room_id],
@@ -244,7 +325,7 @@ fn get_room_settings_internal(conn: &rusqlite::Connection, room_id: &str) -> Res
         Ok(RoomSettings {
             room_id: room_id.to_string(),
             max_snapshots: 10,
-            auto_save_interval: 300,
+            auto_save_interval: 60,
         })
     })
 }
@@ -256,15 +337,19 @@ pub fn get_room_settings(room_id: String) -> Result<RoomSettings, String> {
 }
 
 #[tauri::command]
-pub fn update_room_settings(room_id: String, max_snapshots: i32, auto_save_interval: i32) -> Result<(), String> {
+pub fn update_room_settings(
+    room_id: String,
+    max_snapshots: i32,
+    auto_save_interval: i32,
+) -> Result<(), String> {
     let conn = DB.lock().map_err(|e| e.to_string())?;
-    
+
     conn.execute(
         "INSERT INTO room_settings (room_id, max_snapshots, auto_save_interval) VALUES (?1, ?2, ?3) 
          ON CONFLICT(room_id) DO UPDATE SET max_snapshots = ?2, auto_save_interval = ?3",
         rusqlite::params![&room_id, max_snapshots, auto_save_interval],
     )
     .map_err(|e| e.to_string())?;
-    
+
     Ok(())
 }

excalidraw-app/src-tauri/src/db.rs

@@ -1,8 +1,8 @@
+use once_cell::sync::Lazy;
 use rusqlite::{Connection, Result};
 use serde::{Deserialize, Serialize};
-use std::sync::Mutex;
-use once_cell::sync::Lazy;
 use std::path::PathBuf;
+use std::sync::Mutex;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Drawing {
@@ -43,10 +43,10 @@ fn get_db_path() -> PathBuf {
     let home = std::env::var("HOME")
         .or_else(|_| std::env::var("USERPROFILE"))
         .unwrap_or_else(|_| ".".to_string());
-    
+
     let app_dir = PathBuf::from(home).join(".excalidraw");
     std::fs::create_dir_all(&app_dir).ok();
-    
+
     app_dir.join("drawings.db")
 }
 
@@ -61,7 +61,7 @@ fn init_db(conn: &Connection) -> Result<()> {
         )",
         [],
     )?;
-    
+
     conn.execute(
         "CREATE TABLE IF NOT EXISTS snapshots (
             id TEXT PRIMARY KEY,
@@ -75,15 +75,15 @@ fn init_db(conn: &Connection) -> Result<()> {
         )",
         [],
     )?;
-    
+
     conn.execute(
         "CREATE TABLE IF NOT EXISTS room_settings (
             room_id TEXT PRIMARY KEY,
             max_snapshots INTEGER DEFAULT 10,
-            auto_save_interval INTEGER DEFAULT 300
+            auto_save_interval INTEGER DEFAULT 60
         )",
         [],
     )?;
-    
+
     Ok(())
 }