Add wipe_and_recreate method to SQLiteWasmDatabase

.gitignore

@@ -8,3 +8,5 @@ pkg/sqlite_web_bg.wasm.b64
 
 # macOS
 .DS_Store
+
+.claude

Cargo.toml

@@ -20,17 +20,23 @@ wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
 web-sys = { version = "0.3", features = [
     "Blob",
-    "BlobPropertyBag", 
+    "BlobPropertyBag",
     "Url",
     "Worker",
     "WorkerOptions",
     "WorkerType",
     "BroadcastChannel",
-    "MessageEvent", 
+    "MessageEvent",
     "DedicatedWorkerGlobalScope",
     "Navigator",
     "Window",
-    "Location"
+    "Location",
+    "StorageManager",
+    "FileSystemDirectoryHandle",
+    "FileSystemHandle",
+    "FileSystemRemoveOptions",
+    "FileSystemGetDirectoryOptions",
+    "DomException"
 ]}
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

packages/sqlite-web/src/db.rs

@@ -11,6 +11,7 @@ use web_sys::Worker;
 
 use crate::errors::SQLiteWasmDatabaseError;
 use crate::messages::WORKER_ERROR_TYPE_INITIALIZATION_PENDING;
+use crate::opfs::delete_opfs_sahpool_directory;
 use crate::params::normalize_params_js;
 use crate::ready::{InitializationState, ReadySignal};
 use crate::utils::describe_js_value;
