feat: close dbs when about to exit

- This will close connections, truncate WAL files and
   drain the db cache

Author: pmorris-dev

Cargo.lock

@@ -19,11 +19,12 @@ serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 thiserror = "2.0.17"
 log = "0.4.28"
-futures-core = "0.3.31"
+futures = "0.3.31"
 time = "0.3.44"
-tokio = { version = "1.48.0", features = ["sync"] }
+tokio = { version = "1.48.0", features = ["sync", "time"] }
 indexmap = { version = "2.12.1", features = ["serde"] }
 base64 = "0.22.1"
+tracing = { version = "0.1.41", default-features = false, features = ["std", "release_max_level_off"] }
 
 # SQLx for types and queries (time feature enables datetime type decoding)
 sqlx = { version = "0.8.6", features = ["sqlite", "json", "time", "runtime-tokio"] }

Cargo.toml

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
+use std::sync::Arc;
 
-use tauri::{Manager, Runtime, plugin::Builder as PluginBuilder};
+use tauri::{Manager, RunEvent, Runtime, plugin::Builder as PluginBuilder};
 use tokio::sync::RwLock;
+use tracing::{debug, error, info, warn};
 
 mod commands;
 mod decode;
@@ -15,8 +17,8 @@ pub use wrapper::{DatabaseWrapper, WriteQueryResult};
 ///
 /// This struct maintains a thread-safe map of database paths to their corresponding
 /// connection wrappers.
-#[derive(Default)]
-pub struct DbInstances(pub RwLock<HashMap<String, DatabaseWrapper>>);
+#[derive(Clone, Default)]
+pub struct DbInstances(pub Arc<RwLock<HashMap<String, DatabaseWrapper>>>);
 
 /// Builder for the SQLite plugin.
 ///
@@ -57,10 +59,86 @@ impl Builder {
          ])
          .setup(|app, _api| {
             app.manage(DbInstances::default());
+            debug!("SQLite plugin initialized");
             // Future PR: Possibly handle migrations here
-            // Future PR: Cleanup on app exit
             Ok(())
          })
+         .on_event(|app, event| {
+            match event {
+               RunEvent::ExitRequested { api, code, .. } => {
+                  info!("App exit requested (code: {:?}) - closing databases before exit", code);
+
+                  // Prevent immediate exit so we can close connections and checkpoint WAL
+                  api.prevent_exit();
+
+                  let app_handle = app.clone();
+
+                  let handle = match tokio::runtime::Handle::try_current() {
+                     Ok(h) => h,
+                     Err(_) => {
+                        warn!("No tokio runtime available for database cleanup");
+                        app_handle.exit(code.unwrap_or(0));
+                        return;
+                     }
+                  };
+
+                  let instances = app.state::<DbInstances>().inner().clone();
+
+                  // Spawn a blocking thread to close databases
+                  // (block_in_place panics on current_thread runtime)
+                  let cleanup_result = std::thread::spawn(move || {
+                     handle.block_on(async {
+                        let mut guard = instances.0.write().await;
+                        let wrappers: Vec<DatabaseWrapper> =
+                           guard.drain().map(|(_, v)| v).collect();
+
+                        // Close databases in parallel with timeout
+                        let closes = wrappers.into_iter().map(|w| w.close());
+                        let results = tokio::time::timeout(
+                           std::time::Duration::from_secs(5),
+                           futures::future::join_all(closes),
+                        )
+                        .await;
+
+                        match results {
+                           Ok(outcomes) => {
+                              for result in outcomes {
+                                 if let Err(e) = result {
+                                    warn!("Error closing database: {:?}", e);
+                                 }
+                              }
+                           }
+                           Err(_) => warn!("Database cleanup timed out after 5 seconds"),
+                        }
+
+                        debug!("Database cleanup complete");
+                     })
+                  })
+                  .join();
+
+                  if let Err(e) = cleanup_result {
+                     error!("Database cleanup thread panicked: {:?}", e);
+                  }
+
+                  app_handle.exit(code.unwrap_or(0));
+               }
+               RunEvent::Exit => {
+                  // ExitRequested should have already closed all databases
+                  // This is just a safety check
+                  let instances = app.state::<DbInstances>();
+                  if let Ok(instances) = instances.0.try_read() {
+                     if !instances.is_empty() {
+                        warn!("Exit event fired with {} database(s) still open - cleanup may have been skipped", instances.len());
+                     } else {
+                        debug!("Exit event: all databases already closed");
+                     }
+                  }
+               }
+               _ => {
+                  // Other events don't require action
+               }
+            }
+         })
          .build()
    }
 }