1#[cfg(target_arch = "wasm32")]
2use std::rc::Rc;
3#[cfg(target_arch = "wasm32")]
4use wasm_bindgen::prelude::*;
5
6#[cfg(all(
11 not(target_arch = "wasm32"),
12 any(
13 feature = "bundled-sqlite",
14 feature = "encryption",
15 feature = "encryption-commoncrypto",
16 feature = "encryption-ios"
17 )
18))]
19pub extern crate rusqlite;
20
21#[cfg(feature = "console_error_panic_hook")]
23pub use console_error_panic_hook::set_once as set_panic_hook;
24
25#[cfg(feature = "wee_alloc")]
26#[global_allocator]
27static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
28
29#[cfg(all(target_arch = "wasm32", feature = "console_log"))]
31#[wasm_bindgen(start)]
32pub fn init_logger() {
33 #[cfg(debug_assertions)]
36 let log_level = log::Level::Debug;
37 #[cfg(not(debug_assertions))]
38 let log_level = log::Level::Info;
39
40 console_log::init_with_level(log_level).expect("Failed to initialize console_log");
41
42 log::info!("AbsurderSQL logging initialized at level: {:?}", log_level);
43}
44
45#[cfg(target_arch = "wasm32")]
48use crate::utils::normalize_db_name;
49
50mod cleanup;
52#[cfg(target_arch = "wasm32")]
53pub mod connection_pool;
54#[cfg(not(target_arch = "wasm32"))]
55pub mod database;
56pub mod storage;
57pub mod types;
58pub mod vfs;
59#[cfg(not(target_arch = "wasm32"))]
60pub use database::PreparedStatement;
61pub mod utils;
62
63#[cfg(feature = "telemetry")]
64pub mod telemetry;
65
66#[cfg(not(target_arch = "wasm32"))]
68pub use database::SqliteIndexedDB;
69
70#[cfg(target_arch = "wasm32")]
72thread_local! {
73 static DB_OPEN_IN_PROGRESS: std::cell::RefCell<std::collections::HashSet<String>> =
74 std::cell::RefCell::new(std::collections::HashSet::new());
75}
76
77#[cfg(not(target_arch = "wasm32"))]
79pub type Database = SqliteIndexedDB;
80
81pub use types::DatabaseConfig;
82pub use types::{ColumnValue, DatabaseError, QueryResult, Row, TransactionOptions};
83
84pub use vfs::indexeddb_vfs::IndexedDBVFS;
86
87#[cfg(target_arch = "wasm32")]
89macro_rules! with_storage_async {
90 ($storage:expr, $operation:expr, |$s:ident| $body:expr) => {{
91 let $s = &*$storage;
93 Some($body.await)
94 }};
95}
96
97#[cfg(target_arch = "wasm32")]
99#[wasm_bindgen]
100pub struct Database {
101 connection_state: Rc<crate::connection_pool::ConnectionState>,
102 #[allow(dead_code)]
103 name: String,
104 on_data_change_callback: Option<js_sys::Function>,
105 allow_non_leader_writes: bool,
106 optimistic_updates_manager:
107 std::cell::RefCell<crate::storage::optimistic_updates::OptimisticUpdatesManager>,
108 coordination_metrics_manager:
109 std::cell::RefCell<crate::storage::coordination_metrics::CoordinationMetricsManager>,
110 #[cfg(feature = "telemetry")]
111 metrics: Option<crate::telemetry::Metrics>,
112 #[cfg(feature = "telemetry")]
113 span_recorder: Option<crate::telemetry::SpanRecorder>,
114 #[cfg(feature = "telemetry")]
115 span_context: Option<crate::telemetry::SpanContext>,
116 max_export_size_bytes: Option<u64>,
117}
118
119#[cfg(target_arch = "wasm32")]
120impl Database {
121 fn db(&self) -> *mut sqlite_wasm_rs::sqlite3 {
124 let db_ptr = self.connection_state.db.get();
125 if db_ptr.is_null() {
126 panic!("Database connection is null for {}", self.name);
127 }
128 db_ptr
129 }
130
131 fn is_write_operation(sql: &str) -> bool {
133 let upper = sql.trim().to_uppercase();
134 upper.starts_with("INSERT")
135 || upper.starts_with("UPDATE")
136 || upper.starts_with("DELETE")
137 || upper.starts_with("REPLACE")
138 }
139
140 #[cfg(feature = "telemetry")]
144 pub fn metrics(&self) -> Option<&crate::telemetry::Metrics> {
145 self.metrics.as_ref()
146 }
147
148 async fn check_write_permission(&mut self, sql: &str) -> Result<(), DatabaseError> {
150 if !Self::is_write_operation(sql) {
151 return Ok(());
153 }
154
155 if self.allow_non_leader_writes {
157 log::info!("WRITE_ALLOWED: Non-leader writes enabled for {}", self.name);
158 return Ok(());
159 }
160
161 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
163
164 let db_name = &self.name;
165 let storage_rc = get_storage_with_fallback(db_name);
166
167 if let Some(storage) = storage_rc {
168 let is_leader = with_storage_async!(storage, "check_write_permission", |s| s
169 .is_leader())
170 .ok_or_else(|| {
171 DatabaseError::new("BORROW_CONFLICT", "Failed to check leader status")
172 })?;
173
174 if !is_leader {
175 log::error!("WRITE_DENIED: Instance is not leader for {}", db_name);
176 return Err(DatabaseError::new(
177 "WRITE_PERMISSION_DENIED",
178 "Only the leader tab can write to this database. Use db.isLeader() to check status or call db.allowNonLeaderWrites(true) for single-tab mode.",
179 ));
180 }
181
182 log::info!("WRITE_ALLOWED: Instance is leader for {}", db_name);
183 Ok(())
184 } else {
185 log::info!(
187 "WRITE_ALLOWED: No storage found for {} (single-instance mode)",
188 db_name
189 );
190 Ok(())
191 }
192 }
193
194 fn default_wasm_config(name: String) -> DatabaseConfig {
195 DatabaseConfig {
196 name,
197 version: Some(1),
198 cache_size: Some(10_000),
199 page_size: Some(4096),
200 auto_vacuum: Some(true),
201 journal_mode: Some("WAL".to_string()),
202 max_export_size_bytes: Some(2 * 1024 * 1024 * 1024),
203 }
204 }
205
206 async fn new_with_storage_backend(
207 config: DatabaseConfig,
208 backend: crate::storage::StorageBackend,
209 ) -> Result<Self, DatabaseError> {
210 let normalized_name = normalize_db_name(&config.name);
211 crate::vfs::indexeddb_vfs::ensure_storage_registered_with_backend(
212 &normalized_name,
213 backend,
214 )
215 .await?;
216 Self::new(config).await
217 }
218
219 pub async fn new(config: DatabaseConfig) -> Result<Self, DatabaseError> {
220 use std::ffi::{CStr, CString};
221
222 log::info!("Database::new called for {}", config.name);
223
224 let normalized_name = normalize_db_name(&config.name);
227
228 let vfs_name = format!("vfs_{}", normalized_name.trim_end_matches(".db"));
230 let vfs_name_cstr = CString::new(vfs_name.as_str())
231 .map_err(|_| DatabaseError::new("INVALID_VFS_NAME", "Invalid VFS name"))?;
232 let vfs_exists = unsafe {
233 let existing_vfs = sqlite_wasm_rs::sqlite3_vfs_find(vfs_name_cstr.as_ptr());
234 !existing_vfs.is_null()
235 };
236
237 if !vfs_exists {
238 log::debug!("Creating IndexedDBVFS for: {}", normalized_name);
240 let vfs = crate::vfs::IndexedDBVFS::new(&normalized_name).await?;
241 log::debug!("Registering VFS as '{}'", vfs_name);
242 vfs.register(&vfs_name)?;
243 log::info!("VFS registered successfully");
244 } else {
245 log::info!("VFS '{}' already registered, reusing existing", vfs_name);
246 let _vfs = crate::vfs::IndexedDBVFS::new(&normalized_name).await?;
249 log::info!("BlockStorage ensured for {}", normalized_name);
250 }
251
252 #[cfg(target_arch = "wasm32")]
255 {
256 const MAX_OPEN_WAIT_MS: u32 = 1000; const OPEN_POLL_MS: u32 = 10;
258 let max_open_attempts = MAX_OPEN_WAIT_MS / OPEN_POLL_MS;
259
260 for attempt in 0..max_open_attempts {
261 let can_open = DB_OPEN_IN_PROGRESS.with(|opens| {
262 let mut set = opens.borrow_mut();
263 if set.contains(&config.name) {
264 false } else {
266 set.insert(config.name.clone());
267 true }
269 });
270
271 if can_open {
272 web_sys::console::log_1(
273 &format!("[DB] {} - ACQUIRED sqlite open lock", config.name).into(),
274 );
275 break;
276 } else {
277 web_sys::console::log_1(
278 &format!(
279 "[DB] {} - Waiting for sqlite open (attempt {})",
280 config.name, attempt
281 )
282 .into(),
283 );
284 use wasm_bindgen_futures::JsFuture;
285 let promise = js_sys::Promise::new(&mut |resolve, _| {
286 web_sys::window()
287 .unwrap()
288 .set_timeout_with_callback_and_timeout_and_arguments_0(
289 &resolve,
290 OPEN_POLL_MS as i32,
291 )
292 .unwrap();
293 });
294 JsFuture::from(promise).await.ok();
295 continue;
296 }
297 }
298 }
299
300 let (connection_state, db) = {
302 let vfs_name_str = vfs_name.clone(); let filename_copy = normalized_name.clone(); let pool_key = normalized_name.trim_end_matches(".db").to_string(); let state = crate::connection_pool::get_or_create_connection(&pool_key, || {
306 let mut db = std::ptr::null_mut();
307 let db_name = CString::new(normalized_name.clone())
308 .map_err(|_| "Invalid database name".to_string())?;
309 let vfs_cstr = CString::new(vfs_name_str.as_str())
310 .map_err(|_| "Invalid VFS name".to_string())?;
311
312 log::info!(
313 "Opening database: {} with VFS: {}",
314 filename_copy,
315 vfs_name_str
316 );
317
318 #[cfg(target_arch = "wasm32")]
319 web_sys::console::log_1(&format!("[OPEN] About to call sqlite3_open_v2...").into());
320
321 let ret = unsafe {
322 sqlite_wasm_rs::sqlite3_open_v2(
323 db_name.as_ptr(),
324 &mut db as *mut _,
325 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
326 vfs_cstr.as_ptr(),
327 )
328 };
329
330 #[cfg(target_arch = "wasm32")]
331 web_sys::console::log_1(
332 &format!("[OPEN] sqlite3_open_v2 returned: {}", ret).into(),
333 );
334
335 log::info!(
336 "sqlite3_open_v2 returned: {} for database: {}",
337 ret,
338 filename_copy
339 );
340
341 if ret != sqlite_wasm_rs::SQLITE_OK {
342 let err_msg = unsafe {
343 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
344 if !msg_ptr.is_null() {
345 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
346 } else {
347 "Unknown error".to_string()
348 }
349 };
350
351 #[cfg(target_arch = "wasm32")]
352 web_sys::console::log_1(
353 &format!(
354 "[OPEN] ERROR - sqlite3_open_v2 FAILED: ret={}, err={}",
355 ret, err_msg
356 )
357 .into(),
358 );
359
360 return Err(format!(
361 "Failed to open database with IndexedDB VFS: {}",
362 err_msg
363 ));
364 }
365
366 log::info!("Database opened successfully with IndexedDB VFS");
367 Ok(db)
368 })
369 .map_err(|e| DatabaseError::new("CONNECTION_POOL_ERROR", &e))?;
370 let db_ptr = state.db.get();
371 (state, db_ptr)
372 };
373
374 let exec_sql = |db: *mut sqlite_wasm_rs::sqlite3, sql: &str| -> Result<(), DatabaseError> {
376 let c_sql = CString::new(sql)
377 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL statement"))?;
378
379 let ret = unsafe {
380 sqlite_wasm_rs::sqlite3_exec(
381 db,
382 c_sql.as_ptr(),
383 None,
384 std::ptr::null_mut(),
385 std::ptr::null_mut(),
386 )
387 };
388
389 if ret != sqlite_wasm_rs::SQLITE_OK {
390 let err_msg = unsafe {
391 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
392 if !msg_ptr.is_null() {
393 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
394 } else {
395 "Unknown error".to_string()
396 }
397 };
398 log::warn!("Failed to execute SQL '{}': {}", sql, err_msg);
399 return Err(DatabaseError::new(
400 "SQLITE_ERROR",
401 &format!("Failed to execute: {}", err_msg),
402 ));
403 }
404 Ok(())
405 };
406
407 log::debug!("Setting busy_timeout to 10000ms for concurrent access handling");
411 exec_sql(db, "PRAGMA busy_timeout = 10000")?;
412
413 if let Some(page_size) = config.page_size {
415 log::debug!("Setting page_size to {}", page_size);
416 exec_sql(db, &format!("PRAGMA page_size = {}", page_size))?;
417 }
418
419 if let Some(cache_size) = config.cache_size {
421 log::debug!("Setting cache_size to {}", cache_size);
422 exec_sql(db, &format!("PRAGMA cache_size = {}", cache_size))?;
423 }
424
425 if let Some(ref journal_mode) = config.journal_mode {
428 log::debug!("Setting journal_mode to {}", journal_mode);
429
430 let pragma_sql = format!("PRAGMA journal_mode = {}", journal_mode);
431 let c_sql = CString::new(pragma_sql.as_str())
432 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL statement"))?;
433
434 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
435 let ret = unsafe {
436 sqlite_wasm_rs::sqlite3_prepare_v2(
437 db,
438 c_sql.as_ptr(),
439 -1,
440 &mut stmt as *mut _,
441 std::ptr::null_mut(),
442 )
443 };
444
445 if ret == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
446 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
447 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
448 let result_ptr = unsafe { sqlite_wasm_rs::sqlite3_column_text(stmt, 0) };
449 if !result_ptr.is_null() {
450 let result_mode = unsafe {
451 std::ffi::CStr::from_ptr(result_ptr as *const i8)
452 .to_string_lossy()
453 .to_uppercase()
454 };
455
456 if result_mode != journal_mode.to_uppercase() {
457 log::warn!(
458 "journal_mode {} requested but SQLite set {}",
459 journal_mode,
460 result_mode
461 );
462 } else {
463 log::info!("journal_mode successfully set to {}", result_mode);
464 }
465 }
466 }
467 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
468 } else {
469 log::warn!("Failed to prepare journal_mode PRAGMA");
470 }
471 }
472
473 if let Some(auto_vacuum) = config.auto_vacuum {
475 let vacuum_mode = if auto_vacuum { 1 } else { 0 }; log::debug!("Setting auto_vacuum to {}", vacuum_mode);
477 exec_sql(db, &format!("PRAGMA auto_vacuum = {}", vacuum_mode))?;
478 }
479
480 log::info!("Database configuration applied successfully");
481
482 #[cfg(feature = "telemetry")]
484 let metrics = crate::telemetry::Metrics::new().map_err(|e| {
485 DatabaseError::new(
486 "METRICS_ERROR",
487 &format!("Failed to initialize metrics: {}", e),
488 )
489 })?;
490
491 let database = Database {
492 connection_state,
493 name: normalized_name.clone(), on_data_change_callback: None,
495 allow_non_leader_writes: false,
496 optimistic_updates_manager: std::cell::RefCell::new(
497 crate::storage::optimistic_updates::OptimisticUpdatesManager::new(),
498 ),
499 coordination_metrics_manager: std::cell::RefCell::new(
500 crate::storage::coordination_metrics::CoordinationMetricsManager::new(),
501 ),
502 #[cfg(feature = "telemetry")]
503 metrics: Some(metrics),
504 #[cfg(feature = "telemetry")]
505 span_recorder: None,
506 #[cfg(feature = "telemetry")]
507 span_context: Some(crate::telemetry::SpanContext::new()),
508 max_export_size_bytes: config.max_export_size_bytes,
509 };
510
511 #[cfg(target_arch = "wasm32")]
514 {
515 DB_OPEN_IN_PROGRESS.with(|opens| {
516 opens.borrow_mut().remove(&config.name);
517 });
518 web_sys::console::log_1(
519 &format!("[DB] {} - RELEASED sqlite open lock", config.name).into(),
520 );
521 }
522
523 Ok(database)
524 }
525
526 pub async fn open_with_vfs(filename: &str, vfs_name: &str) -> Result<Self, DatabaseError> {
528 use std::ffi::CString;
529
530 log::info!("Opening database {} with VFS {}", filename, vfs_name);
531
532 let normalized_name = normalize_db_name(filename);
534 let pool_key = normalized_name.trim_end_matches(".db").to_string();
535
536 let connection_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
538 let mut db: *mut sqlite_wasm_rs::sqlite3 = std::ptr::null_mut();
539 let db_name = CString::new(normalized_name.clone())
540 .map_err(|_| "Invalid database name".to_string())?;
541 let vfs_cstr = CString::new(vfs_name).map_err(|_| "Invalid VFS name".to_string())?;
542
543 let ret = unsafe {
544 sqlite_wasm_rs::sqlite3_open_v2(
545 db_name.as_ptr(),
546 &mut db as *mut _,
547 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
548 vfs_cstr.as_ptr(),
549 )
550 };
551
552 if ret != sqlite_wasm_rs::SQLITE_OK {
553 let err_msg = if !db.is_null() {
554 unsafe {
555 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
556 if !msg_ptr.is_null() {
557 std::ffi::CStr::from_ptr(msg_ptr)
558 .to_string_lossy()
559 .into_owned()
560 } else {
561 "Unknown error".to_string()
562 }
563 }
564 } else {
565 "Failed to open database".to_string()
566 };
567 return Err(format!("SQLITE_ERROR: {}", err_msg));
568 }
569
570 Ok(db)
571 })
572 .map_err(|e| DatabaseError::new("OPEN_ERROR", &e))?;
573
574 log::info!(
575 "Successfully opened database {} with VFS {}",
576 normalized_name,
577 vfs_name
578 );
579
580 #[cfg(feature = "telemetry")]
582 let metrics = crate::telemetry::Metrics::new().map_err(|e| {
583 DatabaseError::new(
584 "METRICS_ERROR",
585 &format!("Failed to initialize metrics: {}", e),
586 )
587 })?;
588
589 Ok(Database {
590 connection_state,
591 name: normalized_name, on_data_change_callback: None,
593 allow_non_leader_writes: false,
594 optimistic_updates_manager: std::cell::RefCell::new(
595 crate::storage::optimistic_updates::OptimisticUpdatesManager::new(),
596 ),
597 coordination_metrics_manager: std::cell::RefCell::new(
598 crate::storage::coordination_metrics::CoordinationMetricsManager::new(),
599 ),
600 #[cfg(feature = "telemetry")]
601 metrics: Some(metrics),
602 #[cfg(feature = "telemetry")]
603 span_recorder: None,
604 #[cfg(feature = "telemetry")]
605 span_context: Some(crate::telemetry::SpanContext::new()),
606 max_export_size_bytes: Some(2 * 1024 * 1024 * 1024), })
608 }
609
610 pub async fn execute_internal(&mut self, sql: &str) -> Result<QueryResult, DatabaseError> {
611 use std::ffi::{CStr, CString};
612 let start_time = js_sys::Date::now();
613
614 #[cfg(feature = "telemetry")]
616 let span = if self.span_recorder.is_some() {
617 let query_type = sql
618 .trim()
619 .split_whitespace()
620 .next()
621 .unwrap_or("UNKNOWN")
622 .to_uppercase();
623 let mut builder = crate::telemetry::SpanBuilder::new("execute_query".to_string())
624 .with_attribute("query_type", query_type.clone())
625 .with_attribute("sql", sql.to_string());
626
627 if let Some(ref context) = self.span_context {
629 builder = builder.with_baggage_from_context(context);
630 }
631
632 let span = builder.build();
633
634 if let Some(ref context) = self.span_context {
636 context.enter_span(span.span_id.clone());
637 }
638
639 Some(span)
640 } else {
641 None
642 };
643
644 #[cfg(feature = "telemetry")]
646 #[cfg(feature = "telemetry")]
647 if let Some(metrics) = &self.metrics {
648 metrics.queries_total().inc();
649 }
650
651 if self.db().is_null() {
653 return Err(DatabaseError::new(
654 "NULL_CONNECTION",
655 "Database connection is null",
656 ));
657 }
658
659 let sql_cstr = CString::new(sql)
660 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL string"))?;
661
662 if sql.trim().to_uppercase().starts_with("SELECT") {
663 let mut stmt = std::ptr::null_mut();
664 let ret = unsafe {
665 sqlite_wasm_rs::sqlite3_prepare_v2(
666 self.db(),
667 sql_cstr.as_ptr(),
668 -1,
669 &mut stmt,
670 std::ptr::null_mut(),
671 )
672 };
673
674 if ret != sqlite_wasm_rs::SQLITE_OK {
675 let err_msg = unsafe {
677 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
678 if !msg_ptr.is_null() {
679 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
680 } else {
681 format!("Unknown error (code: {})", ret)
682 }
683 };
684
685 #[cfg(feature = "telemetry")]
687 #[cfg(feature = "telemetry")]
688 if let Some(metrics) = &self.metrics {
689 metrics.errors_total().inc();
690 }
691
692 #[cfg(feature = "telemetry")]
694 if let Some(mut s) = span {
695 s.status = crate::telemetry::SpanStatus::Error(format!(
696 "Failed to prepare: {}",
697 err_msg
698 ));
699 s.end_time_ms = Some(js_sys::Date::now());
700 if let Some(recorder) = &self.span_recorder {
701 recorder.record_span(s);
702 }
703
704 if let Some(ref context) = self.span_context {
706 context.exit_span();
707 }
708 }
709
710 return Err(DatabaseError::new(
711 "SQLITE_ERROR",
712 &format!("Failed to prepare statement: {}", err_msg),
713 )
714 .with_sql(sql));
715 }
716
717 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
718 let mut columns = Vec::new();
719 let mut rows = Vec::new();
720
721 for i in 0..column_count {
723 let col_name = unsafe {
724 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
725 if name_ptr.is_null() {
726 format!("col_{}", i)
727 } else {
728 std::ffi::CStr::from_ptr(name_ptr)
729 .to_string_lossy()
730 .into_owned()
731 }
732 };
733 columns.push(col_name);
734 }
735
736 loop {
738 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
739 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
740 let mut values = Vec::new();
741 for i in 0..column_count {
742 let value = unsafe {
743 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
744 match col_type {
745 sqlite_wasm_rs::SQLITE_NULL => ColumnValue::Null,
746 sqlite_wasm_rs::SQLITE_INTEGER => {
747 let val = sqlite_wasm_rs::sqlite3_column_int64(stmt, i);
748 ColumnValue::Integer(val)
749 }
750 sqlite_wasm_rs::SQLITE_FLOAT => {
751 let val = sqlite_wasm_rs::sqlite3_column_double(stmt, i);
752 ColumnValue::Real(val)
753 }
754 sqlite_wasm_rs::SQLITE_TEXT => {
755 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
756 if text_ptr.is_null() {
757 ColumnValue::Null
758 } else {
759 let text = std::ffi::CStr::from_ptr(text_ptr as *const i8)
760 .to_string_lossy()
761 .into_owned();
762 ColumnValue::Text(text)
763 }
764 }
765 sqlite_wasm_rs::SQLITE_BLOB => {
766 let blob_ptr = sqlite_wasm_rs::sqlite3_column_blob(stmt, i);
767 let blob_size = sqlite_wasm_rs::sqlite3_column_bytes(stmt, i);
768 if blob_ptr.is_null() || blob_size == 0 {
769 ColumnValue::Blob(vec![])
770 } else {
771 let blob_slice = std::slice::from_raw_parts(
772 blob_ptr as *const u8,
773 blob_size as usize,
774 );
775 ColumnValue::Blob(blob_slice.to_vec())
776 }
777 }
778 _ => ColumnValue::Null,
779 }
780 };
781 values.push(value);
782 }
783 rows.push(Row { values });
784 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
785 break;
786 } else {
787 let err_msg = unsafe {
789 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
790 if !err_ptr.is_null() {
791 std::ffi::CStr::from_ptr(err_ptr)
792 .to_string_lossy()
793 .to_string()
794 } else {
795 "Unknown SQLite error".to_string()
796 }
797 };
798 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
799 #[cfg(feature = "telemetry")]
801 if let Some(metrics) = &self.metrics {
802 metrics.errors_total().inc();
803 }
804 return Err(DatabaseError::new(
805 "SQLITE_ERROR",
806 &format!("Error executing SELECT statement: {}", err_msg),
807 )
808 .with_sql(sql));
809 }
810 }
811
812 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
813 let execution_time_ms = js_sys::Date::now() - start_time;
814
815 #[cfg(feature = "telemetry")]
817 if let Some(metrics) = &self.metrics {
818 metrics.query_duration().observe(execution_time_ms);
819 }
820
821 Ok(QueryResult {
822 columns,
823 rows,
824 affected_rows: 0,
825 last_insert_id: None,
826 execution_time_ms,
827 })
828 } else {
829 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
831 let ret = unsafe {
832 sqlite_wasm_rs::sqlite3_prepare_v2(
833 self.db(),
834 sql_cstr.as_ptr(),
835 -1,
836 &mut stmt,
837 std::ptr::null_mut(),
838 )
839 };
840
841 if ret != sqlite_wasm_rs::SQLITE_OK {
842 let err_msg = unsafe {
844 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
845 if !msg_ptr.is_null() {
846 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
847 } else {
848 format!("Unknown error (code: {})", ret)
849 }
850 };
851
852 #[cfg(feature = "telemetry")]
854 if let Some(metrics) = &self.metrics {
855 metrics.errors_total().inc();
856 }
857 return Err(DatabaseError::new(
858 "SQLITE_ERROR",
859 &format!("Failed to prepare statement: {}", err_msg),
860 )
861 .with_sql(sql));
862 }
863
864 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
866 let mut columns = Vec::new();
867 let mut rows = Vec::new();
868
869 if column_count > 0 {
870 for i in 0..column_count {
872 let col_name = unsafe {
873 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
874 if name_ptr.is_null() {
875 format!("column_{}", i)
876 } else {
877 std::ffi::CStr::from_ptr(name_ptr)
878 .to_string_lossy()
879 .into_owned()
880 }
881 };
882 columns.push(col_name);
883 }
884
885 loop {
887 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
888 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
889 let mut values = Vec::new();
890 for i in 0..column_count {
891 let value = unsafe {
892 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
893 match col_type {
894 sqlite_wasm_rs::SQLITE_TEXT => {
895 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
896 if text_ptr.is_null() {
897 ColumnValue::Null
898 } else {
899 let text =
900 std::ffi::CStr::from_ptr(text_ptr as *const i8)
901 .to_string_lossy()
902 .into_owned();
903 ColumnValue::Text(text)
904 }
905 }
906 sqlite_wasm_rs::SQLITE_INTEGER => ColumnValue::Integer(
907 sqlite_wasm_rs::sqlite3_column_int64(stmt, i),
908 ),
909 _ => ColumnValue::Null,
910 }
911 };
912 values.push(value);
913 }
914 rows.push(Row { values });
915 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
916 break;
917 } else {
918 let err_msg = unsafe {
920 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
921 if !err_ptr.is_null() {
922 std::ffi::CStr::from_ptr(err_ptr)
923 .to_string_lossy()
924 .to_string()
925 } else {
926 "Unknown SQLite error".to_string()
927 }
928 };
929 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
930 #[cfg(feature = "telemetry")]
932 if let Some(metrics) = &self.metrics {
933 metrics.errors_total().inc();
934 }
935 return Err(DatabaseError::new(
936 "SQLITE_ERROR",
937 &format!("Failed to execute statement: {}", err_msg),
938 )
939 .with_sql(sql));
940 }
941 }
942 } else {
943 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
945 if step_ret != sqlite_wasm_rs::SQLITE_DONE {
946 let err_msg = unsafe {
948 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
949 if !err_ptr.is_null() {
950 std::ffi::CStr::from_ptr(err_ptr)
951 .to_string_lossy()
952 .to_string()
953 } else {
954 "Unknown SQLite error".to_string()
955 }
956 };
957 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
958 #[cfg(feature = "telemetry")]
960 if let Some(metrics) = &self.metrics {
961 metrics.errors_total().inc();
962 }
963 return Err(DatabaseError::new(
964 "SQLITE_ERROR",
965 &format!("Failed to execute statement: {}", err_msg),
966 )
967 .with_sql(sql));
968 }
969 }
970
971 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
973
974 let affected_rows = unsafe { sqlite_wasm_rs::sqlite3_changes(self.db()) } as u32;
975 let last_insert_id = if sql.trim().to_uppercase().starts_with("INSERT") {
976 Some(unsafe { sqlite_wasm_rs::sqlite3_last_insert_rowid(self.db()) })
977 } else {
978 None
979 };
980
981 let execution_time_ms = js_sys::Date::now() - start_time;
982
983 #[cfg(feature = "telemetry")]
985 if let Some(metrics) = &self.metrics {
986 metrics.query_duration().observe(execution_time_ms);
987 }
988
989 #[cfg(feature = "telemetry")]
991 if let Some(mut s) = span {
992 s.status = crate::telemetry::SpanStatus::Ok;
993 s.end_time_ms = Some(js_sys::Date::now());
994 s.attributes
995 .insert("duration_ms".to_string(), execution_time_ms.to_string());
996 s.attributes
997 .insert("affected_rows".to_string(), affected_rows.to_string());
998 s.attributes
999 .insert("row_count".to_string(), rows.len().to_string());
1000 if let Some(recorder) = &self.span_recorder {
1001 recorder.record_span(s);
1002 }
1003
1004 if let Some(ref context) = self.span_context {
1006 context.exit_span();
1007 }
1008 }
1009
1010 Ok(QueryResult {
1011 columns,
1012 rows,
1013 affected_rows,
1014 last_insert_id,
1015 execution_time_ms,
1016 })
1017 }
1018 }
1019
1020 pub async fn execute_with_params_internal(
1021 &mut self,
1022 sql: &str,
1023 params: &[ColumnValue],
1024 ) -> Result<QueryResult, DatabaseError> {
1025 use std::ffi::{CStr, CString};
1026 let start_time = js_sys::Date::now();
1027
1028 #[cfg(feature = "telemetry")]
1030 let span = if self.span_recorder.is_some() {
1031 let query_type = sql
1032 .trim()
1033 .split_whitespace()
1034 .next()
1035 .unwrap_or("UNKNOWN")
1036 .to_uppercase();
1037 let span = crate::telemetry::SpanBuilder::new("execute_query".to_string())
1038 .with_attribute("query_type", query_type.clone())
1039 .with_attribute("sql", sql.to_string())
1040 .build();
1041 Some(span)
1042 } else {
1043 None
1044 };
1045
1046 #[cfg(feature = "telemetry")]
1048 self.ensure_metrics_propagated();
1049
1050 #[cfg(feature = "telemetry")]
1052 if let Some(metrics) = &self.metrics {
1053 metrics.queries_total().inc();
1054 }
1055
1056 let sql_cstr = CString::new(sql)
1057 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL string"))?;
1058
1059 let mut stmt = std::ptr::null_mut();
1060 let ret = unsafe {
1061 sqlite_wasm_rs::sqlite3_prepare_v2(
1062 self.db(),
1063 sql_cstr.as_ptr(),
1064 -1,
1065 &mut stmt,
1066 std::ptr::null_mut(),
1067 )
1068 };
1069
1070 if ret != sqlite_wasm_rs::SQLITE_OK {
1071 let err_msg = unsafe {
1073 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1074 if !msg_ptr.is_null() {
1075 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
1076 } else {
1077 format!("Unknown error (code: {})", ret)
1078 }
1079 };
1080
1081 #[cfg(feature = "telemetry")]
1083 if let Some(metrics) = &self.metrics {
1084 metrics.errors_total().inc();
1085 }
1086
1087 #[cfg(feature = "telemetry")]
1089 if let Some(mut s) = span {
1090 s.status =
1091 crate::telemetry::SpanStatus::Error(format!("Failed to prepare: {}", err_msg));
1092 s.end_time_ms = Some(js_sys::Date::now());
1093 if let Some(recorder) = &self.span_recorder {
1094 recorder.record_span(s);
1095 }
1096 }
1097
1098 return Err(DatabaseError::new(
1099 "SQLITE_ERROR",
1100 &format!("Failed to prepare statement: {}", err_msg),
1101 )
1102 .with_sql(sql));
1103 }
1104
1105 let mut text_cstrings = Vec::new(); for (i, param) in params.iter().enumerate() {
1108 let param_index = (i + 1) as i32;
1109 let bind_ret = unsafe {
1110 match param {
1111 ColumnValue::Null => sqlite_wasm_rs::sqlite3_bind_null(stmt, param_index),
1112 ColumnValue::Integer(val) => {
1113 sqlite_wasm_rs::sqlite3_bind_int64(stmt, param_index, *val)
1114 }
1115 ColumnValue::Real(val) => {
1116 sqlite_wasm_rs::sqlite3_bind_double(stmt, param_index, *val)
1117 }
1118 ColumnValue::Text(val) => {
1119 let sanitized = val.replace('\0', "");
1121 let text_cstr = CString::new(sanitized.as_str())
1123 .expect("CString::new should not fail after null byte removal");
1124 let result = sqlite_wasm_rs::sqlite3_bind_text(
1125 stmt,
1126 param_index,
1127 text_cstr.as_ptr(),
1128 sanitized.len() as i32,
1129 sqlite_wasm_rs::SQLITE_TRANSIENT(),
1130 );
1131 text_cstrings.push(text_cstr); result
1133 }
1134 ColumnValue::Blob(val) => sqlite_wasm_rs::sqlite3_bind_blob(
1135 stmt,
1136 param_index,
1137 val.as_ptr() as *const _,
1138 val.len() as i32,
1139 sqlite_wasm_rs::SQLITE_TRANSIENT(),
1140 ),
1141 _ => sqlite_wasm_rs::sqlite3_bind_null(stmt, param_index),
1142 }
1143 };
1144
1145 if bind_ret != sqlite_wasm_rs::SQLITE_OK {
1146 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1147 #[cfg(feature = "telemetry")]
1149 if let Some(metrics) = &self.metrics {
1150 metrics.errors_total().inc();
1151 }
1152 return Err(
1153 DatabaseError::new("SQLITE_ERROR", "Failed to bind parameter").with_sql(sql),
1154 );
1155 }
1156 }
1157
1158 if sql.trim().to_uppercase().starts_with("SELECT") {
1159 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
1160 let mut columns = Vec::new();
1161 let mut rows = Vec::new();
1162
1163 for i in 0..column_count {
1165 let col_name = unsafe {
1166 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
1167 if name_ptr.is_null() {
1168 format!("col_{}", i)
1169 } else {
1170 std::ffi::CStr::from_ptr(name_ptr)
1171 .to_string_lossy()
1172 .into_owned()
1173 }
1174 };
1175 columns.push(col_name);
1176 }
1177
1178 loop {
1180 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
1181 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
1182 let mut values = Vec::new();
1183 for i in 0..column_count {
1184 let value = unsafe {
1185 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
1186 match col_type {
1187 sqlite_wasm_rs::SQLITE_NULL => ColumnValue::Null,
1188 sqlite_wasm_rs::SQLITE_INTEGER => {
1189 let val = sqlite_wasm_rs::sqlite3_column_int64(stmt, i);
1190 ColumnValue::Integer(val)
1191 }
1192 sqlite_wasm_rs::SQLITE_FLOAT => {
1193 let val = sqlite_wasm_rs::sqlite3_column_double(stmt, i);
1194 ColumnValue::Real(val)
1195 }
1196 sqlite_wasm_rs::SQLITE_TEXT => {
1197 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
1198 if text_ptr.is_null() {
1199 ColumnValue::Null
1200 } else {
1201 let text = std::ffi::CStr::from_ptr(text_ptr as *const i8)
1202 .to_string_lossy()
1203 .into_owned();
1204 ColumnValue::Text(text)
1205 }
1206 }
1207 sqlite_wasm_rs::SQLITE_BLOB => {
1208 let blob_ptr = sqlite_wasm_rs::sqlite3_column_blob(stmt, i);
1209 let blob_size = sqlite_wasm_rs::sqlite3_column_bytes(stmt, i);
1210 if blob_ptr.is_null() || blob_size == 0 {
1211 ColumnValue::Blob(vec![])
1212 } else {
1213 let blob_slice = std::slice::from_raw_parts(
1214 blob_ptr as *const u8,
1215 blob_size as usize,
1216 );
1217 ColumnValue::Blob(blob_slice.to_vec())
1218 }
1219 }
1220 _ => ColumnValue::Null,
1221 }
1222 };
1223 values.push(value);
1224 }
1225 rows.push(Row { values });
1226 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
1227 break;
1228 } else {
1229 let err_msg = unsafe {
1231 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1232 if !err_ptr.is_null() {
1233 std::ffi::CStr::from_ptr(err_ptr)
1234 .to_string_lossy()
1235 .to_string()
1236 } else {
1237 "Unknown SQLite error".to_string()
1238 }
1239 };
1240 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1241 #[cfg(feature = "telemetry")]
1243 if let Some(metrics) = &self.metrics {
1244 metrics.errors_total().inc();
1245 }
1246 return Err(DatabaseError::new(
1247 "SQLITE_ERROR",
1248 &format!("Error executing SELECT statement: {}", err_msg),
1249 )
1250 .with_sql(sql));
1251 }
1252 }
1253
1254 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1255
1256 let execution_time_ms = js_sys::Date::now() - start_time;
1257
1258 #[cfg(feature = "telemetry")]
1260 if let Some(metrics) = &self.metrics {
1261 metrics.query_duration().observe(execution_time_ms);
1262 }
1263
1264 #[cfg(feature = "telemetry")]
1266 if let Some(mut s) = span {
1267 s.status = crate::telemetry::SpanStatus::Ok;
1268 s.end_time_ms = Some(js_sys::Date::now());
1269 s.attributes
1270 .insert("duration_ms".to_string(), execution_time_ms.to_string());
1271 s.attributes
1272 .insert("row_count".to_string(), rows.len().to_string());
1273 if let Some(recorder) = &self.span_recorder {
1274 recorder.record_span(s);
1275 }
1276 }
1277
1278 Ok(QueryResult {
1279 columns,
1280 rows,
1281 affected_rows: 0,
1282 last_insert_id: None,
1283 execution_time_ms,
1284 })
1285 } else {
1286 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
1288 #[cfg(feature = "telemetry")]
1290 if let Some(metrics) = &self.metrics {
1291 metrics.errors_total().inc();
1292 }
1293 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1294
1295 if step_ret != sqlite_wasm_rs::SQLITE_DONE {
1296 let err_msg = unsafe {
1297 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1298 if !err_ptr.is_null() {
1299 std::ffi::CStr::from_ptr(err_ptr)
1300 .to_string_lossy()
1301 .to_string()
1302 } else {
1303 "Unknown SQLite error".to_string()
1304 }
1305 };
1306 return Err(DatabaseError::new(
1307 "SQLITE_ERROR",
1308 &format!("Failed to execute statement: {}", err_msg),
1309 )
1310 .with_sql(sql));
1311 }
1312
1313 let execution_time_ms = js_sys::Date::now() - start_time;
1314
1315 #[cfg(feature = "telemetry")]
1317 if let Some(metrics) = &self.metrics {
1318 metrics.query_duration().observe(execution_time_ms);
1319 }
1320 let affected_rows = unsafe { sqlite_wasm_rs::sqlite3_changes(self.db()) } as u32;
1321 let last_insert_id = if sql.trim().to_uppercase().starts_with("INSERT") {
1322 Some(unsafe { sqlite_wasm_rs::sqlite3_last_insert_rowid(self.db()) })
1323 } else {
1324 None
1325 };
1326
1327 #[cfg(feature = "telemetry")]
1329 if let Some(mut s) = span {
1330 s.status = crate::telemetry::SpanStatus::Ok;
1331 s.end_time_ms = Some(js_sys::Date::now());
1332 s.attributes
1333 .insert("duration_ms".to_string(), execution_time_ms.to_string());
1334 s.attributes
1335 .insert("affected_rows".to_string(), affected_rows.to_string());
1336 if let Some(recorder) = &self.span_recorder {
1337 recorder.record_span(s);
1338 }
1339 }
1340
1341 Ok(QueryResult {
1342 columns: vec![],
1343 rows: vec![],
1344 affected_rows,
1345 last_insert_id,
1346 execution_time_ms,
1347 })
1348 }
1349 }
1350
1351 #[cfg(feature = "telemetry")]
1353 pub fn set_metrics(&mut self, metrics: Option<crate::telemetry::Metrics>) {
1354 self.metrics = metrics.clone();
1355 self.ensure_metrics_propagated();
1356 }
1357
1358 #[cfg(feature = "telemetry")]
1360 pub fn set_span_recorder(&mut self, recorder: Option<crate::telemetry::SpanRecorder>) {
1361 self.span_recorder = recorder;
1362 }
1363
1364 #[cfg(feature = "telemetry")]
1366 pub fn get_span_context(&self) -> Option<&crate::telemetry::SpanContext> {
1367 self.span_context.as_ref()
1368 }
1369
1370 #[cfg(feature = "telemetry")]
1372 pub fn get_span_recorder(&self) -> Option<&crate::telemetry::SpanRecorder> {
1373 self.span_recorder.as_ref()
1374 }
1375 #[cfg(feature = "telemetry")]
1377 fn ensure_metrics_propagated(&self) {
1378 #[cfg(target_arch = "wasm32")]
1380 {
1381 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1382
1383 if self.metrics.is_none() {
1384 return;
1385 }
1386
1387 let db_name = &self.name;
1388
1389 if let Some(storage_rc) = get_storage_with_fallback(db_name) {
1390 use crate::vfs::indexeddb_vfs::with_storage_borrow_mut;
1391 let _ = with_storage_borrow_mut(&storage_rc, "set_metrics", |storage| {
1392 storage.set_metrics(self.metrics.clone());
1393 Ok(())
1394 });
1395 }
1396 }
1397 }
1398
1399 pub async fn close_internal(&mut self) -> Result<(), DatabaseError> {
1400 log::info!("CLOSE_INTERNAL STARTED for: {}", self.name);
1401
1402 if self.connection_state.db.get().is_null() {
1404 log::info!(
1405 "Connection already null for {}, skipping close operations",
1406 self.name
1407 );
1408 return Ok(());
1409 }
1410
1411 log::info!("Checkpointing WAL before close: {}", self.name);
1413 let _ = self
1414 .execute_internal("PRAGMA wal_checkpoint(PASSIVE)")
1415 .await;
1416 log::info!("WAL checkpoint completed for: {}", self.name);
1417
1418 log::info!("Syncing database before close: {}", self.name);
1420 self.sync_internal().await?;
1421 log::info!("Sync completed for: {}", self.name);
1422
1423 web_sys::console::log_1(
1424 &format!("CLOSE: About to stop leader election for {}", self.name).into(),
1425 );
1426
1427 #[cfg(target_arch = "wasm32")]
1429 {
1430 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1431
1432 let db_name = &self.name;
1433 web_sys::console::log_1(
1434 &format!("STOP_ELECTION: Getting storage for {}", db_name).into(),
1435 );
1436 log::info!("STOP_ELECTION: Getting storage for {}", db_name);
1437 let storage_rc = get_storage_with_fallback(db_name);
1438
1439 if let Some(storage_rc) = storage_rc {
1440 log::info!("STOP_ELECTION: Found storage for {}, calling stop", db_name);
1441 match with_storage_async!(storage_rc, "stop_leader_election", |storage| storage
1442 .stop_leader_election())
1443 {
1444 Some(Ok(())) => {
1445 log::info!("STOP_ELECTION: Successfully stopped for {}", db_name);
1446 }
1447 Some(Err(e)) => {
1448 log::warn!("STOP_ELECTION: Failed for {}: {:?}", db_name, e);
1449 }
1450 None => {
1451 log::warn!("STOP_ELECTION: Borrow failed for {}", db_name);
1452 }
1453 }
1454 } else {
1455 log::warn!("STOP_ELECTION: No storage found for {}", db_name);
1456 }
1457 log::info!("STOP_ELECTION: Completed section for {}", db_name);
1458 }
1459
1460 log::info!(
1465 "Closed database: {} (connection will be released on Drop)",
1466 self.name
1467 );
1468 Ok(())
1469 }
1470
1471 pub async fn query(&mut self, sql: &str) -> Result<Vec<Row>, DatabaseError> {
1473 let result = self.execute_internal(sql).await?;
1474 Ok(result.rows)
1475 }
1476
1477 pub async fn sync_internal(&mut self) -> Result<(), DatabaseError> {
1478 #[cfg(all(target_arch = "wasm32", feature = "telemetry"))]
1480 let start_time = js_sys::Date::now();
1481
1482 #[cfg(feature = "telemetry")]
1484 let span = if self.span_recorder.is_some() {
1485 let mut builder = crate::telemetry::SpanBuilder::new("vfs_sync".to_string())
1486 .with_attribute("operation", "sync");
1487
1488 if let Some(ref context) = self.span_context {
1490 builder = builder
1491 .with_context(context)
1492 .with_baggage_from_context(context);
1493 }
1494
1495 let span = builder.build();
1496
1497 if let Some(ref context) = self.span_context {
1499 context.enter_span(span.span_id.clone());
1500 }
1501
1502 Some(span)
1503 } else {
1504 None
1505 };
1506
1507 #[cfg(feature = "telemetry")]
1509 if let Some(ref metrics) = self.metrics {
1510 metrics.sync_operations_total().inc();
1511 }
1512
1513 #[cfg(feature = "telemetry")]
1515 let mut blocks_count = 0;
1516
1517 #[cfg(target_arch = "wasm32")]
1519 {
1520 use crate::storage::vfs_sync;
1521
1522 let db_ptr = self.connection_state.db.get();
1524 if !db_ptr.is_null() {
1525 let checkpoint_sql =
1528 std::ffi::CString::new("PRAGMA wal_checkpoint(TRUNCATE)").expect("valid SQL");
1529 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
1530 let prepare_result = unsafe {
1531 sqlite_wasm_rs::sqlite3_prepare_v2(
1532 db_ptr,
1533 checkpoint_sql.as_ptr(),
1534 -1,
1535 &mut stmt,
1536 std::ptr::null_mut(),
1537 )
1538 };
1539 if prepare_result == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
1540 unsafe {
1541 sqlite_wasm_rs::sqlite3_step(stmt);
1542 sqlite_wasm_rs::sqlite3_finalize(stmt);
1543 }
1544 log::debug!("WAL checkpoint completed");
1545 }
1546
1547 let flush_result = unsafe { sqlite_wasm_rs::sqlite3_db_cacheflush(db_ptr) };
1549 if flush_result != sqlite_wasm_rs::SQLITE_OK {
1550 log::warn!("sqlite3_db_cacheflush returned {}", flush_result);
1551 }
1552 }
1553
1554 let storage_name = &self.name;
1558
1559 let next_commit = vfs_sync::with_global_commit_marker(|cm| {
1561 #[cfg(target_arch = "wasm32")]
1562 let mut cm_ref = cm.borrow_mut();
1563 #[cfg(not(target_arch = "wasm32"))]
1564 let mut cm_ref = cm.lock();
1565
1566 let current = cm_ref.get(storage_name).copied().unwrap_or(0);
1567 let new_marker = current + 1;
1568 cm_ref.insert(storage_name.to_string(), new_marker);
1569 log::debug!(
1570 "Advanced commit marker for {} from {} to {}",
1571 storage_name,
1572 current,
1573 new_marker
1574 );
1575 new_marker
1576 });
1577
1578 web_sys::console::log_1(
1579 &format!(
1580 "[SYNC] Collecting blocks from GLOBAL_STORAGE for: {}",
1581 storage_name
1582 )
1583 .into(),
1584 );
1585 let (blocks_to_persist, metadata_to_persist) =
1586 vfs_sync::with_global_storage(|storage| {
1587 #[cfg(target_arch = "wasm32")]
1588 let storage_map = storage.borrow();
1589 #[cfg(not(target_arch = "wasm32"))]
1590 let storage_map = storage.lock();
1591
1592 let blocks = if let Some(db_storage) = storage_map.get(storage_name) {
1593 let count = db_storage.len();
1594 web_sys::console::log_1(
1595 &format!("[SYNC] Found {} blocks in GLOBAL_STORAGE", count).into(),
1596 );
1597 db_storage
1598 .iter()
1599 .map(|(&id, data)| (id, data.clone()))
1600 .collect::<Vec<_>>()
1601 } else {
1602 web_sys::console::log_1(
1603 &format!(
1604 "[SYNC] No blocks found in GLOBAL_STORAGE for {}",
1605 storage_name
1606 )
1607 .into(),
1608 );
1609 Vec::new()
1610 };
1611
1612 let metadata = vfs_sync::with_global_metadata(|meta| {
1613 #[cfg(target_arch = "wasm32")]
1614 let meta_map = meta.borrow();
1615 #[cfg(not(target_arch = "wasm32"))]
1616 let meta_map = meta.lock();
1617 if let Some(db_meta) = meta_map.get(storage_name) {
1618 let count = db_meta.len();
1619 web_sys::console::log_1(
1620 &format!("[SYNC] Found {} metadata entries", count).into(),
1621 );
1622 db_meta
1623 .iter()
1624 .map(|(&id, metadata)| (id, metadata.clone()))
1625 .collect::<Vec<_>>()
1626 } else {
1627 web_sys::console::log_1(&format!("[SYNC] No metadata found").into());
1628 Vec::new()
1629 }
1630 });
1631
1632 (blocks, metadata)
1633 });
1634
1635 let backend = crate::vfs::indexeddb_vfs::get_storage_with_fallback(storage_name)
1636 .map(|storage| storage.storage_backend())
1637 .unwrap_or(crate::storage::StorageBackend::IndexedDb);
1638
1639 web_sys::console::log_1(
1640 &format!(
1641 "[SYNC] Preparing to persist {} blocks using backend {}",
1642 blocks_to_persist.len(),
1643 backend.as_str()
1644 )
1645 .into(),
1646 );
1647
1648 if !blocks_to_persist.is_empty() {
1649 #[cfg(feature = "telemetry")]
1650 {
1651 blocks_count = blocks_to_persist.len();
1652 }
1653 match backend {
1654 crate::storage::StorageBackend::IndexedDb => {
1655 web_sys::console::log_1(
1656 &format!(
1657 "[SYNC] Persisting {} blocks to IndexedDB",
1658 blocks_to_persist.len()
1659 )
1660 .into(),
1661 );
1662 crate::storage::wasm_indexeddb::persist_to_indexeddb_event_based(
1663 storage_name,
1664 blocks_to_persist,
1665 metadata_to_persist,
1666 next_commit,
1667 #[cfg(feature = "telemetry")]
1668 self.span_recorder.clone(),
1669 #[cfg(feature = "telemetry")]
1670 span.as_ref().map(|s| s.span_id.clone()),
1671 )
1672 .await?;
1673 web_sys::console::log_1(
1674 &format!("[SYNC] Successfully persisted to IndexedDB").into(),
1675 );
1676 }
1677 crate::storage::StorageBackend::Opfs
1678 | crate::storage::StorageBackend::Hybrid => {
1679 web_sys::console::log_1(
1680 &format!(
1681 "[SYNC] Persisting {} blocks to OPFS and mirroring to IndexedDB",
1682 blocks_to_persist.len()
1683 )
1684 .into(),
1685 );
1686 crate::storage::hybrid_store::hybrid_persist(
1687 storage_name,
1688 blocks_to_persist,
1689 metadata_to_persist,
1690 next_commit,
1691 #[cfg(feature = "telemetry")]
1692 self.span_recorder.clone(),
1693 #[cfg(feature = "telemetry")]
1694 span.as_ref().map(|s| s.span_id.clone()),
1695 )
1696 .await?;
1697 web_sys::console::log_1(
1698 &format!("[SYNC] Successfully persisted to OPFS and IndexedDB").into(),
1699 );
1700 }
1701 }
1702 } else {
1703 web_sys::console::log_1(
1704 &format!("[SYNC] WARNING: No blocks to persist - GLOBAL_STORAGE is empty!")
1705 .into(),
1706 );
1707 }
1708
1709 use crate::storage::broadcast_notifications::{
1711 BroadcastNotification, send_change_notification,
1712 };
1713
1714 let notification = BroadcastNotification::DataChanged {
1715 db_name: self.name.clone(),
1716 timestamp: js_sys::Date::now() as u64,
1717 };
1718
1719 log::debug!("Sending DataChanged notification for {}", self.name);
1720
1721 if let Err(e) = send_change_notification(¬ification) {
1722 log::warn!("Failed to send change notification: {}", e);
1723 }
1725 }
1726
1727 #[cfg(all(target_arch = "wasm32", feature = "telemetry"))]
1729 if let Some(ref metrics) = self.metrics {
1730 let duration_ms = js_sys::Date::now() - start_time;
1731 metrics.sync_duration().observe(duration_ms);
1732 }
1733
1734 #[cfg(feature = "telemetry")]
1736 if let Some(mut s) = span {
1737 s.status = crate::telemetry::SpanStatus::Ok;
1738 #[cfg(target_arch = "wasm32")]
1739 {
1740 s.end_time_ms = Some(js_sys::Date::now());
1741 let duration_ms = s.end_time_ms.unwrap() - s.start_time_ms;
1742 s.attributes
1743 .insert("duration_ms".to_string(), duration_ms.to_string());
1744 }
1745 #[cfg(not(target_arch = "wasm32"))]
1746 {
1747 let now = std::time::SystemTime::now()
1748 .duration_since(std::time::UNIX_EPOCH)
1749 .unwrap()
1750 .as_millis() as f64;
1751 s.end_time_ms = Some(now);
1752 let duration_ms = s.end_time_ms.unwrap() - s.start_time_ms;
1753 s.attributes
1754 .insert("duration_ms".to_string(), duration_ms.to_string());
1755 }
1756 s.attributes
1757 .insert("blocks_persisted".to_string(), blocks_count.to_string());
1758 if let Some(recorder) = &self.span_recorder {
1759 recorder.record_span(s);
1760 }
1761
1762 if let Some(ref context) = self.span_context {
1764 context.exit_span();
1765 }
1766 }
1767
1768 Ok(())
1769 }
1770}
1771
1772#[cfg(target_arch = "wasm32")]
1773impl Drop for Database {
1774 fn drop(&mut self) {
1775 web_sys::console::log_1(&format!("DROP: Releasing connection for {}", self.name).into());
1776
1777 let pool_key = self.name.trim_end_matches(".db");
1781 crate::connection_pool::release_connection(pool_key);
1782
1783 web_sys::console::log_1(&format!("DROP: Connection released for {}", self.name).into());
1784
1785 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1787 if let Some(storage_rc) = get_storage_with_fallback(&self.name) {
1788 let storage = &*storage_rc;
1790 if let Ok(mut manager_ref) = storage.leader_election.try_borrow_mut() {
1792 if let Some(ref mut manager) = *manager_ref {
1793 if let Some(interval_id) = manager.heartbeat_interval.take() {
1795 if let Some(window) = web_sys::window() {
1796 window.clear_interval_with_handle(interval_id);
1797 web_sys::console::log_1(
1798 &format!(
1799 "DROP: Cleared heartbeat interval {} for {}",
1800 interval_id, self.name
1801 )
1802 .into(),
1803 );
1804 }
1805 }
1806 }
1809 } else {
1810 web_sys::console::log_1(
1812 &format!(
1813 "[DROP] Skipping {} (heartbeat already stopped by shared DB)",
1814 self.name
1815 )
1816 .into(),
1817 );
1818 }
1819 }
1820
1821 log::debug!(
1825 "Closed database: {} (BlockStorage remains in registry)",
1826 self.name
1827 );
1828 }
1829}
1830
1831#[cfg(target_arch = "wasm32")]
1833#[wasm_bindgen]
1834impl Database {
1835 #[wasm_bindgen(js_name = "newDatabase")]
1836 pub async fn new_wasm(name: String) -> Result<Database, JsValue> {
1837 let normalized_name = if name.ends_with(".db") {
1839 name.clone()
1840 } else {
1841 format!("{}.db", name)
1842 };
1843
1844 let config = Self::default_wasm_config(normalized_name.clone());
1845
1846 let db = Database::new(config)
1847 .await
1848 .map_err(|e| JsValue::from_str(&format!("Failed to create database: {}", e)))?;
1849
1850 Self::start_write_queue_listener(&normalized_name)?;
1852
1853 Ok(db)
1854 }
1855
1856 #[wasm_bindgen(js_name = "newDatabaseAuto")]
1857 pub async fn new_wasm_auto(name: String) -> Result<Database, JsValue> {
1858 let normalized_name = if name.ends_with(".db") {
1859 name.clone()
1860 } else {
1861 format!("{}.db", name)
1862 };
1863
1864 let config = Self::default_wasm_config(normalized_name.clone());
1865 let backend = crate::storage::backend_detect::detect_best_backend().await;
1866
1867 let db = Database::new_with_storage_backend(config, backend)
1868 .await
1869 .map_err(|e| JsValue::from_str(&format!("Failed to create database: {}", e)))?;
1870
1871 Self::start_write_queue_listener(&normalized_name)?;
1872
1873 Ok(db)
1874 }
1875
1876 #[wasm_bindgen(js_name = "newDatabaseWithBackend")]
1877 pub async fn new_wasm_with_backend(
1878 name: String,
1879 backend_name: String,
1880 ) -> Result<Database, JsValue> {
1881 let normalized_name = if name.ends_with(".db") {
1882 name.clone()
1883 } else {
1884 format!("{}.db", name)
1885 };
1886
1887 let backend = match backend_name.to_ascii_lowercase().as_str() {
1888 "indexeddb" | "indexed-db" | "indexed_db" | "idb" => {
1889 crate::storage::StorageBackend::IndexedDb
1890 }
1891 "opfs" => crate::storage::StorageBackend::Opfs,
1892 "hybrid" => crate::storage::StorageBackend::Hybrid,
1893 _ => {
1894 return Err(JsValue::from_str(&format!(
1895 "Unsupported storage backend '{}'. Expected IndexedDB, OPFS, or Hybrid.",
1896 backend_name
1897 )));
1898 }
1899 };
1900
1901 let config = Self::default_wasm_config(normalized_name.clone());
1902
1903 let db = Database::new_with_storage_backend(config, backend)
1904 .await
1905 .map_err(|e| JsValue::from_str(&format!("Failed to create database: {}", e)))?;
1906
1907 Self::start_write_queue_listener(&normalized_name)?;
1908
1909 Ok(db)
1910 }
1911
1912 #[wasm_bindgen(getter)]
1914 pub fn name(&self) -> String {
1915 self.name.clone()
1916 }
1917
1918 #[wasm_bindgen(js_name = "getStorageBackend")]
1919 pub fn get_storage_backend(&self) -> Result<String, JsValue> {
1920 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1921
1922 let storage = get_storage_with_fallback(&self.name).ok_or_else(|| {
1923 JsValue::from_str(&format!("No storage found for database: {}", self.name))
1924 })?;
1925
1926 Ok(storage.storage_backend().as_str().to_string())
1927 }
1928
1929 #[wasm_bindgen(js_name = "getAllDatabases")]
1933 pub async fn get_all_databases() -> Result<JsValue, JsValue> {
1934 use crate::storage::vfs_sync::with_global_storage;
1935 use crate::vfs::indexeddb_vfs::STORAGE_REGISTRY;
1936 use std::collections::HashSet;
1937
1938 log::info!("getAllDatabases called");
1939 let mut db_names = HashSet::new();
1940
1941 match Self::get_persistent_database_list() {
1943 Ok(persistent_list) => {
1944 log::info!("Persistent list has {} entries", persistent_list.len());
1945 for name in persistent_list {
1946 log::info!("Found in persistent list: {}", name);
1947 db_names.insert(name);
1948 }
1949 }
1950 Err(e) => {
1951 log::warn!("Failed to get persistent list: {:?}", e);
1952 }
1953 }
1954
1955 STORAGE_REGISTRY.with(|reg| unsafe {
1958 let registry = &*reg.get();
1959 log::info!("STORAGE_REGISTRY has {} entries", registry.len());
1960 for key in registry.keys() {
1961 log::info!("Found in STORAGE_REGISTRY: {}", key);
1962 db_names.insert(key.clone());
1963 }
1964 });
1965
1966 with_global_storage(|storage| {
1968 let storage_borrow = storage.borrow();
1969 log::info!("GLOBAL_STORAGE has {} entries", storage_borrow.len());
1970 for key in storage_borrow.keys() {
1971 log::info!("Found in GLOBAL_STORAGE: {}", key);
1972 db_names.insert(key.clone());
1973 }
1974 });
1975
1976 log::info!("Total unique databases found: {}", db_names.len());
1977
1978 let mut result_vec: Vec<String> = db_names.into_iter().collect();
1980 result_vec.sort();
1981
1982 let js_array = js_sys::Array::new();
1984 for name in &result_vec {
1985 log::info!("Returning database: {}", name);
1986 js_array.push(&JsValue::from_str(name));
1987 }
1988
1989 log::info!("getAllDatabases returning {} databases", result_vec.len());
1990
1991 Ok(js_array.into())
1992 }
1993
1994 #[wasm_bindgen(js_name = "deleteDatabase")]
1998 pub async fn delete_database(name: String) -> Result<(), JsValue> {
1999 use crate::storage::vfs_sync::{
2000 with_global_commit_marker, with_global_metadata, with_global_storage,
2001 };
2002
2003 let normalized_name = if name.ends_with(".db") {
2005 name.clone()
2006 } else {
2007 format!("{}.db", name)
2008 };
2009
2010 log::info!("Deleting database: {}", normalized_name);
2011
2012 use crate::vfs::indexeddb_vfs::remove_storage_from_registry;
2014 remove_storage_from_registry(&normalized_name);
2015
2016 with_global_storage(|gs| {
2018 #[cfg(target_arch = "wasm32")]
2019 let mut storage = gs.borrow_mut();
2020 #[cfg(not(target_arch = "wasm32"))]
2021 let mut storage = gs.lock();
2022 storage.remove(&normalized_name);
2023 });
2024
2025 with_global_metadata(|gm| {
2027 #[cfg(target_arch = "wasm32")]
2028 let mut metadata = gm.borrow_mut();
2029 #[cfg(not(target_arch = "wasm32"))]
2030 let mut metadata = gm.lock();
2031 metadata.remove(&normalized_name);
2032 });
2033
2034 with_global_commit_marker(|cm| {
2036 #[cfg(target_arch = "wasm32")]
2037 let mut markers = cm.borrow_mut();
2038 #[cfg(not(target_arch = "wasm32"))]
2039 let mut markers = cm.lock();
2040 log::info!(
2041 "Cleared commit marker for {} from GLOBAL storage",
2042 normalized_name
2043 );
2044 markers.remove(&normalized_name);
2045 });
2046
2047 let idb_name = format!("absurder_{}", normalized_name);
2050 {
2051 use wasm_bindgen::JsCast;
2052 let global = js_sys::global();
2053 let indexed_db_value =
2054 js_sys::Reflect::get(&global, &JsValue::from_str("indexedDB"))
2055 .map_err(|e| JsValue::from_str(&format!("IndexedDB access failed: {:?}", e)))?;
2056 if !indexed_db_value.is_null() && !indexed_db_value.is_undefined() {
2057 let idb_factory: web_sys::IdbFactory = indexed_db_value
2058 .dyn_into()
2059 .map_err(|_| JsValue::from_str("indexedDB is not an IdbFactory"))?;
2060 idb_factory.delete_database(&idb_name).map_err(|e| {
2061 JsValue::from_str(&format!("Failed to delete IndexedDB: {:?}", e))
2062 })?;
2063 }
2064 }
2065
2066 if let Err(error) = crate::storage::wasm_opfs::delete_all_from_opfs(&normalized_name).await
2067 {
2068 log::warn!(
2069 "Failed to delete OPFS data for {} during deleteDatabase: {}",
2070 normalized_name,
2071 error.message
2072 );
2073 }
2074
2075 log::info!("Database deleted: {}", normalized_name);
2076
2077 Self::remove_database_from_persistent_list(&normalized_name)?;
2079
2080 Ok(())
2081 }
2082
2083 #[allow(dead_code)]
2085 fn persistent_list_storage() -> Result<Option<web_sys::Storage>, JsValue> {
2086 let Some(window) = web_sys::window() else {
2087 log::info!("Persistent database list unavailable without Window; skipping");
2088 return Ok(None);
2089 };
2090
2091 let Some(storage) = window.local_storage().map_err(|e| {
2092 log::error!("Failed to get localStorage: {:?}", e);
2093 JsValue::from_str("No localStorage")
2094 })?
2095 else {
2096 log::info!("Persistent database list unavailable without localStorage; skipping");
2097 return Ok(None);
2098 };
2099
2100 Ok(Some(storage))
2101 }
2102
2103 #[allow(dead_code)]
2105 fn add_database_to_persistent_list(db_name: &str) -> Result<(), JsValue> {
2106 log::info!("add_database_to_persistent_list called for: {}", db_name);
2107
2108 let Some(storage) = Self::persistent_list_storage()? else {
2109 return Ok(());
2110 };
2111
2112 let key = "absurder_db_list";
2113 let existing = storage.get_item(key).map_err(|e| {
2114 log::error!("Failed to read localStorage key {}: {:?}", key, e);
2115 JsValue::from_str("Failed to read localStorage")
2116 })?;
2117
2118 log::debug!("Existing localStorage value: {:?}", existing);
2119
2120 let mut db_list: Vec<String> = if let Some(json_str) = existing {
2121 match serde_json::from_str(&json_str) {
2122 Ok(list) => {
2123 log::debug!("Parsed existing list: {:?}", list);
2124 list
2125 }
2126 Err(e) => {
2127 log::warn!("Failed to parse localStorage JSON: {}, starting fresh", e);
2128 Vec::new()
2129 }
2130 }
2131 } else {
2132 log::debug!("No existing list, creating new");
2133 Vec::new()
2134 };
2135
2136 if !db_list.contains(&db_name.to_string()) {
2137 db_list.push(db_name.to_string());
2138 db_list.sort();
2139 log::debug!("Updated list: {:?}", db_list);
2140
2141 let json_str = serde_json::to_string(&db_list).map_err(|e| {
2142 log::error!("Failed to serialize list: {}", e);
2143 JsValue::from_str("Failed to serialize")
2144 })?;
2145
2146 log::debug!("Writing to localStorage: {}", json_str);
2147
2148 storage.set_item(key, &json_str).map_err(|e| {
2149 log::error!("Failed to write to localStorage: {:?}", e);
2150 JsValue::from_str("Failed to write localStorage")
2151 })?;
2152
2153 log::info!("Successfully added {} to persistent database list", db_name);
2154 } else {
2155 log::info!("{} already in persistent list", db_name);
2156 }
2157
2158 Ok(())
2159 }
2160
2161 fn remove_database_from_persistent_list(db_name: &str) -> Result<(), JsValue> {
2163 let Some(storage) = Self::persistent_list_storage()? else {
2164 return Ok(());
2165 };
2166
2167 let key = "absurder_db_list";
2168 let existing = storage
2169 .get_item(key)
2170 .map_err(|_| JsValue::from_str("Failed to read localStorage"))?;
2171
2172 if let Some(json_str) = existing {
2173 let mut db_list: Vec<String> =
2174 serde_json::from_str(&json_str).unwrap_or_else(|_| Vec::new());
2175 db_list.retain(|name| name != db_name);
2176 let json_str = serde_json::to_string(&db_list)
2177 .map_err(|_| JsValue::from_str("Failed to serialize"))?;
2178 storage
2179 .set_item(key, &json_str)
2180 .map_err(|_| JsValue::from_str("Failed to write localStorage"))?;
2181 log::info!("Removed {} from persistent database list", db_name);
2182 }
2183
2184 Ok(())
2185 }
2186
2187 fn get_persistent_database_list() -> Result<Vec<String>, JsValue> {
2189 log::info!("get_persistent_database_list called");
2190
2191 let Some(storage) = Self::persistent_list_storage()? else {
2192 return Ok(Vec::new());
2193 };
2194
2195 let key = "absurder_db_list";
2196 let existing = storage.get_item(key).map_err(|e| {
2197 log::error!("Failed to read localStorage key {}: {:?}", key, e);
2198 JsValue::from_str("Failed to read localStorage")
2199 })?;
2200
2201 log::debug!("Read from localStorage: {:?}", existing);
2202
2203 if let Some(json_str) = existing {
2204 match serde_json::from_str::<Vec<String>>(&json_str) {
2205 Ok(db_list) => {
2206 log::info!(
2207 "Successfully parsed {} databases from localStorage",
2208 db_list.len()
2209 );
2210 log::debug!("Database list: {:?}", db_list);
2211 Ok(db_list)
2212 }
2213 Err(e) => {
2214 log::error!("Failed to parse localStorage JSON: {}", e);
2215 Ok(Vec::new())
2216 }
2217 }
2218 } else {
2219 log::info!("No persistent database list in localStorage");
2220 Ok(Vec::new())
2221 }
2222 }
2223
2224 fn start_write_queue_listener(db_name: &str) -> Result<(), JsValue> {
2226 use crate::storage::write_queue::{
2227 WriteQueueMessage, WriteResponse, register_write_queue_listener,
2228 };
2229 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2230
2231 let db_name_clone = db_name.to_string();
2232
2233 let callback = Closure::wrap(Box::new(move |msg: JsValue| {
2234 let db_name_inner = db_name_clone.clone();
2235
2236 if let Ok(json_str) = js_sys::JSON::stringify(&msg) {
2238 if let Some(json_str) = json_str.as_string() {
2239 if let Ok(message) = serde_json::from_str::<WriteQueueMessage>(&json_str) {
2240 if let WriteQueueMessage::WriteRequest(request) = message {
2241 log::debug!("Leader received write request: {}", request.request_id);
2242
2243 let storage_rc = get_storage_with_fallback(&db_name_inner);
2245
2246 if let Some(storage) = storage_rc {
2247 wasm_bindgen_futures::spawn_local(async move {
2249 let is_leader = with_storage_async!(
2250 storage,
2251 "write_queue_is_leader",
2252 |s| s.is_leader()
2253 );
2254 if is_leader.is_none() {
2255 log::error!("Failed to check leader status");
2256 return;
2257 }
2258 let is_leader = is_leader.unwrap();
2259
2260 if !is_leader {
2261 log::error!("Not leader, ignoring write request");
2262 return;
2263 }
2264
2265 log::debug!("Processing write request as leader");
2266
2267 match Database::new_wasm(db_name_inner.clone()).await {
2269 Ok(mut db) => {
2270 match db.execute_internal(&request.sql).await {
2272 Ok(result) => {
2273 let response = WriteResponse::Success {
2275 request_id: request.request_id.clone(),
2276 affected_rows: result.affected_rows
2277 as usize,
2278 };
2279
2280 use crate::storage::write_queue::send_write_response;
2281 if let Err(e) = send_write_response(
2282 &db_name_inner,
2283 response,
2284 ) {
2285 log::error!(
2286 "Failed to send response: {}",
2287 e
2288 );
2289 } else {
2290 log::info!(
2291 "Write response sent successfully"
2292 );
2293 }
2294 }
2295 Err(e) => {
2296 let response = WriteResponse::Error {
2298 request_id: request.request_id.clone(),
2299 error_message: e.to_string(),
2300 };
2301
2302 use crate::storage::write_queue::send_write_response;
2303 if let Err(e) = send_write_response(
2304 &db_name_inner,
2305 response,
2306 ) {
2307 log::error!(
2308 "Failed to send error response: {}",
2309 e
2310 );
2311 }
2312 }
2313 }
2314 }
2315 Err(e) => {
2316 log::error!(
2317 "Failed to create db for write processing: {:?}",
2318 e
2319 );
2320 }
2321 }
2322 });
2323 }
2324 }
2325 }
2326 }
2327 }
2328 }) as Box<dyn FnMut(JsValue)>);
2329
2330 let callback_fn = callback.as_ref().unchecked_ref();
2331 register_write_queue_listener(db_name, callback_fn).map_err(|e| {
2332 JsValue::from_str(&format!("Failed to register write queue listener: {}", e))
2333 })?;
2334
2335 callback.forget();
2336
2337 Ok(())
2338 }
2339
2340 #[wasm_bindgen]
2341 pub async fn execute(&mut self, sql: &str) -> Result<JsValue, JsValue> {
2342 self.check_write_permission(sql)
2344 .await
2345 .map_err(|e| JsValue::from_str(&format!("Write permission denied: {}", e)))?;
2346
2347 let result = self
2348 .execute_internal(sql)
2349 .await
2350 .map_err(|e| JsValue::from_str(&format!("Query execution failed: {}", e)))?;
2351 serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
2352 }
2353
2354 #[wasm_bindgen(js_name = "executeWithParams")]
2355 pub async fn execute_with_params(
2356 &mut self,
2357 sql: &str,
2358 params: JsValue,
2359 ) -> Result<JsValue, JsValue> {
2360 let params: Vec<ColumnValue> = serde_wasm_bindgen::from_value(params)
2361 .map_err(|e| JsValue::from_str(&format!("Invalid parameters: {}", e)))?;
2362
2363 self.check_write_permission(sql)
2365 .await
2366 .map_err(|e| JsValue::from_str(&format!("Write permission denied: {}", e)))?;
2367
2368 let result = self
2369 .execute_with_params_internal(sql, ¶ms)
2370 .await
2371 .map_err(|e| JsValue::from_str(&format!("Query execution failed: {}", e)))?;
2372 serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
2373 }
2374
2375 #[wasm_bindgen]
2376 pub async fn close(&mut self) -> Result<(), JsValue> {
2377 self.close_internal()
2378 .await
2379 .map_err(|e| JsValue::from_str(&format!("Failed to close database: {}", e)))
2380 }
2381
2382 #[wasm_bindgen(js_name = "forceCloseConnection")]
2384 pub async fn force_close_connection(&mut self) -> Result<(), JsValue> {
2385 let _ = self.close_internal().await;
2387
2388 let pool_key = self.name.trim_end_matches(".db");
2391 crate::connection_pool::force_close_connection(pool_key);
2392
2393 #[cfg(target_arch = "wasm32")]
2395 {
2396 crate::cleanup::cleanup_all_state(pool_key)
2397 .await
2398 .map_err(|e| JsValue::from_str(&format!("Cleanup failed: {}", e)))?;
2399 }
2400 log::info!("Force closed and removed connection for: {}", self.name);
2401 Ok(())
2402 }
2403
2404 #[wasm_bindgen]
2405 pub async fn sync(&mut self) -> Result<(), JsValue> {
2406 self.sync_internal()
2407 .await
2408 .map_err(|e| JsValue::from_str(&format!("Failed to sync database: {}", e)))
2409 }
2410
2411 #[wasm_bindgen(js_name = "allowNonLeaderWrites")]
2413 pub async fn allow_non_leader_writes(&mut self, allow: bool) -> Result<(), JsValue> {
2414 log::debug!("Setting allowNonLeaderWrites = {} for {}", allow, self.name);
2415 self.allow_non_leader_writes = allow;
2416 Ok(())
2417 }
2418
2419 #[wasm_bindgen(js_name = "exportToFile")]
2435 pub async fn export_to_file(&self) -> Result<js_sys::Uint8Array, JsValue> {
2436 let db_name = self.name.clone();
2437 let max_export_size = self.max_export_size_bytes;
2438
2439 crate::storage::export_import_lock::with_lock(&db_name, || async {
2440 log::info!("[EXPORT] ===== Step 1: Lock acquired");
2441
2442 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2444 log::info!("[EXPORT] ===== Step 2: Getting storage");
2445 let storage_rc = get_storage_with_fallback(&db_name).ok_or_else(|| {
2446 JsValue::from_str(&format!("Storage not found for database: {}", db_name))
2447 })?;
2448 log::info!("[EXPORT] ===== Step 3: Got storage");
2449
2450 log::info!("[EXPORT] ===== Step 4: Checkpointing WAL");
2453 if !self.connection_state.db.get().is_null() {
2454 use std::ffi::CString;
2456 let pragma = CString::new("PRAGMA wal_checkpoint(PASSIVE)").unwrap();
2457 unsafe {
2458 let mut stmt = std::ptr::null_mut();
2459 let rc = sqlite_wasm_rs::sqlite3_prepare_v2(
2460 self.connection_state.db.get(),
2461 pragma.as_ptr(),
2462 -1,
2463 &mut stmt,
2464 std::ptr::null_mut(),
2465 );
2466 if rc == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
2467 sqlite_wasm_rs::sqlite3_step(stmt);
2468 sqlite_wasm_rs::sqlite3_finalize(stmt);
2469 log::info!("[EXPORT] WAL checkpoint completed");
2470 } else {
2471 log::warn!("[EXPORT] WAL checkpoint failed with rc: {}", rc);
2472 }
2473 }
2474 }
2475
2476 #[cfg(target_arch = "wasm32")]
2479 {
2480 log::info!("[EXPORT] ===== Step 4b: Reloading cache after checkpoint");
2481 storage_rc.reload_cache_from_global_storage();
2482 }
2483
2484 log::info!("[EXPORT] ===== Step 5: Starting sync");
2485 storage_rc
2486 .sync()
2487 .await
2488 .map_err(|e| JsValue::from_str(&format!("Sync failed: {}", e)))?;
2489 log::info!("[EXPORT] ===== Step 6: Sync complete");
2490
2491 log::info!("[EXPORT] Calling export_database_to_bytes");
2492 let db_bytes = {
2493 let storage = &*storage_rc;
2494 crate::storage::export::export_database_to_bytes(storage, max_export_size)
2495 .await
2496 .map_err(|e| {
2497 log::error!("[EXPORT] Export failed: {}", e);
2498 JsValue::from_str(&format!("Export failed: {}", e))
2499 })?
2500 };
2501
2502 log::info!("[EXPORT] Export complete: {} bytes", db_bytes.len());
2503
2504 let uint8_array = js_sys::Uint8Array::new_with_length(db_bytes.len() as u32);
2505 uint8_array.copy_from(&db_bytes);
2506
2507 Ok(uint8_array)
2508 })
2509 .await
2510 }
2511
2512 #[wasm_bindgen(js_name = "testLock")]
2514 pub async fn test_lock(&self, value: u32) -> Result<u32, JsValue> {
2515 let lock_name = format!("{}.lock_test", self.name);
2516
2517 log::info!(
2518 "[LOCK-TEST] Acquiring lock: {} with value: {}",
2519 lock_name,
2520 value
2521 );
2522 let _guard = weblocks::acquire(&lock_name, weblocks::AcquireOptions::exclusive()).await?;
2523 log::info!("[LOCK-TEST] Lock acquired, processing value: {}", value);
2524
2525 let result = value + 1;
2527
2528 let delay_promise = js_sys::Promise::new(&mut |resolve, _reject| {
2530 let window = web_sys::window().unwrap();
2531 let _ = window
2532 .set_timeout_with_callback_and_timeout_and_arguments_0(resolve.unchecked_ref(), 10);
2533 });
2534 wasm_bindgen_futures::JsFuture::from(delay_promise).await?;
2535
2536 log::info!(
2537 "[LOCK-TEST] Lock releasing for: {} with result: {}",
2538 lock_name,
2539 result
2540 );
2541 Ok(result)
2542 }
2543
2544 #[wasm_bindgen(js_name = "importFromFile")]
2573 pub async fn import_from_file(&mut self, file_data: js_sys::Uint8Array) -> Result<(), JsValue> {
2574 log::info!("[IMPORT] Starting import with lock for: {}", self.name);
2575 let db_name = self.name.clone();
2576 let data = file_data.to_vec();
2577
2578 crate::storage::export_import_lock::with_lock(&db_name, || async {
2579 log::info!("[IMPORT] Lock acquired for: {}", db_name);
2580 log::debug!("Import data size: {} bytes", data.len());
2581
2582 let storage_backend = crate::vfs::indexeddb_vfs::get_storage_with_fallback(&db_name)
2583 .map(|storage| storage.storage_backend())
2584 .unwrap_or(crate::storage::StorageBackend::IndexedDb);
2585
2586 log::debug!("Force-closing database connection before import");
2587
2588 self.close_internal()
2589 .await
2590 .map_err(|e| JsValue::from_str(&format!("Failed to close before import: {}", e)))?;
2591
2592 let pool_key = self.name.trim_end_matches(".db");
2593 crate::connection_pool::force_close_connection(pool_key);
2594 self.connection_state.db.set(std::ptr::null_mut());
2595 log::debug!("Removed connection from pool for import");
2596
2597 crate::storage::import::import_database_from_bytes_with_backend(
2598 &db_name,
2599 data,
2600 storage_backend,
2601 )
2602 .await
2603 .map_err(|e| {
2604 log::error!("Import failed for {}: {}", db_name, e);
2605 JsValue::from_str(&format!("Import failed: {}", e))
2606 })?;
2607
2608 log::info!("[IMPORT] Import complete for: {}", db_name);
2609 log::info!("[IMPORT] Reopening connection for: {}", db_name);
2610
2611 use std::ffi::CString;
2612
2613 let vfs_name = format!("vfs_{}", db_name.trim_end_matches(".db"));
2614 let pool_key = db_name.trim_end_matches(".db").to_string();
2615 let db_name_for_closure = db_name.clone();
2616 let vfs_name_for_closure = vfs_name.clone();
2617
2618 let new_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
2619 let mut db = std::ptr::null_mut();
2620 let db_name_cstr = CString::new(db_name_for_closure.clone())
2621 .map_err(|_| "Invalid database name".to_string())?;
2622 let vfs_cstr = CString::new(vfs_name_for_closure.as_str())
2623 .map_err(|_| "Invalid VFS name".to_string())?;
2624
2625 log::info!(
2626 "[IMPORT] Reopening database: {} with VFS: {}",
2627 db_name_for_closure,
2628 vfs_name_for_closure
2629 );
2630
2631 let ret = unsafe {
2632 sqlite_wasm_rs::sqlite3_open_v2(
2633 db_name_cstr.as_ptr(),
2634 &mut db as *mut _,
2635 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
2636 vfs_cstr.as_ptr(),
2637 )
2638 };
2639
2640 if ret != sqlite_wasm_rs::SQLITE_OK {
2641 let err_msg = unsafe {
2642 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
2643 if !msg_ptr.is_null() {
2644 std::ffi::CStr::from_ptr(msg_ptr)
2645 .to_string_lossy()
2646 .into_owned()
2647 } else {
2648 "Unknown error".to_string()
2649 }
2650 };
2651 return Err(format!(
2652 "Failed to reopen database after import: {}",
2653 err_msg
2654 ));
2655 }
2656
2657 log::info!("[IMPORT] Database reopened successfully");
2658 Ok(db)
2659 })
2660 .map_err(|e| {
2661 JsValue::from_str(&format!("Failed to reopen connection after import: {}", e))
2662 })?;
2663
2664 self.connection_state = new_state;
2665 log::info!("[IMPORT] Connection state updated for: {}", db_name);
2666
2667 Ok(())
2668 })
2669 .await
2670 }
2671
2672 #[wasm_bindgen(js_name = "waitForLeadership")]
2674 pub async fn wait_for_leadership(&mut self) -> Result<(), JsValue> {
2675 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2676
2677 #[cfg(feature = "telemetry")]
2679 if let Some(ref metrics) = self.metrics {
2680 metrics.leader_election_attempts_total().inc();
2681 }
2682
2683 let db_name = &self.name;
2684 let start_time = js_sys::Date::now();
2685
2686 let timeout_ms = 5000.0; loop {
2689 let storage_rc = get_storage_with_fallback(db_name);
2690
2691 if let Some(storage) = storage_rc {
2692 let is_leader =
2693 match with_storage_async!(storage, "wait_for_leadership", |s| s.is_leader()) {
2694 Some(v) => v,
2695 None => continue,
2696 };
2697
2698 if is_leader {
2699 log::info!("Became leader for {}", db_name);
2700
2701 #[cfg(feature = "telemetry")]
2703 if let Some(ref metrics) = self.metrics {
2704 let duration_ms = js_sys::Date::now() - start_time;
2705 metrics.leader_election_duration().observe(duration_ms);
2706 metrics.is_leader().set(1.0);
2707 metrics.leadership_changes_total().inc();
2708 }
2709
2710 return Ok(());
2711 }
2712 }
2713
2714 if js_sys::Date::now() - start_time > timeout_ms {
2716 #[cfg(feature = "telemetry")]
2718 if let Some(ref metrics) = self.metrics {
2719 let duration_ms = js_sys::Date::now() - start_time;
2720 metrics.leader_election_duration().observe(duration_ms);
2721 }
2722
2723 return Err(JsValue::from_str("Timeout waiting for leadership"));
2724 }
2725
2726 let promise = js_sys::Promise::new(&mut |resolve, _| {
2728 let window = web_sys::window().expect("should have window");
2729 let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, 100);
2730 });
2731 let _ = wasm_bindgen_futures::JsFuture::from(promise).await;
2732 }
2733 }
2734
2735 #[wasm_bindgen(js_name = "requestLeadership")]
2737 pub async fn request_leadership(&mut self) -> Result<(), JsValue> {
2738 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2739
2740 let db_name = &self.name;
2741 log::debug!("Requesting leadership for {}", db_name);
2742
2743 #[cfg(feature = "telemetry")]
2745 let telemetry_data = if self.metrics.is_some() {
2746 let start_time = js_sys::Date::now();
2747 let was_leader = self
2748 .is_leader_wasm()
2749 .await
2750 .ok()
2751 .and_then(|v| v.as_bool())
2752 .unwrap_or(false);
2753
2754 if let Some(ref metrics) = self.metrics {
2755 metrics.leader_elections_total().inc();
2756 }
2757
2758 Some((start_time, was_leader))
2759 } else {
2760 None
2761 };
2762
2763 let storage_rc = get_storage_with_fallback(db_name);
2764
2765 if let Some(storage) = storage_rc {
2766 {
2767 let result = with_storage_async!(storage, "request_leadership", |s| s
2769 .start_leader_election())
2770 .ok_or_else(|| {
2771 JsValue::from_str("Failed to acquire storage lock for leadership request")
2772 })?;
2773 result.map_err(|e| {
2774 JsValue::from_str(&format!("Failed to request leadership: {}", e))
2775 })?;
2776
2777 log::debug!("Re-election triggered for {}", db_name);
2778 } #[cfg(feature = "telemetry")]
2782 if let Some((start_time, was_leader)) = telemetry_data {
2783 if let Some(ref metrics) = self.metrics {
2784 let duration_ms = js_sys::Date::now() - start_time;
2786 metrics.leader_election_duration().observe(duration_ms);
2787
2788 let is_leader_now = self
2790 .is_leader_wasm()
2791 .await
2792 .ok()
2793 .and_then(|v| v.as_bool())
2794 .unwrap_or(false);
2795
2796 metrics
2798 .is_leader()
2799 .set(if is_leader_now { 1.0 } else { 0.0 });
2800
2801 if was_leader != is_leader_now {
2803 metrics.leadership_changes_total().inc();
2804 }
2805 }
2806 }
2807
2808 Ok(())
2809 } else {
2810 Err(JsValue::from_str(&format!(
2811 "No storage found for database: {}",
2812 db_name
2813 )))
2814 }
2815 }
2816
2817 #[wasm_bindgen(js_name = "getLeaderInfo")]
2819 pub async fn get_leader_info(&mut self) -> Result<JsValue, JsValue> {
2820 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2821
2822 let db_name = &self.name;
2823
2824 let storage_rc = get_storage_with_fallback(db_name);
2825
2826 if let Some(storage) = storage_rc {
2827 let is_leader = with_storage_async!(storage, "get_leader_info", |s| s.is_leader())
2828 .ok_or_else(|| {
2829 JsValue::from_str(&format!(
2830 "Failed to access storage for database: {}",
2831 db_name
2832 ))
2833 })?;
2834
2835 let leader_id_str = if is_leader {
2838 format!("leader_{}", db_name)
2839 } else {
2840 "unknown".to_string()
2841 };
2842
2843 let obj = js_sys::Object::new();
2845 js_sys::Reflect::set(&obj, &"isLeader".into(), &JsValue::from_bool(is_leader))?;
2846 js_sys::Reflect::set(&obj, &"leaderId".into(), &JsValue::from_str(&leader_id_str))?;
2847 js_sys::Reflect::set(
2848 &obj,
2849 &"leaseExpiry".into(),
2850 &JsValue::from_f64(js_sys::Date::now()),
2851 )?;
2852
2853 Ok(obj.into())
2854 } else {
2855 Err(JsValue::from_str(&format!(
2856 "No storage found for database: {}",
2857 db_name
2858 )))
2859 }
2860 }
2861
2862 #[wasm_bindgen(js_name = "queueWrite")]
2873 pub async fn queue_write(&mut self, sql: String) -> Result<(), JsValue> {
2874 self.queue_write_with_timeout(sql, 5000).await
2875 }
2876
2877 #[wasm_bindgen(js_name = "queueWriteWithTimeout")]
2883 pub async fn queue_write_with_timeout(
2884 &mut self,
2885 sql: String,
2886 timeout_ms: u32,
2887 ) -> Result<(), JsValue> {
2888 use crate::storage::write_queue::{WriteQueueMessage, WriteResponse, send_write_request};
2889 use std::cell::RefCell;
2890 use std::rc::Rc;
2891
2892 log::debug!("Queuing write: {}", sql);
2893
2894 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2896 let is_leader = {
2897 let storage_rc = get_storage_with_fallback(&self.name);
2898
2899 if let Some(storage) = storage_rc {
2900 with_storage_async!(storage, "queue_write_is_leader", |s| s.is_leader())
2901 .unwrap_or(false)
2902 } else {
2903 false
2904 }
2905 };
2906
2907 if is_leader {
2908 log::debug!("We are leader, executing directly");
2909 return self
2910 .execute_internal(&sql)
2911 .await
2912 .map(|_| ())
2913 .map_err(|e| JsValue::from_str(&format!("Execute failed: {}", e)));
2914 }
2915
2916 let request_id = send_write_request(&self.name, &sql)
2918 .map_err(|e| JsValue::from_str(&format!("Failed to send write request: {}", e)))?;
2919
2920 log::debug!("Write request sent with ID: {}", request_id);
2921
2922 let response_received = Rc::new(RefCell::new(false));
2924 let response_error = Rc::new(RefCell::new(None::<String>));
2925
2926 let response_received_clone = response_received.clone();
2927 let response_error_clone = response_error.clone();
2928 let request_id_clone = request_id.clone();
2929
2930 let callback = Closure::wrap(Box::new(move |msg: JsValue| {
2932 if let Ok(json_str) = js_sys::JSON::stringify(&msg) {
2934 if let Some(json_str) = json_str.as_string() {
2935 if let Ok(message) = serde_json::from_str::<WriteQueueMessage>(&json_str) {
2936 if let WriteQueueMessage::WriteResponse(response) = message {
2937 match response {
2938 WriteResponse::Success { request_id, .. } => {
2939 if request_id == request_id_clone {
2940 *response_received_clone.borrow_mut() = true;
2941 log::debug!("Write response received: Success");
2942 }
2943 }
2944 WriteResponse::Error {
2945 request_id,
2946 error_message,
2947 } => {
2948 if request_id == request_id_clone {
2949 *response_received_clone.borrow_mut() = true;
2950 *response_error_clone.borrow_mut() = Some(error_message);
2951 log::debug!("Write response received: Error");
2952 }
2953 }
2954 }
2955 }
2956 }
2957 }
2958 }
2959 }) as Box<dyn FnMut(JsValue)>);
2960
2961 use crate::storage::write_queue::register_write_queue_listener;
2963 let callback_fn = callback.as_ref().unchecked_ref();
2964 register_write_queue_listener(&self.name, callback_fn)
2965 .map_err(|e| JsValue::from_str(&format!("Failed to register listener: {}", e)))?;
2966
2967 callback.forget();
2969
2970 let start_time = js_sys::Date::now();
2972 let timeout_f64 = timeout_ms as f64;
2973
2974 loop {
2975 if *response_received.borrow() {
2977 if let Some(error_msg) = response_error.borrow().as_ref() {
2978 return Err(JsValue::from_str(&format!("Write failed: {}", error_msg)));
2979 }
2980 log::info!("Write completed successfully");
2981 return Ok(());
2982 }
2983
2984 let elapsed = js_sys::Date::now() - start_time;
2986 if elapsed > timeout_f64 {
2987 return Err(JsValue::from_str("Write request timed out"));
2988 }
2989
2990 wasm_bindgen_futures::JsFuture::from(js_sys::Promise::new(&mut |resolve, _reject| {
2992 if let Some(window) = web_sys::window() {
2993 let _ =
2994 window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, 100);
2995 } else {
2996 log::error!("Window unavailable in timeout handler");
2997 }
2998 }))
2999 .await
3000 .ok();
3001 }
3002 }
3003
3004 #[wasm_bindgen(js_name = "isLeader")]
3005 pub async fn is_leader_wasm(&self) -> Result<JsValue, JsValue> {
3006 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
3008
3009 let db_name = &self.name;
3010 log::debug!("isLeader() called for database: {} (self.name)", db_name);
3011
3012 let storage_rc = get_storage_with_fallback(db_name);
3013
3014 if let Some(storage) = storage_rc {
3015 log::debug!("Found storage for {}, calling is_leader()", db_name);
3016 let is_leader = with_storage_async!(storage, "is_leader_wasm", |s| s.is_leader())
3017 .ok_or_else(|| {
3018 JsValue::from_str(&format!(
3019 "Failed to access storage for database: {}",
3020 db_name
3021 ))
3022 })?;
3023 log::debug!("is_leader() = {} for {}", is_leader, db_name);
3024
3025 Ok(JsValue::from_bool(is_leader))
3027 } else {
3028 log::error!("ERROR: No storage found for database: {}", db_name);
3029 Err(JsValue::from_str(&format!(
3030 "No storage found for database: {}",
3031 db_name
3032 )))
3033 }
3034 }
3035
3036 pub async fn is_leader(&self) -> Result<bool, JsValue> {
3038 let result = self.is_leader_wasm().await?;
3039 Ok(result.as_bool().unwrap_or(false))
3040 }
3041
3042 #[wasm_bindgen(js_name = "onDataChange")]
3043 pub fn on_data_change_wasm(&mut self, callback: &js_sys::Function) -> Result<(), JsValue> {
3044 log::debug!("Registering onDataChange callback for {}", self.name);
3045
3046 self.on_data_change_callback = Some(callback.clone());
3048
3049 use crate::storage::broadcast_notifications::register_change_listener;
3051
3052 let db_name = &self.name;
3053 register_change_listener(db_name, callback).map_err(|e| {
3054 JsValue::from_str(&format!("Failed to register change listener: {}", e))
3055 })?;
3056
3057 log::debug!("onDataChange callback registered for {}", self.name);
3058 Ok(())
3059 }
3060
3061 #[wasm_bindgen(js_name = "reloadFromIndexedDB")]
3065 pub async fn reload_from_indexed_db(&mut self) -> Result<(), JsValue> {
3066 log::info!("Reloading data from IndexedDB for {}", self.name);
3067
3068 let db_name = self.name.clone();
3069
3070 let pool_key = db_name.trim_end_matches(".db");
3072 crate::connection_pool::force_close_connection(pool_key);
3073 self.connection_state.db.set(std::ptr::null_mut());
3074 log::info!("[RELOAD] Closed SQLite connection for {}", db_name);
3075
3076 crate::storage::wasm_indexeddb::restore_from_indexeddb_force(&db_name)
3078 .await
3079 .map_err(|e| JsValue::from_str(&format!("Failed to restore from IndexedDB: {}", e)))?;
3080 log::info!("[RELOAD] Restored from IndexedDB for {}", db_name);
3081
3082 use crate::vfs::indexeddb_vfs::STORAGE_REGISTRY;
3084 STORAGE_REGISTRY.with(|reg| unsafe {
3085 let registry = &*reg.get();
3086 if let Some(storage_rc) = registry.get(&db_name) {
3087 storage_rc.reload_cache_from_global_storage();
3088 log::info!("[RELOAD] Reloaded BlockStorage cache for {}", db_name);
3089 }
3090 });
3091
3092 use std::ffi::CString;
3094
3095 let vfs_name = format!("vfs_{}", db_name.trim_end_matches(".db"));
3096 let pool_key = db_name.trim_end_matches(".db").to_string();
3097 let db_name_for_closure = db_name.clone();
3098 let vfs_name_for_closure = vfs_name.clone();
3099
3100 let new_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
3101 let mut db = std::ptr::null_mut();
3102 let db_name_cstr = CString::new(db_name_for_closure.clone())
3103 .map_err(|_| "Invalid database name".to_string())?;
3104 let vfs_cstr = CString::new(vfs_name_for_closure.as_str())
3105 .map_err(|_| "Invalid VFS name".to_string())?;
3106
3107 log::info!(
3108 "[RELOAD] Reopening database: {} with VFS: {}",
3109 db_name_for_closure,
3110 vfs_name_for_closure
3111 );
3112
3113 let ret = unsafe {
3114 sqlite_wasm_rs::sqlite3_open_v2(
3115 db_name_cstr.as_ptr(),
3116 &mut db as *mut _,
3117 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
3118 vfs_cstr.as_ptr(),
3119 )
3120 };
3121
3122 if ret != sqlite_wasm_rs::SQLITE_OK {
3123 let err_msg = unsafe {
3124 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
3125 if !msg_ptr.is_null() {
3126 std::ffi::CStr::from_ptr(msg_ptr)
3127 .to_string_lossy()
3128 .into_owned()
3129 } else {
3130 "Unknown error".to_string()
3131 }
3132 };
3133 return Err(format!("Failed to reopen database: {}", err_msg));
3134 }
3135
3136 log::info!("[RELOAD] Database reopened successfully");
3137 Ok(db)
3138 })
3139 .map_err(|e| JsValue::from_str(&format!("Failed to reopen connection: {}", e)))?;
3140
3141 self.connection_state = new_state;
3142 log::info!("[RELOAD] Connection state updated for {}", db_name);
3143
3144 Ok(())
3145 }
3146
3147 #[wasm_bindgen(js_name = "enableOptimisticUpdates")]
3149 pub async fn enable_optimistic_updates(&mut self, enabled: bool) -> Result<(), JsValue> {
3150 self.optimistic_updates_manager
3151 .borrow_mut()
3152 .set_enabled(enabled);
3153 log::debug!(
3154 "Optimistic updates {}",
3155 if enabled { "enabled" } else { "disabled" }
3156 );
3157 Ok(())
3158 }
3159
3160 #[wasm_bindgen(js_name = "isOptimisticMode")]
3162 pub async fn is_optimistic_mode(&self) -> bool {
3163 self.optimistic_updates_manager.borrow().is_enabled()
3164 }
3165
3166 #[wasm_bindgen(js_name = "trackOptimisticWrite")]
3168 pub async fn track_optimistic_write(&mut self, sql: String) -> Result<String, JsValue> {
3169 let id = self
3170 .optimistic_updates_manager
3171 .borrow_mut()
3172 .track_write(sql);
3173 Ok(id)
3174 }
3175
3176 #[wasm_bindgen(js_name = "getPendingWritesCount")]
3178 pub async fn get_pending_writes_count(&self) -> usize {
3179 self.optimistic_updates_manager.borrow().get_pending_count()
3180 }
3181
3182 #[wasm_bindgen(js_name = "clearOptimisticWrites")]
3184 pub async fn clear_optimistic_writes(&mut self) -> Result<(), JsValue> {
3185 self.optimistic_updates_manager.borrow_mut().clear_all();
3186 Ok(())
3187 }
3188
3189 #[wasm_bindgen(js_name = "enableCoordinationMetrics")]
3191 pub async fn enable_coordination_metrics(&mut self, enabled: bool) -> Result<(), JsValue> {
3192 self.coordination_metrics_manager
3193 .borrow_mut()
3194 .set_enabled(enabled);
3195 Ok(())
3196 }
3197
3198 #[wasm_bindgen(js_name = "isCoordinationMetricsEnabled")]
3200 pub async fn is_coordination_metrics_enabled(&self) -> bool {
3201 self.coordination_metrics_manager.borrow().is_enabled()
3202 }
3203
3204 #[wasm_bindgen(js_name = "recordLeadershipChange")]
3206 pub async fn record_leadership_change(&mut self, became_leader: bool) -> Result<(), JsValue> {
3207 self.coordination_metrics_manager
3208 .borrow_mut()
3209 .record_leadership_change(became_leader);
3210 Ok(())
3211 }
3212
3213 #[wasm_bindgen(js_name = "recordNotificationLatency")]
3215 pub async fn record_notification_latency(&mut self, latency_ms: f64) -> Result<(), JsValue> {
3216 self.coordination_metrics_manager
3217 .borrow_mut()
3218 .record_notification_latency(latency_ms);
3219 Ok(())
3220 }
3221
3222 #[wasm_bindgen(js_name = "recordWriteConflict")]
3224 pub async fn record_write_conflict(&mut self) -> Result<(), JsValue> {
3225 self.coordination_metrics_manager
3226 .borrow_mut()
3227 .record_write_conflict();
3228 Ok(())
3229 }
3230
3231 #[wasm_bindgen(js_name = "recordFollowerRefresh")]
3233 pub async fn record_follower_refresh(&mut self) -> Result<(), JsValue> {
3234 self.coordination_metrics_manager
3235 .borrow_mut()
3236 .record_follower_refresh();
3237 Ok(())
3238 }
3239
3240 #[wasm_bindgen(js_name = "getCoordinationMetrics")]
3242 pub async fn get_coordination_metrics(&self) -> Result<String, JsValue> {
3243 self.coordination_metrics_manager
3244 .borrow()
3245 .get_metrics_json()
3246 .map_err(|e| JsValue::from_str(&e))
3247 }
3248
3249 #[wasm_bindgen(js_name = "resetCoordinationMetrics")]
3251 pub async fn reset_coordination_metrics(&mut self) -> Result<(), JsValue> {
3252 self.coordination_metrics_manager.borrow_mut().reset();
3253 Ok(())
3254 }
3255}
3256
3257#[cfg(target_arch = "wasm32")]
3259#[wasm_bindgen]
3260pub struct WasmColumnValue {
3261 #[allow(dead_code)]
3262 inner: ColumnValue,
3263}
3264
3265#[cfg(target_arch = "wasm32")]
3266#[wasm_bindgen]
3267impl WasmColumnValue {
3268 #[wasm_bindgen(js_name = "createNull")]
3269 pub fn create_null() -> WasmColumnValue {
3270 WasmColumnValue {
3271 inner: ColumnValue::Null,
3272 }
3273 }
3274
3275 #[wasm_bindgen(js_name = "createInteger")]
3276 pub fn create_integer(value: i64) -> WasmColumnValue {
3277 WasmColumnValue {
3278 inner: ColumnValue::Integer(value),
3279 }
3280 }
3281
3282 #[wasm_bindgen(js_name = "createReal")]
3283 pub fn create_real(value: f64) -> WasmColumnValue {
3284 WasmColumnValue {
3285 inner: ColumnValue::Real(value),
3286 }
3287 }
3288
3289 #[wasm_bindgen(js_name = "createText")]
3290 pub fn create_text(value: String) -> WasmColumnValue {
3291 WasmColumnValue {
3292 inner: ColumnValue::Text(value),
3293 }
3294 }
3295
3296 #[wasm_bindgen(js_name = "createBlob")]
3297 pub fn create_blob(value: &[u8]) -> WasmColumnValue {
3298 WasmColumnValue {
3299 inner: ColumnValue::Blob(value.to_vec()),
3300 }
3301 }
3302
3303 #[wasm_bindgen(js_name = "createBigInt")]
3304 pub fn create_bigint(value: &str) -> WasmColumnValue {
3305 WasmColumnValue {
3306 inner: ColumnValue::BigInt(value.to_string()),
3307 }
3308 }
3309
3310 #[wasm_bindgen(js_name = "createDate")]
3311 pub fn create_date(timestamp: f64) -> WasmColumnValue {
3312 WasmColumnValue {
3313 inner: ColumnValue::Date(timestamp as i64),
3314 }
3315 }
3316
3317 #[wasm_bindgen(js_name = "fromJsValue")]
3318 pub fn from_js_value(value: &JsValue) -> WasmColumnValue {
3319 if value.is_null() || value.is_undefined() {
3320 WasmColumnValue {
3321 inner: ColumnValue::Null,
3322 }
3323 } else if let Some(s) = value.as_string() {
3324 if let Ok(parsed) = s.parse::<i64>() {
3326 WasmColumnValue {
3327 inner: ColumnValue::Integer(parsed),
3328 }
3329 } else {
3330 WasmColumnValue {
3331 inner: ColumnValue::Text(s),
3332 }
3333 }
3334 } else if let Some(n) = value.as_f64() {
3335 if n.fract() == 0.0 && n >= i64::MIN as f64 && n <= i64::MAX as f64 {
3336 WasmColumnValue {
3337 inner: ColumnValue::Integer(n as i64),
3338 }
3339 } else {
3340 WasmColumnValue {
3341 inner: ColumnValue::Real(n),
3342 }
3343 }
3344 } else if value.is_object() {
3345 if js_sys::Date::new(value).get_time().is_finite() {
3347 let timestamp = js_sys::Date::new(value).get_time() as i64;
3348 WasmColumnValue {
3349 inner: ColumnValue::Date(timestamp),
3350 }
3351 } else {
3352 WasmColumnValue {
3354 inner: ColumnValue::Text(format!("{:?}", value)),
3355 }
3356 }
3357 } else {
3358 WasmColumnValue {
3359 inner: ColumnValue::Null,
3360 }
3361 }
3362 }
3363
3364 pub fn null() -> WasmColumnValue {
3368 Self::create_null()
3369 }
3370
3371 pub fn integer(value: f64) -> WasmColumnValue {
3373 Self::create_integer(value as i64)
3374 }
3375
3376 pub fn real(value: f64) -> WasmColumnValue {
3377 Self::create_real(value)
3378 }
3379
3380 pub fn text(value: String) -> WasmColumnValue {
3381 Self::create_text(value)
3382 }
3383
3384 pub fn blob(value: Vec<u8>) -> WasmColumnValue {
3385 Self::create_blob(&value)
3386 }
3387
3388 pub fn big_int(value: String) -> WasmColumnValue {
3389 Self::create_bigint(&value)
3390 }
3391
3392 pub fn date(timestamp_ms: f64) -> WasmColumnValue {
3393 Self::create_date(timestamp_ms)
3394 }
3395}