@@ -19,7 +20,8 @@ use crate::worker_template::generate_self_contained_worker;
 
 #[wasm_bindgen]
 pub struct SQLiteWasmDatabase {
-    worker: Worker,
+    worker: Rc<RefCell<Worker>>,
+    db_name: String,
     pending_queries: Rc<RefCell<HashMap<u32, (js_sys::Function, js_sys::Function)>>>,
     next_request_id: Rc<RefCell<u32>>,
     ready_signal: ReadySignal,
@@ -63,7 +65,8 @@ impl SQLiteWasmDatabase {
         let next_request_id = Rc::new(RefCell::new(1u32));
 
         Ok(SQLiteWasmDatabase {
-            worker,
+            worker: Rc::new(RefCell::new(worker)),
+            db_name: db_name.to_string(),
             pending_queries,
             next_request_id,
             ready_signal,
@@ -112,7 +115,7 @@ impl SQLiteWasmDatabase {
         sql: &str,
         params: Option<Array>,
     ) -> Result<String, SQLiteWasmDatabaseError> {
-        let worker = &self.worker;
+        let worker = Rc::clone(&self.worker);
         let pending_queries = Rc::clone(&self.pending_queries);
         let sql = sql.to_string();
         let params_array = Self::normalize_params(params)?;
@@ -154,17 +157,19 @@ impl SQLiteWasmDatabase {
         }
 
         let rid_for_insert = request_id;
-        let promise =
-            js_sys::Promise::new(&mut |resolve, reject| match worker.post_message(&message) {
-                Ok(()) => {
-                    pending_queries
-                        .borrow_mut()
-                        .insert(rid_for_insert, (resolve, reject));
-                }
-                Err(err) => {
-                    let _ = reject.call1(&JsValue::NULL, &err);
-                }
-            });
+        let promise = js_sys::Promise::new(&mut |resolve, reject| match worker
+            .borrow()
+            .post_message(&message)
+        {
+            Ok(()) => {
+                pending_queries
+                    .borrow_mut()
+                    .insert(rid_for_insert, (resolve, reject));
+            }
+            Err(err) => {
+                let _ = reject.call1(&JsValue::NULL, &err);
+            }
+        });
 
         let result = match JsFuture::from(promise).await {
             Ok(value) => value,
@@ -177,6 +182,36 @@ impl SQLiteWasmDatabase {
         };
         Ok(result.as_string().unwrap_or_else(|| format!("{result:?}")))
     }
+
+    #[wasm_export(js_name = "wipeAndRecreate", unchecked_return_type = "void")]
+    pub async fn wipe_and_recreate(&self) -> Result<(), SQLiteWasmDatabaseError> {
+        self.worker.borrow().terminate();
+
+        for (_, (_, reject)) in self.pending_queries.borrow_mut().drain() {
+            let err = JsValue::from_str("Database wipe in progress");
+            let _ = reject.call1(&JsValue::NULL, &err);
+        }
+
+        self.ready_signal.reset();
+
+        let deletion_result = delete_opfs_sahpool_directory().await;
+
+        let worker_code = generate_self_contained_worker(&self.db_name);
+        let new_worker =
+            create_worker_from_code(&worker_code).map_err(SQLiteWasmDatabaseError::JsError)?;
+
+        install_onmessage_handler(
+            &new_worker,
+            Rc::clone(&self.pending_queries),
+            self.ready_signal.clone(),
+        );
+
+        *self.worker.borrow_mut() = new_worker;
+
+        self.wait_until_ready().await?;
+
+        deletion_result
+    }
 }
 
 fn is_initialization_pending_error(err: &JsValue) -> bool {
@@ -294,4 +329,77 @@ mod tests {
         let js_val = JsValue::from_str(WORKER_ERROR_TYPE_INITIALIZATION_PENDING);
         assert!(is_initialization_pending_error(&js_val));
     }
+
+    #[wasm_bindgen_test(async)]
+    async fn wipe_and_recreate_tests() {
+        let db = SQLiteWasmDatabase::new("test_wipe").await.unwrap();
+        db.wipe_and_recreate().await.unwrap();
+
+        db.query(
+            "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)",
+            None,
+        )
+        .await
+        .unwrap();
+        db.query("INSERT INTO users (name) VALUES ('Alice')", None)
+            .await
+            .unwrap();
+
+        let result = db
+            .query("SELECT COUNT(*) as count FROM users", None)
+            .await
+            .unwrap();
+        assert!(result.contains("\"count\": 1"));
+
+        db.wipe_and_recreate().await.unwrap();
+
+        let result = db.query("SELECT * FROM users", None).await;
+        assert!(result.is_err() || result.unwrap().contains("no such table"));
+
+        let create_result = db
+            .query(
+                "CREATE TABLE new_table (id INTEGER PRIMARY KEY, value TEXT)",
+                None,
+            )
+            .await;
+        assert!(create_result.is_ok());
+
+        let insert_result = db
+            .query("INSERT INTO new_table (value) VALUES ('test')", None)
+            .await;
+        assert!(insert_result.is_ok());
+
+        let select_result = db.query("SELECT * FROM new_table", None).await.unwrap();
+        assert!(select_result.contains("test"));
+
+        for i in 0..3 {
+            db.query(&format!("CREATE TABLE t{} (id INTEGER)", i), None)
+                .await
+                .unwrap();
+            db.wipe_and_recreate().await.unwrap();
+        }
+
+        let result = db
+            .query("SELECT name FROM sqlite_master WHERE type='table'", None)
+            .await
+            .unwrap();
+        assert!(!result.contains("t0"));
+        assert!(!result.contains("t1"));
+        assert!(!result.contains("t2"));
+
+        let arr = Array::new();
+        arr.push(&JsValue::from_f64(f64::NAN));
+        let res = db.query("SELECT ?", Some(arr)).await;
+        assert!(res.is_err(), "NaN should be rejected");
+
+        let arr = Array::new();
+        arr.push(&JsValue::from_f64(f64::INFINITY));
+        let res = db.query("SELECT ?", Some(arr)).await;
+        assert!(res.is_err(), "+Infinity should be rejected");
+
+        let arr = Array::new();
+        arr.push(&JsValue::from_f64(f64::NEG_INFINITY));
+        let res = db.query("SELECT ?", Some(arr)).await;
+        assert!(res.is_err(), "-Infinity should be rejected");
+    }
 }

packages/sqlite-web/src/errors.rs

@@ -12,6 +12,8 @@ pub enum SQLiteWasmDatabaseError {
     InitializationPending,
     #[error("Initialization failed: {0}")]
     InitializationFailed(String),
+    #[error("OPFS deletion failed: {0}")]
+    OpfsDeletionFailed(String),
 }
 
 impl From<JsValue> for SQLiteWasmDatabaseError {

packages/sqlite-web/src/lib.rs

@@ -1,6 +1,7 @@
 mod db;
 mod errors;
 mod messages;
+mod opfs;
 mod params;
 mod ready;
 mod utils;