feat: OPFS SAH errors

3 files changed, 126 insertions, 2 deletions

diff --git a/filamento/Cargo.toml b/filamento/Cargo.toml
index 7d7af0c..b89c577 100644
--- a/filamento/Cargo.toml
+++ b/filamento/Cargo.toml
@@ -52,6 +52,7 @@ tokio = { workspace = true, features = ["sync", "time", "rt", "fs", "io-std"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 tokio = { workspace = true, features = ["sync", "time", "rt"] }
+js-sys.workspace = true
 web-sys = { workspace = true, features = [
 	"FileSystemDirectoryHandle",
 	"FileSystemWritableFileStream",
diff --git a/filamento/src/db.rs b/filamento/src/db.rs
index 385382a..298d54a 100644
--- a/filamento/src/db.rs
+++ b/filamento/src/db.rs
@@ -88,12 +88,21 @@ impl Db {
         spawn_blocking(move || {
             spawn_local(async move {
                 debug!("installing opfs in spawn");
-                rusqlite::ffi::install_opfs_sahpool(
+                match rusqlite::ffi::install_opfs_sahpool(
                     Some(&rusqlite::ffi::OpfsSAHPoolCfg::default()),
                     false,
                 )
                 .await
-                .unwrap();
+                {
+                    Ok(_) => {}
+                    Err(e) => {
+                        use crate::error::OpfsSAHError;
+
+                        let error: OpfsSAHError = e.into();
+                        result_send.send(Err(error.into()));
+                        return;
+                    }
+                }
                 debug!("opfs installed");
                 let file_name = format!("file:{}?vfs=opfs-sahpool", file_name.as_ref());
                 let result = DbActor::new(file_name, receiver);
diff --git a/filamento/src/error.rs b/filamento/src/error.rs
index 721d532..fb7d778 100644
--- a/filamento/src/error.rs
+++ b/filamento/src/error.rs
@@ -293,6 +293,9 @@ pub enum IqProcessError {
 
 #[derive(Debug, Error, Clone)]
 pub enum DatabaseOpenError {
+    #[cfg(target_arch = "wasm32")]
+    #[error("opfs: {0}")]
+    OpfsSAH(#[from] OpfsSAHError),
     #[error("error: {0}")]
     Error(Arc<rusqlite::Error>),
     // #[error("migration: {0}")]
@@ -311,6 +314,117 @@ pub enum DatabaseOpenError {
 //     }
 // }
 
+#[cfg(target_arch = "wasm32")]
+impl From<rusqlite::ffi::OpfsSAHError> for OpfsSAHError {
+    fn from(e: rusqlite::ffi::OpfsSAHError) -> Self {
+        use wasm_bindgen::UnwrapThrowExt;
+        match e {
+            rusqlite::ffi::OpfsSAHError::Vfs(_register_vfs_error) => Self::VfsRegistration,
+            rusqlite::ffi::OpfsSAHError::ImportDb(_import_db_error) => Self::ImportDb,
+            rusqlite::ffi::OpfsSAHError::NotSuported => Self::NotSupported,
+            rusqlite::ffi::OpfsSAHError::GetDirHandle(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::GetDirHandle(message)
+            }
+            rusqlite::ffi::OpfsSAHError::GetFileHandle(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::GetFileHandle(message)
+            }
+            rusqlite::ffi::OpfsSAHError::CreateSyncAccessHandle(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::CreateSyncAccessHandle(message)
+            }
+            rusqlite::ffi::OpfsSAHError::IterHandle(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::IterHandle(message)
+            }
+            rusqlite::ffi::OpfsSAHError::GetPath(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::GetPath(message)
+            }
+            rusqlite::ffi::OpfsSAHError::RemoveEntity(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::RemoveEntity(message)
+            }
+            rusqlite::ffi::OpfsSAHError::GetSize(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::GetSize(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Read(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::Read(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Write(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::Write(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Flush(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::Flush(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Truncate(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::Truncate(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Reflect(js_value) => {
+                let error: js_sys::Error = js_value.into();
+                let message = error.message().as_string().unwrap_throw();
+                Self::Reflect(message)
+            }
+            rusqlite::ffi::OpfsSAHError::Generic(s) => Self::Generic(s),
+            rusqlite::ffi::OpfsSAHError::Custom(s) => Self::Generic(s),
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[derive(Debug, Error, Clone)]
+pub enum OpfsSAHError {
+    #[error("VFS registration")]
+    VfsRegistration,
+    #[error("import db error")]
+    ImportDb,
+    #[error("not supported")]
+    NotSupported,
+    #[error("get dir handle: {0}")]
+    GetDirHandle(String),
+    #[error("get file handle: {0}")]
+    GetFileHandle(String),
+    #[error("create sync access handle: {0}")]
+    CreateSyncAccessHandle(String),
+    #[error("iter handle: {0}")]
+    IterHandle(String),
+    #[error("get path: {0}")]
+    GetPath(String),
+    #[error("remove entity: {0}")]
+    RemoveEntity(String),
+    #[error("get size: {0}")]
+    GetSize(String),
+    #[error("read: {0}")]
+    Read(String),
+    #[error("write: {0}")]
+    Write(String),
+    #[error("flush: {0}")]
+    Flush(String),
+    #[error("truncate: {0}")]
+    Truncate(String),
+    #[error("reflect: {0}")]
+    Reflect(String),
+    #[error("generic: {0}")]
+    Generic(String),
+}
+
 impl From<std::io::Error> for DatabaseOpenError {
     fn from(e: std::io::Error) -> Self {
         Self::Io(Arc::new(e))