Let yaak-models compile for wasm32-unknown-unknown (#556)

crates/yaak-models/src/lib.rs

@@ -1,15 +1,12 @@
 use crate::blob_manager::{BlobManager, migrate_blob_db};
-use crate::error::{Error, Result};
+use crate::error::Result;
 use crate::migrate::migrate_db;
 use crate::query_manager::QueryManager;
 use crate::util::ModelPayload;
 use log::info;
-use r2d2::Pool;
-use r2d2_sqlite::SqliteConnectionManager;
-use std::fs::create_dir_all;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::mpsc;
-use std::time::Duration;
+use yaak_database::SqlitePool;
 
 pub mod blob_manager;
 pub mod client_db;
@@ -22,17 +19,78 @@ pub mod query_manager;
 pub mod render;
 pub mod util;
 
-fn sqlite_file_manager(path: impl Into<PathBuf>) -> SqliteConnectionManager {
-    SqliteConnectionManager::file(path.into()).with_init(|conn| {
-        conn.pragma_update(None, "journal_mode", "WAL")?;
-        conn.pragma_update(None, "synchronous", "NORMAL")?;
-        conn.busy_timeout(Duration::from_millis(5000))
-    })
+/// Per-connection setup, applied by every pool on every connection it opens.
+fn init_connection(conn: &rusqlite::Connection) -> rusqlite::Result<()> {
+    conn.busy_timeout(std::time::Duration::from_millis(5000))
 }
 
-fn sqlite_memory_manager() -> SqliteConnectionManager {
-    SqliteConnectionManager::memory()
-        .with_init(|conn| conn.busy_timeout(Duration::from_millis(5000)))
+fn init_file_connection(conn: &rusqlite::Connection) -> rusqlite::Result<()> {
+    conn.pragma_update(None, "journal_mode", "WAL")?;
+    conn.pragma_update(None, "synchronous", "NORMAL")?;
+    init_connection(conn)
+}
+
+/// The two ways a pool comes to exist, one per target.
+///
+/// On the desktop and CLI, an r2d2 pool over a file. In a browser, a single
+/// connection over whatever VFS the host registered before calling in — the
+/// path is a name inside that VFS, not a place on disk. Everything downstream
+/// of `SqlitePool` is target-agnostic; this is the only fork.
+#[cfg(not(target_arch = "wasm32"))]
+mod open {
+    use super::*;
+    use crate::error::Error;
+    use r2d2::Pool;
+    use r2d2_sqlite::SqliteConnectionManager;
+    use std::path::PathBuf;
+    use std::time::Duration;
+
+    pub fn file_pool(path: impl Into<PathBuf>, max_size: u32, min_idle: u32) -> Result<SqlitePool> {
+        let path: PathBuf = path.into();
+        // Create parent directories if needed
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let manager = SqliteConnectionManager::file(path).with_init(|c| init_file_connection(c));
+        Pool::builder()
+            .max_size(max_size)
+            .min_idle(Some(min_idle))
+            .connection_timeout(Duration::from_secs(10))
+            .build(manager)
+            .map_err(|e| Error::Database(e.to_string()))
+    }
+
+    pub fn memory_pool() -> Result<SqlitePool> {
+        let manager = SqliteConnectionManager::memory().with_init(|c| init_connection(c));
+        // In-memory DB doesn't support multiple connections
+        Pool::builder().max_size(1).build(manager).map_err(|e| Error::Database(e.to_string()))
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+mod open {
+    use super::*;
+    use rusqlite::Connection;
+    use std::path::PathBuf;
+
+    pub fn file_pool(
+        path: impl Into<PathBuf>,
+        _max_size: u32,
+        _min_idle: u32,
+    ) -> Result<SqlitePool> {
+        // No WAL: the browser VFSs are single-connection and journal their own
+        // way; the pragma is accepted and ignored on some and rejected on
+        // others, so it is not applied at all here.
+        let conn = Connection::open(path.into())?;
+        init_connection(&conn)?;
+        Ok(SqlitePool::single(conn))
+    }
+
+    pub fn memory_pool() -> Result<SqlitePool> {
+        let conn = Connection::open_in_memory()?;
+        init_connection(&conn)?;
+        Ok(SqlitePool::single(conn))
+    }
 }
 
 /// Initialize the database managers for standalone (non-Tauri) usage.
@@ -46,40 +104,16 @@ pub fn init_standalone(
     let db_path = db_path.as_ref();
     let blob_path = blob_path.as_ref();
 
-    // Create parent directories if needed
-    if let Some(parent) = db_path.parent() {
-        create_dir_all(parent)?;
-    }
-    if let Some(parent) = blob_path.parent() {
-        create_dir_all(parent)?;
-    }
-
     // Main database pool. Sized for concurrent in-flight queries, not concurrent app
     // features — connections are held per-statement, so even heavy fan-out (e.g. many
     // gRPC streams) only needs a handful at once. Keep max_size modest: WAL connections
     // hold ~3 file descriptors each, and macOS GUI apps get a 256 fd soft limit.
     info!("Initializing app database {db_path:?}");
-    let manager = sqlite_file_manager(db_path);
-    let pool = Pool::builder()
-        .max_size(20)
-        .min_idle(Some(2))
-        .connection_timeout(Duration::from_secs(10))
-        .build(manager)
-        .map_err(|e| Error::Database(e.to_string()))?;
-
+    let pool = open::file_pool(db_path, 20, 2)?;
     migrate_db(&pool)?;
 
     info!("Initializing blobs database {blob_path:?}");
-
-    // Blob database pool
-    let blob_manager = sqlite_file_manager(blob_path);
-    let blob_pool = Pool::builder()
-        .max_size(10)
-        .min_idle(Some(1))
-        .connection_timeout(Duration::from_secs(10))
-        .build(blob_manager)
-        .map_err(|e| Error::Database(e.to_string()))?;
-
+    let blob_pool = open::file_pool(blob_path, 10, 1)?;
     migrate_blob_db(&blob_pool)?;
 
     let (tx, rx) = mpsc::channel();
@@ -92,22 +126,10 @@ pub fn init_standalone(
 /// Initialize the database managers with in-memory SQLite databases.
 /// Useful for testing and CI environments.
 pub fn init_in_memory() -> Result<(QueryManager, BlobManager, mpsc::Receiver<ModelPayload>)> {
-    // Main database pool
-    let manager = sqlite_memory_manager();
-    let pool = Pool::builder()
-        .max_size(1) // In-memory DB doesn't support multiple connections
-        .build(manager)
-        .map_err(|e| Error::Database(e.to_string()))?;
-
+    let pool = open::memory_pool()?;
     migrate_db(&pool)?;
 
-    // Blob database pool
-    let blob_manager = sqlite_memory_manager();
-    let blob_pool = Pool::builder()
-        .max_size(1)
-        .build(blob_manager)
-        .map_err(|e| Error::Database(e.to_string()))?;
-
+    let blob_pool = open::memory_pool()?;
     migrate_blob_db(&blob_pool)?;
 
     let (tx, rx) = mpsc::channel();