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 pub async fn new(config: DatabaseConfig) -> Result<Self, DatabaseError> {
195 use std::ffi::{CStr, CString};
196
197 log::info!("Database::new called for {}", config.name);
198
199 let normalized_name = normalize_db_name(&config.name);
202
203 let vfs_name = format!("vfs_{}", normalized_name.trim_end_matches(".db"));
205 let vfs_name_cstr = CString::new(vfs_name.as_str())
206 .map_err(|_| DatabaseError::new("INVALID_VFS_NAME", "Invalid VFS name"))?;
207 let vfs_exists = unsafe {
208 let existing_vfs = sqlite_wasm_rs::sqlite3_vfs_find(vfs_name_cstr.as_ptr());
209 !existing_vfs.is_null()
210 };
211
212 if !vfs_exists {
213 log::debug!("Creating IndexedDBVFS for: {}", normalized_name);
215 let vfs = crate::vfs::IndexedDBVFS::new(&normalized_name).await?;
216 log::debug!("Registering VFS as '{}'", vfs_name);
217 vfs.register(&vfs_name)?;
218 log::info!("VFS registered successfully");
219 } else {
220 log::info!("VFS '{}' already registered, reusing existing", vfs_name);
221 let _vfs = crate::vfs::IndexedDBVFS::new(&normalized_name).await?;
224 log::info!("BlockStorage ensured for {}", normalized_name);
225 }
226
227 #[cfg(target_arch = "wasm32")]
230 {
231 const MAX_OPEN_WAIT_MS: u32 = 1000; const OPEN_POLL_MS: u32 = 10;
233 let max_open_attempts = MAX_OPEN_WAIT_MS / OPEN_POLL_MS;
234
235 for attempt in 0..max_open_attempts {
236 let can_open = DB_OPEN_IN_PROGRESS.with(|opens| {
237 let mut set = opens.borrow_mut();
238 if set.contains(&config.name) {
239 false } else {
241 set.insert(config.name.clone());
242 true }
244 });
245
246 if can_open {
247 web_sys::console::log_1(
248 &format!("[DB] {} - ACQUIRED sqlite open lock", config.name).into(),
249 );
250 break;
251 } else {
252 web_sys::console::log_1(
253 &format!(
254 "[DB] {} - Waiting for sqlite open (attempt {})",
255 config.name, attempt
256 )
257 .into(),
258 );
259 use wasm_bindgen_futures::JsFuture;
260 let promise = js_sys::Promise::new(&mut |resolve, _| {
261 web_sys::window()
262 .unwrap()
263 .set_timeout_with_callback_and_timeout_and_arguments_0(
264 &resolve,
265 OPEN_POLL_MS as i32,
266 )
267 .unwrap();
268 });
269 JsFuture::from(promise).await.ok();
270 continue;
271 }
272 }
273 }
274
275 let (connection_state, db) = {
277 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, || {
281 let mut db = std::ptr::null_mut();
282 let db_name = CString::new(normalized_name.clone())
283 .map_err(|_| "Invalid database name".to_string())?;
284 let vfs_cstr = CString::new(vfs_name_str.as_str())
285 .map_err(|_| "Invalid VFS name".to_string())?;
286
287 log::info!(
288 "Opening database: {} with VFS: {}",
289 filename_copy,
290 vfs_name_str
291 );
292
293 #[cfg(target_arch = "wasm32")]
294 web_sys::console::log_1(&format!("[OPEN] About to call sqlite3_open_v2...").into());
295
296 let ret = unsafe {
297 sqlite_wasm_rs::sqlite3_open_v2(
298 db_name.as_ptr(),
299 &mut db as *mut _,
300 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
301 vfs_cstr.as_ptr(),
302 )
303 };
304
305 #[cfg(target_arch = "wasm32")]
306 web_sys::console::log_1(
307 &format!("[OPEN] sqlite3_open_v2 returned: {}", ret).into(),
308 );
309
310 log::info!(
311 "sqlite3_open_v2 returned: {} for database: {}",
312 ret,
313 filename_copy
314 );
315
316 if ret != sqlite_wasm_rs::SQLITE_OK {
317 let err_msg = unsafe {
318 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
319 if !msg_ptr.is_null() {
320 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
321 } else {
322 "Unknown error".to_string()
323 }
324 };
325
326 #[cfg(target_arch = "wasm32")]
327 web_sys::console::log_1(
328 &format!(
329 "[OPEN] ERROR - sqlite3_open_v2 FAILED: ret={}, err={}",
330 ret, err_msg
331 )
332 .into(),
333 );
334
335 return Err(format!(
336 "Failed to open database with IndexedDB VFS: {}",
337 err_msg
338 ));
339 }
340
341 log::info!("Database opened successfully with IndexedDB VFS");
342 Ok(db)
343 })
344 .map_err(|e| DatabaseError::new("CONNECTION_POOL_ERROR", &e))?;
345 let db_ptr = state.db.get();
346 (state, db_ptr)
347 };
348
349 let exec_sql = |db: *mut sqlite_wasm_rs::sqlite3, sql: &str| -> Result<(), DatabaseError> {
351 let c_sql = CString::new(sql)
352 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL statement"))?;
353
354 let ret = unsafe {
355 sqlite_wasm_rs::sqlite3_exec(
356 db,
357 c_sql.as_ptr(),
358 None,
359 std::ptr::null_mut(),
360 std::ptr::null_mut(),
361 )
362 };
363
364 if ret != sqlite_wasm_rs::SQLITE_OK {
365 let err_msg = unsafe {
366 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
367 if !msg_ptr.is_null() {
368 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
369 } else {
370 "Unknown error".to_string()
371 }
372 };
373 log::warn!("Failed to execute SQL '{}': {}", sql, err_msg);
374 return Err(DatabaseError::new(
375 "SQLITE_ERROR",
376 &format!("Failed to execute: {}", err_msg),
377 ));
378 }
379 Ok(())
380 };
381
382 log::debug!("Setting busy_timeout to 10000ms for concurrent access handling");
386 exec_sql(db, "PRAGMA busy_timeout = 10000")?;
387
388 if let Some(page_size) = config.page_size {
390 log::debug!("Setting page_size to {}", page_size);
391 exec_sql(db, &format!("PRAGMA page_size = {}", page_size))?;
392 }
393
394 if let Some(cache_size) = config.cache_size {
396 log::debug!("Setting cache_size to {}", cache_size);
397 exec_sql(db, &format!("PRAGMA cache_size = {}", cache_size))?;
398 }
399
400 if let Some(ref journal_mode) = config.journal_mode {
403 log::debug!("Setting journal_mode to {}", journal_mode);
404
405 let pragma_sql = format!("PRAGMA journal_mode = {}", journal_mode);
406 let c_sql = CString::new(pragma_sql.as_str())
407 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL statement"))?;
408
409 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
410 let ret = unsafe {
411 sqlite_wasm_rs::sqlite3_prepare_v2(
412 db,
413 c_sql.as_ptr(),
414 -1,
415 &mut stmt as *mut _,
416 std::ptr::null_mut(),
417 )
418 };
419
420 if ret == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
421 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
422 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
423 let result_ptr = unsafe { sqlite_wasm_rs::sqlite3_column_text(stmt, 0) };
424 if !result_ptr.is_null() {
425 let result_mode = unsafe {
426 std::ffi::CStr::from_ptr(result_ptr as *const i8)
427 .to_string_lossy()
428 .to_uppercase()
429 };
430
431 if result_mode != journal_mode.to_uppercase() {
432 log::warn!(
433 "journal_mode {} requested but SQLite set {}",
434 journal_mode,
435 result_mode
436 );
437 } else {
438 log::info!("journal_mode successfully set to {}", result_mode);
439 }
440 }
441 }
442 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
443 } else {
444 log::warn!("Failed to prepare journal_mode PRAGMA");
445 }
446 }
447
448 if let Some(auto_vacuum) = config.auto_vacuum {
450 let vacuum_mode = if auto_vacuum { 1 } else { 0 }; log::debug!("Setting auto_vacuum to {}", vacuum_mode);
452 exec_sql(db, &format!("PRAGMA auto_vacuum = {}", vacuum_mode))?;
453 }
454
455 log::info!("Database configuration applied successfully");
456
457 #[cfg(feature = "telemetry")]
459 let metrics = crate::telemetry::Metrics::new().map_err(|e| {
460 DatabaseError::new(
461 "METRICS_ERROR",
462 &format!("Failed to initialize metrics: {}", e),
463 )
464 })?;
465
466 let database = Database {
467 connection_state,
468 name: normalized_name.clone(), on_data_change_callback: None,
470 allow_non_leader_writes: false,
471 optimistic_updates_manager: std::cell::RefCell::new(
472 crate::storage::optimistic_updates::OptimisticUpdatesManager::new(),
473 ),
474 coordination_metrics_manager: std::cell::RefCell::new(
475 crate::storage::coordination_metrics::CoordinationMetricsManager::new(),
476 ),
477 #[cfg(feature = "telemetry")]
478 metrics: Some(metrics),
479 #[cfg(feature = "telemetry")]
480 span_recorder: None,
481 #[cfg(feature = "telemetry")]
482 span_context: Some(crate::telemetry::SpanContext::new()),
483 max_export_size_bytes: config.max_export_size_bytes,
484 };
485
486 #[cfg(target_arch = "wasm32")]
489 {
490 DB_OPEN_IN_PROGRESS.with(|opens| {
491 opens.borrow_mut().remove(&config.name);
492 });
493 web_sys::console::log_1(
494 &format!("[DB] {} - RELEASED sqlite open lock", config.name).into(),
495 );
496 }
497
498 Ok(database)
499 }
500
501 pub async fn open_with_vfs(filename: &str, vfs_name: &str) -> Result<Self, DatabaseError> {
503 use std::ffi::CString;
504
505 log::info!("Opening database {} with VFS {}", filename, vfs_name);
506
507 let normalized_name = normalize_db_name(filename);
509 let pool_key = normalized_name.trim_end_matches(".db").to_string();
510
511 let connection_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
513 let mut db: *mut sqlite_wasm_rs::sqlite3 = std::ptr::null_mut();
514 let db_name = CString::new(normalized_name.clone())
515 .map_err(|_| "Invalid database name".to_string())?;
516 let vfs_cstr = CString::new(vfs_name).map_err(|_| "Invalid VFS name".to_string())?;
517
518 let ret = unsafe {
519 sqlite_wasm_rs::sqlite3_open_v2(
520 db_name.as_ptr(),
521 &mut db as *mut _,
522 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
523 vfs_cstr.as_ptr(),
524 )
525 };
526
527 if ret != sqlite_wasm_rs::SQLITE_OK {
528 let err_msg = if !db.is_null() {
529 unsafe {
530 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
531 if !msg_ptr.is_null() {
532 std::ffi::CStr::from_ptr(msg_ptr)
533 .to_string_lossy()
534 .into_owned()
535 } else {
536 "Unknown error".to_string()
537 }
538 }
539 } else {
540 "Failed to open database".to_string()
541 };
542 return Err(format!("SQLITE_ERROR: {}", err_msg));
543 }
544
545 Ok(db)
546 })
547 .map_err(|e| DatabaseError::new("OPEN_ERROR", &e))?;
548
549 log::info!(
550 "Successfully opened database {} with VFS {}",
551 normalized_name,
552 vfs_name
553 );
554
555 #[cfg(feature = "telemetry")]
557 let metrics = crate::telemetry::Metrics::new().map_err(|e| {
558 DatabaseError::new(
559 "METRICS_ERROR",
560 &format!("Failed to initialize metrics: {}", e),
561 )
562 })?;
563
564 Ok(Database {
565 connection_state,
566 name: normalized_name, on_data_change_callback: None,
568 allow_non_leader_writes: false,
569 optimistic_updates_manager: std::cell::RefCell::new(
570 crate::storage::optimistic_updates::OptimisticUpdatesManager::new(),
571 ),
572 coordination_metrics_manager: std::cell::RefCell::new(
573 crate::storage::coordination_metrics::CoordinationMetricsManager::new(),
574 ),
575 #[cfg(feature = "telemetry")]
576 metrics: Some(metrics),
577 #[cfg(feature = "telemetry")]
578 span_recorder: None,
579 #[cfg(feature = "telemetry")]
580 span_context: Some(crate::telemetry::SpanContext::new()),
581 max_export_size_bytes: Some(2 * 1024 * 1024 * 1024), })
583 }
584
585 pub async fn execute_internal(&mut self, sql: &str) -> Result<QueryResult, DatabaseError> {
586 use std::ffi::{CStr, CString};
587 let start_time = js_sys::Date::now();
588
589 #[cfg(feature = "telemetry")]
591 let span = if self.span_recorder.is_some() {
592 let query_type = sql
593 .trim()
594 .split_whitespace()
595 .next()
596 .unwrap_or("UNKNOWN")
597 .to_uppercase();
598 let mut builder = crate::telemetry::SpanBuilder::new("execute_query".to_string())
599 .with_attribute("query_type", query_type.clone())
600 .with_attribute("sql", sql.to_string());
601
602 if let Some(ref context) = self.span_context {
604 builder = builder.with_baggage_from_context(context);
605 }
606
607 let span = builder.build();
608
609 if let Some(ref context) = self.span_context {
611 context.enter_span(span.span_id.clone());
612 }
613
614 Some(span)
615 } else {
616 None
617 };
618
619 #[cfg(feature = "telemetry")]
621 #[cfg(feature = "telemetry")]
622 if let Some(metrics) = &self.metrics {
623 metrics.queries_total().inc();
624 }
625
626 if self.db().is_null() {
628 return Err(DatabaseError::new(
629 "NULL_CONNECTION",
630 "Database connection is null",
631 ));
632 }
633
634 let sql_cstr = CString::new(sql)
635 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL string"))?;
636
637 if sql.trim().to_uppercase().starts_with("SELECT") {
638 let mut stmt = std::ptr::null_mut();
639 let ret = unsafe {
640 sqlite_wasm_rs::sqlite3_prepare_v2(
641 self.db(),
642 sql_cstr.as_ptr(),
643 -1,
644 &mut stmt,
645 std::ptr::null_mut(),
646 )
647 };
648
649 if ret != sqlite_wasm_rs::SQLITE_OK {
650 let err_msg = unsafe {
652 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
653 if !msg_ptr.is_null() {
654 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
655 } else {
656 format!("Unknown error (code: {})", ret)
657 }
658 };
659
660 #[cfg(feature = "telemetry")]
662 #[cfg(feature = "telemetry")]
663 if let Some(metrics) = &self.metrics {
664 metrics.errors_total().inc();
665 }
666
667 #[cfg(feature = "telemetry")]
669 if let Some(mut s) = span {
670 s.status = crate::telemetry::SpanStatus::Error(format!(
671 "Failed to prepare: {}",
672 err_msg
673 ));
674 s.end_time_ms = Some(js_sys::Date::now());
675 if let Some(recorder) = &self.span_recorder {
676 recorder.record_span(s);
677 }
678
679 if let Some(ref context) = self.span_context {
681 context.exit_span();
682 }
683 }
684
685 return Err(DatabaseError::new(
686 "SQLITE_ERROR",
687 &format!("Failed to prepare statement: {}", err_msg),
688 )
689 .with_sql(sql));
690 }
691
692 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
693 let mut columns = Vec::new();
694 let mut rows = Vec::new();
695
696 for i in 0..column_count {
698 let col_name = unsafe {
699 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
700 if name_ptr.is_null() {
701 format!("col_{}", i)
702 } else {
703 std::ffi::CStr::from_ptr(name_ptr)
704 .to_string_lossy()
705 .into_owned()
706 }
707 };
708 columns.push(col_name);
709 }
710
711 loop {
713 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
714 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
715 let mut values = Vec::new();
716 for i in 0..column_count {
717 let value = unsafe {
718 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
719 match col_type {
720 sqlite_wasm_rs::SQLITE_NULL => ColumnValue::Null,
721 sqlite_wasm_rs::SQLITE_INTEGER => {
722 let val = sqlite_wasm_rs::sqlite3_column_int64(stmt, i);
723 ColumnValue::Integer(val)
724 }
725 sqlite_wasm_rs::SQLITE_FLOAT => {
726 let val = sqlite_wasm_rs::sqlite3_column_double(stmt, i);
727 ColumnValue::Real(val)
728 }
729 sqlite_wasm_rs::SQLITE_TEXT => {
730 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
731 if text_ptr.is_null() {
732 ColumnValue::Null
733 } else {
734 let text = std::ffi::CStr::from_ptr(text_ptr as *const i8)
735 .to_string_lossy()
736 .into_owned();
737 ColumnValue::Text(text)
738 }
739 }
740 sqlite_wasm_rs::SQLITE_BLOB => {
741 let blob_ptr = sqlite_wasm_rs::sqlite3_column_blob(stmt, i);
742 let blob_size = sqlite_wasm_rs::sqlite3_column_bytes(stmt, i);
743 if blob_ptr.is_null() || blob_size == 0 {
744 ColumnValue::Blob(vec![])
745 } else {
746 let blob_slice = std::slice::from_raw_parts(
747 blob_ptr as *const u8,
748 blob_size as usize,
749 );
750 ColumnValue::Blob(blob_slice.to_vec())
751 }
752 }
753 _ => ColumnValue::Null,
754 }
755 };
756 values.push(value);
757 }
758 rows.push(Row { values });
759 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
760 break;
761 } else {
762 let err_msg = unsafe {
764 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
765 if !err_ptr.is_null() {
766 std::ffi::CStr::from_ptr(err_ptr)
767 .to_string_lossy()
768 .to_string()
769 } else {
770 "Unknown SQLite error".to_string()
771 }
772 };
773 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
774 #[cfg(feature = "telemetry")]
776 if let Some(metrics) = &self.metrics {
777 metrics.errors_total().inc();
778 }
779 return Err(DatabaseError::new(
780 "SQLITE_ERROR",
781 &format!("Error executing SELECT statement: {}", err_msg),
782 )
783 .with_sql(sql));
784 }
785 }
786
787 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
788 let execution_time_ms = js_sys::Date::now() - start_time;
789
790 #[cfg(feature = "telemetry")]
792 if let Some(metrics) = &self.metrics {
793 metrics.query_duration().observe(execution_time_ms);
794 }
795
796 Ok(QueryResult {
797 columns,
798 rows,
799 affected_rows: 0,
800 last_insert_id: None,
801 execution_time_ms,
802 })
803 } else {
804 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
806 let ret = unsafe {
807 sqlite_wasm_rs::sqlite3_prepare_v2(
808 self.db(),
809 sql_cstr.as_ptr(),
810 -1,
811 &mut stmt,
812 std::ptr::null_mut(),
813 )
814 };
815
816 if ret != sqlite_wasm_rs::SQLITE_OK {
817 let err_msg = unsafe {
819 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
820 if !msg_ptr.is_null() {
821 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
822 } else {
823 format!("Unknown error (code: {})", ret)
824 }
825 };
826
827 #[cfg(feature = "telemetry")]
829 if let Some(metrics) = &self.metrics {
830 metrics.errors_total().inc();
831 }
832 return Err(DatabaseError::new(
833 "SQLITE_ERROR",
834 &format!("Failed to prepare statement: {}", err_msg),
835 )
836 .with_sql(sql));
837 }
838
839 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
841 let mut columns = Vec::new();
842 let mut rows = Vec::new();
843
844 if column_count > 0 {
845 for i in 0..column_count {
847 let col_name = unsafe {
848 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
849 if name_ptr.is_null() {
850 format!("column_{}", i)
851 } else {
852 std::ffi::CStr::from_ptr(name_ptr)
853 .to_string_lossy()
854 .into_owned()
855 }
856 };
857 columns.push(col_name);
858 }
859
860 loop {
862 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
863 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
864 let mut values = Vec::new();
865 for i in 0..column_count {
866 let value = unsafe {
867 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
868 match col_type {
869 sqlite_wasm_rs::SQLITE_TEXT => {
870 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
871 if text_ptr.is_null() {
872 ColumnValue::Null
873 } else {
874 let text =
875 std::ffi::CStr::from_ptr(text_ptr as *const i8)
876 .to_string_lossy()
877 .into_owned();
878 ColumnValue::Text(text)
879 }
880 }
881 sqlite_wasm_rs::SQLITE_INTEGER => ColumnValue::Integer(
882 sqlite_wasm_rs::sqlite3_column_int64(stmt, i),
883 ),
884 _ => ColumnValue::Null,
885 }
886 };
887 values.push(value);
888 }
889 rows.push(Row { values });
890 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
891 break;
892 } else {
893 let err_msg = unsafe {
895 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
896 if !err_ptr.is_null() {
897 std::ffi::CStr::from_ptr(err_ptr)
898 .to_string_lossy()
899 .to_string()
900 } else {
901 "Unknown SQLite error".to_string()
902 }
903 };
904 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
905 #[cfg(feature = "telemetry")]
907 if let Some(metrics) = &self.metrics {
908 metrics.errors_total().inc();
909 }
910 return Err(DatabaseError::new(
911 "SQLITE_ERROR",
912 &format!("Failed to execute statement: {}", err_msg),
913 )
914 .with_sql(sql));
915 }
916 }
917 } else {
918 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
920 if step_ret != sqlite_wasm_rs::SQLITE_DONE {
921 let err_msg = unsafe {
923 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
924 if !err_ptr.is_null() {
925 std::ffi::CStr::from_ptr(err_ptr)
926 .to_string_lossy()
927 .to_string()
928 } else {
929 "Unknown SQLite error".to_string()
930 }
931 };
932 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
933 #[cfg(feature = "telemetry")]
935 if let Some(metrics) = &self.metrics {
936 metrics.errors_total().inc();
937 }
938 return Err(DatabaseError::new(
939 "SQLITE_ERROR",
940 &format!("Failed to execute statement: {}", err_msg),
941 )
942 .with_sql(sql));
943 }
944 }
945
946 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
948
949 let affected_rows = unsafe { sqlite_wasm_rs::sqlite3_changes(self.db()) } as u32;
950 let last_insert_id = if sql.trim().to_uppercase().starts_with("INSERT") {
951 Some(unsafe { sqlite_wasm_rs::sqlite3_last_insert_rowid(self.db()) })
952 } else {
953 None
954 };
955
956 let execution_time_ms = js_sys::Date::now() - start_time;
957
958 #[cfg(feature = "telemetry")]
960 if let Some(metrics) = &self.metrics {
961 metrics.query_duration().observe(execution_time_ms);
962 }
963
964 #[cfg(feature = "telemetry")]
966 if let Some(mut s) = span {
967 s.status = crate::telemetry::SpanStatus::Ok;
968 s.end_time_ms = Some(js_sys::Date::now());
969 s.attributes
970 .insert("duration_ms".to_string(), execution_time_ms.to_string());
971 s.attributes
972 .insert("affected_rows".to_string(), affected_rows.to_string());
973 s.attributes
974 .insert("row_count".to_string(), rows.len().to_string());
975 if let Some(recorder) = &self.span_recorder {
976 recorder.record_span(s);
977 }
978
979 if let Some(ref context) = self.span_context {
981 context.exit_span();
982 }
983 }
984
985 Ok(QueryResult {
986 columns,
987 rows,
988 affected_rows,
989 last_insert_id,
990 execution_time_ms,
991 })
992 }
993 }
994
995 pub async fn execute_with_params_internal(
996 &mut self,
997 sql: &str,
998 params: &[ColumnValue],
999 ) -> Result<QueryResult, DatabaseError> {
1000 use std::ffi::{CStr, CString};
1001 let start_time = js_sys::Date::now();
1002
1003 #[cfg(feature = "telemetry")]
1005 let span = if self.span_recorder.is_some() {
1006 let query_type = sql
1007 .trim()
1008 .split_whitespace()
1009 .next()
1010 .unwrap_or("UNKNOWN")
1011 .to_uppercase();
1012 let span = crate::telemetry::SpanBuilder::new("execute_query".to_string())
1013 .with_attribute("query_type", query_type.clone())
1014 .with_attribute("sql", sql.to_string())
1015 .build();
1016 Some(span)
1017 } else {
1018 None
1019 };
1020
1021 #[cfg(feature = "telemetry")]
1023 self.ensure_metrics_propagated();
1024
1025 #[cfg(feature = "telemetry")]
1027 if let Some(metrics) = &self.metrics {
1028 metrics.queries_total().inc();
1029 }
1030
1031 let sql_cstr = CString::new(sql)
1032 .map_err(|_| DatabaseError::new("INVALID_SQL", "Invalid SQL string"))?;
1033
1034 let mut stmt = std::ptr::null_mut();
1035 let ret = unsafe {
1036 sqlite_wasm_rs::sqlite3_prepare_v2(
1037 self.db(),
1038 sql_cstr.as_ptr(),
1039 -1,
1040 &mut stmt,
1041 std::ptr::null_mut(),
1042 )
1043 };
1044
1045 if ret != sqlite_wasm_rs::SQLITE_OK {
1046 let err_msg = unsafe {
1048 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1049 if !msg_ptr.is_null() {
1050 CStr::from_ptr(msg_ptr).to_string_lossy().into_owned()
1051 } else {
1052 format!("Unknown error (code: {})", ret)
1053 }
1054 };
1055
1056 #[cfg(feature = "telemetry")]
1058 if let Some(metrics) = &self.metrics {
1059 metrics.errors_total().inc();
1060 }
1061
1062 #[cfg(feature = "telemetry")]
1064 if let Some(mut s) = span {
1065 s.status =
1066 crate::telemetry::SpanStatus::Error(format!("Failed to prepare: {}", err_msg));
1067 s.end_time_ms = Some(js_sys::Date::now());
1068 if let Some(recorder) = &self.span_recorder {
1069 recorder.record_span(s);
1070 }
1071 }
1072
1073 return Err(DatabaseError::new(
1074 "SQLITE_ERROR",
1075 &format!("Failed to prepare statement: {}", err_msg),
1076 )
1077 .with_sql(sql));
1078 }
1079
1080 let mut text_cstrings = Vec::new(); for (i, param) in params.iter().enumerate() {
1083 let param_index = (i + 1) as i32;
1084 let bind_ret = unsafe {
1085 match param {
1086 ColumnValue::Null => sqlite_wasm_rs::sqlite3_bind_null(stmt, param_index),
1087 ColumnValue::Integer(val) => {
1088 sqlite_wasm_rs::sqlite3_bind_int64(stmt, param_index, *val)
1089 }
1090 ColumnValue::Real(val) => {
1091 sqlite_wasm_rs::sqlite3_bind_double(stmt, param_index, *val)
1092 }
1093 ColumnValue::Text(val) => {
1094 let sanitized = val.replace('\0', "");
1096 let text_cstr = CString::new(sanitized.as_str())
1098 .expect("CString::new should not fail after null byte removal");
1099 let result = sqlite_wasm_rs::sqlite3_bind_text(
1100 stmt,
1101 param_index,
1102 text_cstr.as_ptr(),
1103 sanitized.len() as i32,
1104 sqlite_wasm_rs::SQLITE_TRANSIENT(),
1105 );
1106 text_cstrings.push(text_cstr); result
1108 }
1109 ColumnValue::Blob(val) => sqlite_wasm_rs::sqlite3_bind_blob(
1110 stmt,
1111 param_index,
1112 val.as_ptr() as *const _,
1113 val.len() as i32,
1114 sqlite_wasm_rs::SQLITE_TRANSIENT(),
1115 ),
1116 _ => sqlite_wasm_rs::sqlite3_bind_null(stmt, param_index),
1117 }
1118 };
1119
1120 if bind_ret != sqlite_wasm_rs::SQLITE_OK {
1121 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1122 #[cfg(feature = "telemetry")]
1124 if let Some(metrics) = &self.metrics {
1125 metrics.errors_total().inc();
1126 }
1127 return Err(
1128 DatabaseError::new("SQLITE_ERROR", "Failed to bind parameter").with_sql(sql),
1129 );
1130 }
1131 }
1132
1133 if sql.trim().to_uppercase().starts_with("SELECT") {
1134 let column_count = unsafe { sqlite_wasm_rs::sqlite3_column_count(stmt) };
1135 let mut columns = Vec::new();
1136 let mut rows = Vec::new();
1137
1138 for i in 0..column_count {
1140 let col_name = unsafe {
1141 let name_ptr = sqlite_wasm_rs::sqlite3_column_name(stmt, i);
1142 if name_ptr.is_null() {
1143 format!("col_{}", i)
1144 } else {
1145 std::ffi::CStr::from_ptr(name_ptr)
1146 .to_string_lossy()
1147 .into_owned()
1148 }
1149 };
1150 columns.push(col_name);
1151 }
1152
1153 loop {
1155 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
1156 if step_ret == sqlite_wasm_rs::SQLITE_ROW {
1157 let mut values = Vec::new();
1158 for i in 0..column_count {
1159 let value = unsafe {
1160 let col_type = sqlite_wasm_rs::sqlite3_column_type(stmt, i);
1161 match col_type {
1162 sqlite_wasm_rs::SQLITE_NULL => ColumnValue::Null,
1163 sqlite_wasm_rs::SQLITE_INTEGER => {
1164 let val = sqlite_wasm_rs::sqlite3_column_int64(stmt, i);
1165 ColumnValue::Integer(val)
1166 }
1167 sqlite_wasm_rs::SQLITE_FLOAT => {
1168 let val = sqlite_wasm_rs::sqlite3_column_double(stmt, i);
1169 ColumnValue::Real(val)
1170 }
1171 sqlite_wasm_rs::SQLITE_TEXT => {
1172 let text_ptr = sqlite_wasm_rs::sqlite3_column_text(stmt, i);
1173 if text_ptr.is_null() {
1174 ColumnValue::Null
1175 } else {
1176 let text = std::ffi::CStr::from_ptr(text_ptr as *const i8)
1177 .to_string_lossy()
1178 .into_owned();
1179 ColumnValue::Text(text)
1180 }
1181 }
1182 sqlite_wasm_rs::SQLITE_BLOB => {
1183 let blob_ptr = sqlite_wasm_rs::sqlite3_column_blob(stmt, i);
1184 let blob_size = sqlite_wasm_rs::sqlite3_column_bytes(stmt, i);
1185 if blob_ptr.is_null() || blob_size == 0 {
1186 ColumnValue::Blob(vec![])
1187 } else {
1188 let blob_slice = std::slice::from_raw_parts(
1189 blob_ptr as *const u8,
1190 blob_size as usize,
1191 );
1192 ColumnValue::Blob(blob_slice.to_vec())
1193 }
1194 }
1195 _ => ColumnValue::Null,
1196 }
1197 };
1198 values.push(value);
1199 }
1200 rows.push(Row { values });
1201 } else if step_ret == sqlite_wasm_rs::SQLITE_DONE {
1202 break;
1203 } else {
1204 let err_msg = unsafe {
1206 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1207 if !err_ptr.is_null() {
1208 std::ffi::CStr::from_ptr(err_ptr)
1209 .to_string_lossy()
1210 .to_string()
1211 } else {
1212 "Unknown SQLite error".to_string()
1213 }
1214 };
1215 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1216 #[cfg(feature = "telemetry")]
1218 if let Some(metrics) = &self.metrics {
1219 metrics.errors_total().inc();
1220 }
1221 return Err(DatabaseError::new(
1222 "SQLITE_ERROR",
1223 &format!("Error executing SELECT statement: {}", err_msg),
1224 )
1225 .with_sql(sql));
1226 }
1227 }
1228
1229 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1230
1231 let execution_time_ms = js_sys::Date::now() - start_time;
1232
1233 #[cfg(feature = "telemetry")]
1235 if let Some(metrics) = &self.metrics {
1236 metrics.query_duration().observe(execution_time_ms);
1237 }
1238
1239 #[cfg(feature = "telemetry")]
1241 if let Some(mut s) = span {
1242 s.status = crate::telemetry::SpanStatus::Ok;
1243 s.end_time_ms = Some(js_sys::Date::now());
1244 s.attributes
1245 .insert("duration_ms".to_string(), execution_time_ms.to_string());
1246 s.attributes
1247 .insert("row_count".to_string(), rows.len().to_string());
1248 if let Some(recorder) = &self.span_recorder {
1249 recorder.record_span(s);
1250 }
1251 }
1252
1253 Ok(QueryResult {
1254 columns,
1255 rows,
1256 affected_rows: 0,
1257 last_insert_id: None,
1258 execution_time_ms,
1259 })
1260 } else {
1261 let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
1263 #[cfg(feature = "telemetry")]
1265 if let Some(metrics) = &self.metrics {
1266 metrics.errors_total().inc();
1267 }
1268 unsafe { sqlite_wasm_rs::sqlite3_finalize(stmt) };
1269
1270 if step_ret != sqlite_wasm_rs::SQLITE_DONE {
1271 let err_msg = unsafe {
1272 let err_ptr = sqlite_wasm_rs::sqlite3_errmsg(self.db());
1273 if !err_ptr.is_null() {
1274 std::ffi::CStr::from_ptr(err_ptr)
1275 .to_string_lossy()
1276 .to_string()
1277 } else {
1278 "Unknown SQLite error".to_string()
1279 }
1280 };
1281 return Err(DatabaseError::new(
1282 "SQLITE_ERROR",
1283 &format!("Failed to execute statement: {}", err_msg),
1284 )
1285 .with_sql(sql));
1286 }
1287
1288 let execution_time_ms = js_sys::Date::now() - start_time;
1289
1290 #[cfg(feature = "telemetry")]
1292 if let Some(metrics) = &self.metrics {
1293 metrics.query_duration().observe(execution_time_ms);
1294 }
1295 let affected_rows = unsafe { sqlite_wasm_rs::sqlite3_changes(self.db()) } as u32;
1296 let last_insert_id = if sql.trim().to_uppercase().starts_with("INSERT") {
1297 Some(unsafe { sqlite_wasm_rs::sqlite3_last_insert_rowid(self.db()) })
1298 } else {
1299 None
1300 };
1301
1302 #[cfg(feature = "telemetry")]
1304 if let Some(mut s) = span {
1305 s.status = crate::telemetry::SpanStatus::Ok;
1306 s.end_time_ms = Some(js_sys::Date::now());
1307 s.attributes
1308 .insert("duration_ms".to_string(), execution_time_ms.to_string());
1309 s.attributes
1310 .insert("affected_rows".to_string(), affected_rows.to_string());
1311 if let Some(recorder) = &self.span_recorder {
1312 recorder.record_span(s);
1313 }
1314 }
1315
1316 Ok(QueryResult {
1317 columns: vec![],
1318 rows: vec![],
1319 affected_rows,
1320 last_insert_id,
1321 execution_time_ms,
1322 })
1323 }
1324 }
1325
1326 #[cfg(feature = "telemetry")]
1328 pub fn set_metrics(&mut self, metrics: Option<crate::telemetry::Metrics>) {
1329 self.metrics = metrics.clone();
1330 self.ensure_metrics_propagated();
1331 }
1332
1333 #[cfg(feature = "telemetry")]
1335 pub fn set_span_recorder(&mut self, recorder: Option<crate::telemetry::SpanRecorder>) {
1336 self.span_recorder = recorder;
1337 }
1338
1339 #[cfg(feature = "telemetry")]
1341 pub fn get_span_context(&self) -> Option<&crate::telemetry::SpanContext> {
1342 self.span_context.as_ref()
1343 }
1344
1345 #[cfg(feature = "telemetry")]
1347 pub fn get_span_recorder(&self) -> Option<&crate::telemetry::SpanRecorder> {
1348 self.span_recorder.as_ref()
1349 }
1350 #[cfg(feature = "telemetry")]
1352 fn ensure_metrics_propagated(&self) {
1353 #[cfg(target_arch = "wasm32")]
1355 {
1356 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1357
1358 if self.metrics.is_none() {
1359 return;
1360 }
1361
1362 let db_name = &self.name;
1363
1364 if let Some(storage_rc) = get_storage_with_fallback(db_name) {
1365 use crate::vfs::indexeddb_vfs::with_storage_borrow_mut;
1366 let _ = with_storage_borrow_mut(&storage_rc, "set_metrics", |storage| {
1367 storage.set_metrics(self.metrics.clone());
1368 Ok(())
1369 });
1370 }
1371 }
1372 }
1373
1374 pub async fn close_internal(&mut self) -> Result<(), DatabaseError> {
1375 log::info!("CLOSE_INTERNAL STARTED for: {}", self.name);
1376
1377 if self.connection_state.db.get().is_null() {
1379 log::info!(
1380 "Connection already null for {}, skipping close operations",
1381 self.name
1382 );
1383 return Ok(());
1384 }
1385
1386 log::info!("Checkpointing WAL before close: {}", self.name);
1388 let _ = self
1389 .execute_internal("PRAGMA wal_checkpoint(PASSIVE)")
1390 .await;
1391 log::info!("WAL checkpoint completed for: {}", self.name);
1392
1393 log::info!("Syncing database before close: {}", self.name);
1395 self.sync_internal().await?;
1396 log::info!("Sync completed for: {}", self.name);
1397
1398 web_sys::console::log_1(
1399 &format!("CLOSE: About to stop leader election for {}", self.name).into(),
1400 );
1401
1402 #[cfg(target_arch = "wasm32")]
1404 {
1405 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1406
1407 let db_name = &self.name;
1408 web_sys::console::log_1(
1409 &format!("STOP_ELECTION: Getting storage for {}", db_name).into(),
1410 );
1411 log::info!("STOP_ELECTION: Getting storage for {}", db_name);
1412 let storage_rc = get_storage_with_fallback(db_name);
1413
1414 if let Some(storage_rc) = storage_rc {
1415 log::info!("STOP_ELECTION: Found storage for {}, calling stop", db_name);
1416 match with_storage_async!(storage_rc, "stop_leader_election", |storage| storage
1417 .stop_leader_election())
1418 {
1419 Some(Ok(())) => {
1420 log::info!("STOP_ELECTION: Successfully stopped for {}", db_name);
1421 }
1422 Some(Err(e)) => {
1423 log::warn!("STOP_ELECTION: Failed for {}: {:?}", db_name, e);
1424 }
1425 None => {
1426 log::warn!("STOP_ELECTION: Borrow failed for {}", db_name);
1427 }
1428 }
1429 } else {
1430 log::warn!("STOP_ELECTION: No storage found for {}", db_name);
1431 }
1432 log::info!("STOP_ELECTION: Completed section for {}", db_name);
1433 }
1434
1435 log::info!(
1440 "Closed database: {} (connection will be released on Drop)",
1441 self.name
1442 );
1443 Ok(())
1444 }
1445
1446 pub async fn query(&mut self, sql: &str) -> Result<Vec<Row>, DatabaseError> {
1448 let result = self.execute_internal(sql).await?;
1449 Ok(result.rows)
1450 }
1451
1452 pub async fn sync_internal(&mut self) -> Result<(), DatabaseError> {
1453 #[cfg(all(target_arch = "wasm32", feature = "telemetry"))]
1455 let start_time = js_sys::Date::now();
1456
1457 #[cfg(feature = "telemetry")]
1459 let span = if self.span_recorder.is_some() {
1460 let mut builder = crate::telemetry::SpanBuilder::new("vfs_sync".to_string())
1461 .with_attribute("operation", "sync");
1462
1463 if let Some(ref context) = self.span_context {
1465 builder = builder
1466 .with_context(context)
1467 .with_baggage_from_context(context);
1468 }
1469
1470 let span = builder.build();
1471
1472 if let Some(ref context) = self.span_context {
1474 context.enter_span(span.span_id.clone());
1475 }
1476
1477 Some(span)
1478 } else {
1479 None
1480 };
1481
1482 #[cfg(feature = "telemetry")]
1484 if let Some(ref metrics) = self.metrics {
1485 metrics.sync_operations_total().inc();
1486 }
1487
1488 #[cfg(feature = "telemetry")]
1490 let mut blocks_count = 0;
1491
1492 #[cfg(target_arch = "wasm32")]
1494 {
1495 use crate::storage::vfs_sync;
1496
1497 let db_ptr = self.connection_state.db.get();
1499 if !db_ptr.is_null() {
1500 let checkpoint_sql =
1503 std::ffi::CString::new("PRAGMA wal_checkpoint(TRUNCATE)").expect("valid SQL");
1504 let mut stmt: *mut sqlite_wasm_rs::sqlite3_stmt = std::ptr::null_mut();
1505 let prepare_result = unsafe {
1506 sqlite_wasm_rs::sqlite3_prepare_v2(
1507 db_ptr,
1508 checkpoint_sql.as_ptr(),
1509 -1,
1510 &mut stmt,
1511 std::ptr::null_mut(),
1512 )
1513 };
1514 if prepare_result == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
1515 unsafe {
1516 sqlite_wasm_rs::sqlite3_step(stmt);
1517 sqlite_wasm_rs::sqlite3_finalize(stmt);
1518 }
1519 log::debug!("WAL checkpoint completed");
1520 }
1521
1522 let flush_result = unsafe { sqlite_wasm_rs::sqlite3_db_cacheflush(db_ptr) };
1524 if flush_result != sqlite_wasm_rs::SQLITE_OK {
1525 log::warn!("sqlite3_db_cacheflush returned {}", flush_result);
1526 }
1527 }
1528
1529 let storage_name = &self.name;
1533
1534 let next_commit = vfs_sync::with_global_commit_marker(|cm| {
1536 #[cfg(target_arch = "wasm32")]
1537 let mut cm_ref = cm.borrow_mut();
1538 #[cfg(not(target_arch = "wasm32"))]
1539 let mut cm_ref = cm.lock();
1540
1541 let current = cm_ref.get(storage_name).copied().unwrap_or(0);
1542 let new_marker = current + 1;
1543 cm_ref.insert(storage_name.to_string(), new_marker);
1544 log::debug!(
1545 "Advanced commit marker for {} from {} to {}",
1546 storage_name,
1547 current,
1548 new_marker
1549 );
1550 new_marker
1551 });
1552
1553 web_sys::console::log_1(
1554 &format!(
1555 "[SYNC] Collecting blocks from GLOBAL_STORAGE for: {}",
1556 storage_name
1557 )
1558 .into(),
1559 );
1560 let (blocks_to_persist, metadata_to_persist) =
1561 vfs_sync::with_global_storage(|storage| {
1562 #[cfg(target_arch = "wasm32")]
1563 let storage_map = storage.borrow();
1564 #[cfg(not(target_arch = "wasm32"))]
1565 let storage_map = storage.lock();
1566
1567 let blocks = if let Some(db_storage) = storage_map.get(storage_name) {
1568 let count = db_storage.len();
1569 web_sys::console::log_1(
1570 &format!("[SYNC] Found {} blocks in GLOBAL_STORAGE", count).into(),
1571 );
1572 db_storage
1573 .iter()
1574 .map(|(&id, data)| (id, data.clone()))
1575 .collect::<Vec<_>>()
1576 } else {
1577 web_sys::console::log_1(
1578 &format!(
1579 "[SYNC] No blocks found in GLOBAL_STORAGE for {}",
1580 storage_name
1581 )
1582 .into(),
1583 );
1584 Vec::new()
1585 };
1586
1587 let metadata = vfs_sync::with_global_metadata(|meta| {
1588 #[cfg(target_arch = "wasm32")]
1589 let meta_map = meta.borrow();
1590 #[cfg(not(target_arch = "wasm32"))]
1591 let meta_map = meta.lock();
1592 if let Some(db_meta) = meta_map.get(storage_name) {
1593 let count = db_meta.len();
1594 web_sys::console::log_1(
1595 &format!("[SYNC] Found {} metadata entries", count).into(),
1596 );
1597 db_meta
1598 .iter()
1599 .map(|(&id, metadata)| (id, metadata.checksum))
1600 .collect::<Vec<_>>()
1601 } else {
1602 web_sys::console::log_1(&format!("[SYNC] No metadata found").into());
1603 Vec::new()
1604 }
1605 });
1606
1607 (blocks, metadata)
1608 });
1609
1610 web_sys::console::log_1(
1611 &format!(
1612 "[SYNC] Preparing to persist {} blocks to IndexedDB",
1613 blocks_to_persist.len()
1614 )
1615 .into(),
1616 );
1617
1618 if !blocks_to_persist.is_empty() {
1619 #[cfg(feature = "telemetry")]
1620 {
1621 blocks_count = blocks_to_persist.len();
1622 }
1623 web_sys::console::log_1(
1624 &format!(
1625 "[SYNC] Persisting {} blocks to IndexedDB",
1626 blocks_to_persist.len()
1627 )
1628 .into(),
1629 );
1630 crate::storage::wasm_indexeddb::persist_to_indexeddb_event_based(
1631 storage_name,
1632 blocks_to_persist,
1633 metadata_to_persist,
1634 next_commit,
1635 #[cfg(feature = "telemetry")]
1636 self.span_recorder.clone(),
1637 #[cfg(feature = "telemetry")]
1638 span.as_ref().map(|s| s.span_id.clone()),
1639 )
1640 .await?;
1641 web_sys::console::log_1(
1642 &format!("[SYNC] Successfully persisted to IndexedDB").into(),
1643 );
1644 } else {
1645 web_sys::console::log_1(
1646 &format!("[SYNC] WARNING: No blocks to persist - GLOBAL_STORAGE is empty!")
1647 .into(),
1648 );
1649 }
1650
1651 use crate::storage::broadcast_notifications::{
1653 BroadcastNotification, send_change_notification,
1654 };
1655
1656 let notification = BroadcastNotification::DataChanged {
1657 db_name: self.name.clone(),
1658 timestamp: js_sys::Date::now() as u64,
1659 };
1660
1661 log::debug!("Sending DataChanged notification for {}", self.name);
1662
1663 if let Err(e) = send_change_notification(¬ification) {
1664 log::warn!("Failed to send change notification: {}", e);
1665 }
1667 }
1668
1669 #[cfg(all(target_arch = "wasm32", feature = "telemetry"))]
1671 if let Some(ref metrics) = self.metrics {
1672 let duration_ms = js_sys::Date::now() - start_time;
1673 metrics.sync_duration().observe(duration_ms);
1674 }
1675
1676 #[cfg(feature = "telemetry")]
1678 if let Some(mut s) = span {
1679 s.status = crate::telemetry::SpanStatus::Ok;
1680 #[cfg(target_arch = "wasm32")]
1681 {
1682 s.end_time_ms = Some(js_sys::Date::now());
1683 let duration_ms = s.end_time_ms.unwrap() - s.start_time_ms;
1684 s.attributes
1685 .insert("duration_ms".to_string(), duration_ms.to_string());
1686 }
1687 #[cfg(not(target_arch = "wasm32"))]
1688 {
1689 let now = std::time::SystemTime::now()
1690 .duration_since(std::time::UNIX_EPOCH)
1691 .unwrap()
1692 .as_millis() as f64;
1693 s.end_time_ms = Some(now);
1694 let duration_ms = s.end_time_ms.unwrap() - s.start_time_ms;
1695 s.attributes
1696 .insert("duration_ms".to_string(), duration_ms.to_string());
1697 }
1698 s.attributes
1699 .insert("blocks_persisted".to_string(), blocks_count.to_string());
1700 if let Some(recorder) = &self.span_recorder {
1701 recorder.record_span(s);
1702 }
1703
1704 if let Some(ref context) = self.span_context {
1706 context.exit_span();
1707 }
1708 }
1709
1710 Ok(())
1711 }
1712}
1713
1714#[cfg(target_arch = "wasm32")]
1715impl Drop for Database {
1716 fn drop(&mut self) {
1717 web_sys::console::log_1(&format!("DROP: Releasing connection for {}", self.name).into());
1718
1719 let pool_key = self.name.trim_end_matches(".db");
1723 crate::connection_pool::release_connection(pool_key);
1724
1725 web_sys::console::log_1(&format!("DROP: Connection released for {}", self.name).into());
1726
1727 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1729 if let Some(storage_rc) = get_storage_with_fallback(&self.name) {
1730 let storage = &*storage_rc;
1732 if let Ok(mut manager_ref) = storage.leader_election.try_borrow_mut() {
1734 if let Some(ref mut manager) = *manager_ref {
1735 if let Some(interval_id) = manager.heartbeat_interval.take() {
1737 if let Some(window) = web_sys::window() {
1738 window.clear_interval_with_handle(interval_id);
1739 web_sys::console::log_1(
1740 &format!(
1741 "DROP: Cleared heartbeat interval {} for {}",
1742 interval_id, self.name
1743 )
1744 .into(),
1745 );
1746 }
1747 }
1748 }
1751 } else {
1752 web_sys::console::log_1(
1754 &format!(
1755 "[DROP] Skipping {} (heartbeat already stopped by shared DB)",
1756 self.name
1757 )
1758 .into(),
1759 );
1760 }
1761 }
1762
1763 log::debug!(
1767 "Closed database: {} (BlockStorage remains in registry)",
1768 self.name
1769 );
1770 }
1771}
1772
1773#[cfg(target_arch = "wasm32")]
1775#[wasm_bindgen]
1776impl Database {
1777 #[wasm_bindgen(js_name = "newDatabase")]
1778 pub async fn new_wasm(name: String) -> Result<Database, JsValue> {
1779 let normalized_name = if name.ends_with(".db") {
1781 name.clone()
1782 } else {
1783 format!("{}.db", name)
1784 };
1785
1786 let config = DatabaseConfig {
1787 name: normalized_name.clone(),
1788 version: Some(1),
1789 cache_size: Some(10_000),
1790 page_size: Some(4096),
1791 auto_vacuum: Some(true),
1792 journal_mode: Some("WAL".to_string()),
1793 max_export_size_bytes: Some(2 * 1024 * 1024 * 1024), };
1795
1796 let db = Database::new(config)
1797 .await
1798 .map_err(|e| JsValue::from_str(&format!("Failed to create database: {}", e)))?;
1799
1800 Self::start_write_queue_listener(&normalized_name)?;
1802
1803 Ok(db)
1804 }
1805
1806 #[wasm_bindgen(getter)]
1808 pub fn name(&self) -> String {
1809 self.name.clone()
1810 }
1811
1812 #[wasm_bindgen(js_name = "getAllDatabases")]
1816 pub async fn get_all_databases() -> Result<JsValue, JsValue> {
1817 use crate::storage::vfs_sync::with_global_storage;
1818 use crate::vfs::indexeddb_vfs::STORAGE_REGISTRY;
1819 use std::collections::HashSet;
1820
1821 log::info!("getAllDatabases called");
1822 let mut db_names = HashSet::new();
1823
1824 match Self::get_persistent_database_list() {
1826 Ok(persistent_list) => {
1827 log::info!("Persistent list has {} entries", persistent_list.len());
1828 for name in persistent_list {
1829 log::info!("Found in persistent list: {}", name);
1830 db_names.insert(name);
1831 }
1832 }
1833 Err(e) => {
1834 log::warn!("Failed to get persistent list: {:?}", e);
1835 }
1836 }
1837
1838 STORAGE_REGISTRY.with(|reg| unsafe {
1841 let registry = &*reg.get();
1842 log::info!("STORAGE_REGISTRY has {} entries", registry.len());
1843 for key in registry.keys() {
1844 log::info!("Found in STORAGE_REGISTRY: {}", key);
1845 db_names.insert(key.clone());
1846 }
1847 });
1848
1849 with_global_storage(|storage| {
1851 let storage_borrow = storage.borrow();
1852 log::info!("GLOBAL_STORAGE has {} entries", storage_borrow.len());
1853 for key in storage_borrow.keys() {
1854 log::info!("Found in GLOBAL_STORAGE: {}", key);
1855 db_names.insert(key.clone());
1856 }
1857 });
1858
1859 log::info!("Total unique databases found: {}", db_names.len());
1860
1861 let mut result_vec: Vec<String> = db_names.into_iter().collect();
1863 result_vec.sort();
1864
1865 let js_array = js_sys::Array::new();
1867 for name in &result_vec {
1868 log::info!("Returning database: {}", name);
1869 js_array.push(&JsValue::from_str(name));
1870 }
1871
1872 log::info!("getAllDatabases returning {} databases", result_vec.len());
1873
1874 Ok(js_array.into())
1875 }
1876
1877 #[wasm_bindgen(js_name = "deleteDatabase")]
1881 pub async fn delete_database(name: String) -> Result<(), JsValue> {
1882 use crate::storage::vfs_sync::{
1883 with_global_commit_marker, with_global_metadata, with_global_storage,
1884 };
1885
1886 let normalized_name = if name.ends_with(".db") {
1888 name.clone()
1889 } else {
1890 format!("{}.db", name)
1891 };
1892
1893 log::info!("Deleting database: {}", normalized_name);
1894
1895 use crate::vfs::indexeddb_vfs::remove_storage_from_registry;
1897 remove_storage_from_registry(&normalized_name);
1898
1899 with_global_storage(|gs| {
1901 #[cfg(target_arch = "wasm32")]
1902 let mut storage = gs.borrow_mut();
1903 #[cfg(not(target_arch = "wasm32"))]
1904 let mut storage = gs.lock();
1905 storage.remove(&normalized_name);
1906 });
1907
1908 with_global_metadata(|gm| {
1910 #[cfg(target_arch = "wasm32")]
1911 let mut metadata = gm.borrow_mut();
1912 #[cfg(not(target_arch = "wasm32"))]
1913 let mut metadata = gm.lock();
1914 metadata.remove(&normalized_name);
1915 });
1916
1917 with_global_commit_marker(|cm| {
1919 #[cfg(target_arch = "wasm32")]
1920 let mut markers = cm.borrow_mut();
1921 #[cfg(not(target_arch = "wasm32"))]
1922 let mut markers = cm.lock();
1923 log::info!(
1924 "Cleared commit marker for {} from GLOBAL storage",
1925 normalized_name
1926 );
1927 markers.remove(&normalized_name);
1928 });
1929
1930 let idb_name = format!("absurder_{}", normalized_name);
1933 {
1934 use wasm_bindgen::JsCast;
1935 let global = js_sys::global();
1936 let indexed_db_value =
1937 js_sys::Reflect::get(&global, &JsValue::from_str("indexedDB"))
1938 .map_err(|e| JsValue::from_str(&format!("IndexedDB access failed: {:?}", e)))?;
1939 if !indexed_db_value.is_null() && !indexed_db_value.is_undefined() {
1940 let idb_factory: web_sys::IdbFactory = indexed_db_value
1941 .dyn_into()
1942 .map_err(|_| JsValue::from_str("indexedDB is not an IdbFactory"))?;
1943 idb_factory.delete_database(&idb_name).map_err(|e| {
1944 JsValue::from_str(&format!("Failed to delete IndexedDB: {:?}", e))
1945 })?;
1946 }
1947 }
1948
1949 log::info!("Database deleted: {}", normalized_name);
1950
1951 Self::remove_database_from_persistent_list(&normalized_name)?;
1953
1954 Ok(())
1955 }
1956
1957 #[allow(dead_code)]
1959 fn add_database_to_persistent_list(db_name: &str) -> Result<(), JsValue> {
1960 log::info!("add_database_to_persistent_list called for: {}", db_name);
1961
1962 let window = web_sys::window().ok_or_else(|| {
1963 log::error!("No window object");
1964 JsValue::from_str("No window")
1965 })?;
1966
1967 let storage = window
1968 .local_storage()
1969 .map_err(|e| {
1970 log::error!("Failed to get localStorage: {:?}", e);
1971 JsValue::from_str("No localStorage")
1972 })?
1973 .ok_or_else(|| {
1974 log::error!("localStorage not available");
1975 JsValue::from_str("localStorage not available")
1976 })?;
1977
1978 let key = "absurder_db_list";
1979 let existing = storage.get_item(key).map_err(|e| {
1980 log::error!("Failed to read localStorage key {}: {:?}", key, e);
1981 JsValue::from_str("Failed to read localStorage")
1982 })?;
1983
1984 log::debug!("Existing localStorage value: {:?}", existing);
1985
1986 let mut db_list: Vec<String> = if let Some(json_str) = existing {
1987 match serde_json::from_str(&json_str) {
1988 Ok(list) => {
1989 log::debug!("Parsed existing list: {:?}", list);
1990 list
1991 }
1992 Err(e) => {
1993 log::warn!("Failed to parse localStorage JSON: {}, starting fresh", e);
1994 Vec::new()
1995 }
1996 }
1997 } else {
1998 log::debug!("No existing list, creating new");
1999 Vec::new()
2000 };
2001
2002 if !db_list.contains(&db_name.to_string()) {
2003 db_list.push(db_name.to_string());
2004 db_list.sort();
2005 log::debug!("Updated list: {:?}", db_list);
2006
2007 let json_str = serde_json::to_string(&db_list).map_err(|e| {
2008 log::error!("Failed to serialize list: {}", e);
2009 JsValue::from_str("Failed to serialize")
2010 })?;
2011
2012 log::debug!("Writing to localStorage: {}", json_str);
2013
2014 storage.set_item(key, &json_str).map_err(|e| {
2015 log::error!("Failed to write to localStorage: {:?}", e);
2016 JsValue::from_str("Failed to write localStorage")
2017 })?;
2018
2019 log::info!("Successfully added {} to persistent database list", db_name);
2020 } else {
2021 log::info!("{} already in persistent list", db_name);
2022 }
2023
2024 Ok(())
2025 }
2026
2027 fn remove_database_from_persistent_list(db_name: &str) -> Result<(), JsValue> {
2029 let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window"))?;
2030 let storage = window
2031 .local_storage()
2032 .map_err(|_| JsValue::from_str("No localStorage"))?
2033 .ok_or_else(|| JsValue::from_str("localStorage not available"))?;
2034
2035 let key = "absurder_db_list";
2036 let existing = storage
2037 .get_item(key)
2038 .map_err(|_| JsValue::from_str("Failed to read localStorage"))?;
2039
2040 if let Some(json_str) = existing {
2041 let mut db_list: Vec<String> =
2042 serde_json::from_str(&json_str).unwrap_or_else(|_| Vec::new());
2043 db_list.retain(|name| name != db_name);
2044 let json_str = serde_json::to_string(&db_list)
2045 .map_err(|_| JsValue::from_str("Failed to serialize"))?;
2046 storage
2047 .set_item(key, &json_str)
2048 .map_err(|_| JsValue::from_str("Failed to write localStorage"))?;
2049 log::info!("Removed {} from persistent database list", db_name);
2050 }
2051
2052 Ok(())
2053 }
2054
2055 fn get_persistent_database_list() -> Result<Vec<String>, JsValue> {
2057 log::info!("get_persistent_database_list called");
2058
2059 let window = web_sys::window().ok_or_else(|| {
2060 log::error!("No window object");
2061 JsValue::from_str("No window")
2062 })?;
2063
2064 let storage = window
2065 .local_storage()
2066 .map_err(|e| {
2067 log::error!("Failed to get localStorage: {:?}", e);
2068 JsValue::from_str("No localStorage")
2069 })?
2070 .ok_or_else(|| {
2071 log::error!("localStorage not available");
2072 JsValue::from_str("localStorage not available")
2073 })?;
2074
2075 let key = "absurder_db_list";
2076 let existing = storage.get_item(key).map_err(|e| {
2077 log::error!("Failed to read localStorage key {}: {:?}", key, e);
2078 JsValue::from_str("Failed to read localStorage")
2079 })?;
2080
2081 log::debug!("Read from localStorage: {:?}", existing);
2082
2083 if let Some(json_str) = existing {
2084 match serde_json::from_str::<Vec<String>>(&json_str) {
2085 Ok(db_list) => {
2086 log::info!(
2087 "Successfully parsed {} databases from localStorage",
2088 db_list.len()
2089 );
2090 log::debug!("Database list: {:?}", db_list);
2091 Ok(db_list)
2092 }
2093 Err(e) => {
2094 log::error!("Failed to parse localStorage JSON: {}", e);
2095 Ok(Vec::new())
2096 }
2097 }
2098 } else {
2099 log::info!("No persistent database list in localStorage");
2100 Ok(Vec::new())
2101 }
2102 }
2103
2104 fn start_write_queue_listener(db_name: &str) -> Result<(), JsValue> {
2106 use crate::storage::write_queue::{
2107 WriteQueueMessage, WriteResponse, register_write_queue_listener,
2108 };
2109 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2110
2111 let db_name_clone = db_name.to_string();
2112
2113 let callback = Closure::wrap(Box::new(move |msg: JsValue| {
2114 let db_name_inner = db_name_clone.clone();
2115
2116 if let Ok(json_str) = js_sys::JSON::stringify(&msg) {
2118 if let Some(json_str) = json_str.as_string() {
2119 if let Ok(message) = serde_json::from_str::<WriteQueueMessage>(&json_str) {
2120 if let WriteQueueMessage::WriteRequest(request) = message {
2121 log::debug!("Leader received write request: {}", request.request_id);
2122
2123 let storage_rc = get_storage_with_fallback(&db_name_inner);
2125
2126 if let Some(storage) = storage_rc {
2127 wasm_bindgen_futures::spawn_local(async move {
2129 let is_leader = with_storage_async!(
2130 storage,
2131 "write_queue_is_leader",
2132 |s| s.is_leader()
2133 );
2134 if is_leader.is_none() {
2135 log::error!("Failed to check leader status");
2136 return;
2137 }
2138 let is_leader = is_leader.unwrap();
2139
2140 if !is_leader {
2141 log::error!("Not leader, ignoring write request");
2142 return;
2143 }
2144
2145 log::debug!("Processing write request as leader");
2146
2147 match Database::new_wasm(db_name_inner.clone()).await {
2149 Ok(mut db) => {
2150 match db.execute_internal(&request.sql).await {
2152 Ok(result) => {
2153 let response = WriteResponse::Success {
2155 request_id: request.request_id.clone(),
2156 affected_rows: result.affected_rows
2157 as usize,
2158 };
2159
2160 use crate::storage::write_queue::send_write_response;
2161 if let Err(e) = send_write_response(
2162 &db_name_inner,
2163 response,
2164 ) {
2165 log::error!(
2166 "Failed to send response: {}",
2167 e
2168 );
2169 } else {
2170 log::info!(
2171 "Write response sent successfully"
2172 );
2173 }
2174 }
2175 Err(e) => {
2176 let response = WriteResponse::Error {
2178 request_id: request.request_id.clone(),
2179 error_message: e.to_string(),
2180 };
2181
2182 use crate::storage::write_queue::send_write_response;
2183 if let Err(e) = send_write_response(
2184 &db_name_inner,
2185 response,
2186 ) {
2187 log::error!(
2188 "Failed to send error response: {}",
2189 e
2190 );
2191 }
2192 }
2193 }
2194 }
2195 Err(e) => {
2196 log::error!(
2197 "Failed to create db for write processing: {:?}",
2198 e
2199 );
2200 }
2201 }
2202 });
2203 }
2204 }
2205 }
2206 }
2207 }
2208 }) as Box<dyn FnMut(JsValue)>);
2209
2210 let callback_fn = callback.as_ref().unchecked_ref();
2211 register_write_queue_listener(db_name, callback_fn).map_err(|e| {
2212 JsValue::from_str(&format!("Failed to register write queue listener: {}", e))
2213 })?;
2214
2215 callback.forget();
2216
2217 Ok(())
2218 }
2219
2220 #[wasm_bindgen]
2221 pub async fn execute(&mut self, sql: &str) -> Result<JsValue, JsValue> {
2222 self.check_write_permission(sql)
2224 .await
2225 .map_err(|e| JsValue::from_str(&format!("Write permission denied: {}", e)))?;
2226
2227 let result = self
2228 .execute_internal(sql)
2229 .await
2230 .map_err(|e| JsValue::from_str(&format!("Query execution failed: {}", e)))?;
2231 serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
2232 }
2233
2234 #[wasm_bindgen(js_name = "executeWithParams")]
2235 pub async fn execute_with_params(
2236 &mut self,
2237 sql: &str,
2238 params: JsValue,
2239 ) -> Result<JsValue, JsValue> {
2240 let params: Vec<ColumnValue> = serde_wasm_bindgen::from_value(params)
2241 .map_err(|e| JsValue::from_str(&format!("Invalid parameters: {}", e)))?;
2242
2243 self.check_write_permission(sql)
2245 .await
2246 .map_err(|e| JsValue::from_str(&format!("Write permission denied: {}", e)))?;
2247
2248 let result = self
2249 .execute_with_params_internal(sql, ¶ms)
2250 .await
2251 .map_err(|e| JsValue::from_str(&format!("Query execution failed: {}", e)))?;
2252 serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
2253 }
2254
2255 #[wasm_bindgen]
2256 pub async fn close(&mut self) -> Result<(), JsValue> {
2257 self.close_internal()
2258 .await
2259 .map_err(|e| JsValue::from_str(&format!("Failed to close database: {}", e)))
2260 }
2261
2262 #[wasm_bindgen(js_name = "forceCloseConnection")]
2264 pub async fn force_close_connection(&mut self) -> Result<(), JsValue> {
2265 let _ = self.close_internal().await;
2267
2268 let pool_key = self.name.trim_end_matches(".db");
2271 crate::connection_pool::force_close_connection(pool_key);
2272
2273 #[cfg(target_arch = "wasm32")]
2275 {
2276 crate::cleanup::cleanup_all_state(pool_key)
2277 .await
2278 .map_err(|e| JsValue::from_str(&format!("Cleanup failed: {}", e)))?;
2279 }
2280 log::info!("Force closed and removed connection for: {}", self.name);
2281 Ok(())
2282 }
2283
2284 #[wasm_bindgen]
2285 pub async fn sync(&mut self) -> Result<(), JsValue> {
2286 self.sync_internal()
2287 .await
2288 .map_err(|e| JsValue::from_str(&format!("Failed to sync database: {}", e)))
2289 }
2290
2291 #[wasm_bindgen(js_name = "allowNonLeaderWrites")]
2293 pub async fn allow_non_leader_writes(&mut self, allow: bool) -> Result<(), JsValue> {
2294 log::debug!("Setting allowNonLeaderWrites = {} for {}", allow, self.name);
2295 self.allow_non_leader_writes = allow;
2296 Ok(())
2297 }
2298
2299 #[wasm_bindgen(js_name = "exportToFile")]
2315 pub async fn export_to_file(&self) -> Result<js_sys::Uint8Array, JsValue> {
2316 let db_name = self.name.clone();
2317 let max_export_size = self.max_export_size_bytes;
2318
2319 log::info!("[EXPORT] ===== Step 1: Acquiring lock");
2320
2321 let _guard = weblocks::acquire(&db_name, weblocks::AcquireOptions::exclusive()).await?;
2323 log::info!("[EXPORT] ===== Step 2: Lock acquired");
2324
2325 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2327 log::info!("[EXPORT] ===== Step 3: Getting storage");
2328 let storage_rc = get_storage_with_fallback(&db_name).ok_or_else(|| {
2329 JsValue::from_str(&format!("Storage not found for database: {}", db_name))
2330 })?;
2331 log::info!("[EXPORT] ===== Step 4: Got storage, reloading cache");
2332
2333 #[cfg(target_arch = "wasm32")]
2335 {
2336 storage_rc.reload_cache_from_global_storage();
2337 }
2338
2339 log::info!("[EXPORT] ===== Step 5: Checkpointing WAL");
2342 if !self.connection_state.db.get().is_null() {
2343 use std::ffi::CString;
2345 let pragma = CString::new("PRAGMA wal_checkpoint(PASSIVE)").unwrap();
2346 unsafe {
2347 let mut stmt = std::ptr::null_mut();
2348 let rc = sqlite_wasm_rs::sqlite3_prepare_v2(
2349 self.connection_state.db.get(),
2350 pragma.as_ptr(),
2351 -1,
2352 &mut stmt,
2353 std::ptr::null_mut(),
2354 );
2355 if rc == sqlite_wasm_rs::SQLITE_OK && !stmt.is_null() {
2356 sqlite_wasm_rs::sqlite3_step(stmt);
2357 sqlite_wasm_rs::sqlite3_finalize(stmt);
2358 log::info!("[EXPORT] WAL checkpoint completed");
2359 } else {
2360 log::warn!("[EXPORT] WAL checkpoint failed with rc: {}", rc);
2361 }
2362 }
2363 }
2364
2365 log::info!("[EXPORT] ===== Step 6: Starting sync");
2366 storage_rc
2368 .sync()
2369 .await
2370 .map_err(|e| JsValue::from_str(&format!("Sync failed: {}", e)))?;
2371 log::info!("[EXPORT] ===== Step 7: Sync complete");
2372
2373 log::info!("[EXPORT] Calling export_database_to_bytes");
2375 let db_bytes = {
2376 let storage = &*storage_rc;
2377 crate::storage::export::export_database_to_bytes(storage, max_export_size)
2378 .await
2379 .map_err(|e| {
2380 log::error!("[EXPORT] Export failed: {}", e);
2381 JsValue::from_str(&format!("Export failed: {}", e))
2382 })?
2383 };
2384
2385 log::info!("[EXPORT] Export complete: {} bytes", db_bytes.len());
2386
2387 let uint8_array = js_sys::Uint8Array::new_with_length(db_bytes.len() as u32);
2388 uint8_array.copy_from(&db_bytes);
2389
2390 Ok(uint8_array)
2391 }
2392
2393 #[wasm_bindgen(js_name = "testLock")]
2395 pub async fn test_lock(&self, value: u32) -> Result<u32, JsValue> {
2396 let lock_name = format!("{}.lock_test", self.name);
2397
2398 log::info!(
2399 "[LOCK-TEST] Acquiring lock: {} with value: {}",
2400 lock_name,
2401 value
2402 );
2403 let _guard = weblocks::acquire(&lock_name, weblocks::AcquireOptions::exclusive()).await?;
2404 log::info!("[LOCK-TEST] Lock acquired, processing value: {}", value);
2405
2406 let result = value + 1;
2408
2409 let delay_promise = js_sys::Promise::new(&mut |resolve, _reject| {
2411 let window = web_sys::window().unwrap();
2412 let _ = window
2413 .set_timeout_with_callback_and_timeout_and_arguments_0(resolve.unchecked_ref(), 10);
2414 });
2415 wasm_bindgen_futures::JsFuture::from(delay_promise).await?;
2416
2417 log::info!(
2418 "[LOCK-TEST] Lock releasing for: {} with result: {}",
2419 lock_name,
2420 result
2421 );
2422 Ok(result)
2423 }
2424
2425 #[wasm_bindgen(js_name = "importFromFile")]
2454 pub async fn import_from_file(&mut self, file_data: js_sys::Uint8Array) -> Result<(), JsValue> {
2455 log::info!("[IMPORT] Starting import with lock for: {}", self.name);
2456 let db_name = self.name.clone();
2457 let data = file_data.to_vec();
2458
2459 let _guard = weblocks::acquire(&db_name, weblocks::AcquireOptions::exclusive()).await?;
2461 log::info!("[IMPORT] Lock acquired for: {}", db_name);
2462
2463 log::debug!("Import data size: {} bytes", data.len());
2464
2465 log::debug!("Force-closing database connection before import");
2469
2470 self.close_internal()
2472 .await
2473 .map_err(|e| JsValue::from_str(&format!("Failed to close before import: {}", e)))?;
2474
2475 let pool_key = self.name.trim_end_matches(".db");
2477 crate::connection_pool::force_close_connection(pool_key);
2478
2479 self.connection_state.db.set(std::ptr::null_mut());
2481 log::debug!("Removed connection from pool for import");
2482
2483 crate::storage::import::import_database_from_bytes(&db_name, data)
2485 .await
2486 .map_err(|e| {
2487 log::error!("Import failed for {}: {}", db_name, e);
2488 JsValue::from_str(&format!("Import failed: {}", e))
2489 })?;
2490
2491 log::info!("[IMPORT] Import complete for: {}", db_name);
2492
2493 log::info!("[IMPORT] Reopening connection for: {}", db_name);
2496
2497 use std::ffi::CString;
2498
2499 let vfs_name = format!("vfs_{}", db_name.trim_end_matches(".db"));
2500 let pool_key = db_name.trim_end_matches(".db").to_string();
2501 let db_name_for_closure = db_name.clone();
2502 let vfs_name_for_closure = vfs_name.clone();
2503
2504 let new_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
2505 let mut db = std::ptr::null_mut();
2506 let db_name_cstr = CString::new(db_name_for_closure.clone())
2507 .map_err(|_| "Invalid database name".to_string())?;
2508 let vfs_cstr = CString::new(vfs_name_for_closure.as_str())
2509 .map_err(|_| "Invalid VFS name".to_string())?;
2510
2511 log::info!(
2512 "[IMPORT] Reopening database: {} with VFS: {}",
2513 db_name_for_closure,
2514 vfs_name_for_closure
2515 );
2516
2517 let ret = unsafe {
2518 sqlite_wasm_rs::sqlite3_open_v2(
2519 db_name_cstr.as_ptr(),
2520 &mut db as *mut _,
2521 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
2522 vfs_cstr.as_ptr(),
2523 )
2524 };
2525
2526 if ret != sqlite_wasm_rs::SQLITE_OK {
2527 let err_msg = unsafe {
2528 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
2529 if !msg_ptr.is_null() {
2530 std::ffi::CStr::from_ptr(msg_ptr)
2531 .to_string_lossy()
2532 .into_owned()
2533 } else {
2534 "Unknown error".to_string()
2535 }
2536 };
2537 return Err(format!(
2538 "Failed to reopen database after import: {}",
2539 err_msg
2540 ));
2541 }
2542
2543 log::info!("[IMPORT] Database reopened successfully");
2544 Ok(db)
2545 })
2546 .map_err(|e| {
2547 JsValue::from_str(&format!("Failed to reopen connection after import: {}", e))
2548 })?;
2549
2550 self.connection_state = new_state;
2552 log::info!("[IMPORT] Connection state updated for: {}", db_name);
2553
2554 Ok(())
2555 }
2556
2557 #[wasm_bindgen(js_name = "waitForLeadership")]
2559 pub async fn wait_for_leadership(&mut self) -> Result<(), JsValue> {
2560 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2561
2562 #[cfg(feature = "telemetry")]
2564 if let Some(ref metrics) = self.metrics {
2565 metrics.leader_election_attempts_total().inc();
2566 }
2567
2568 let db_name = &self.name;
2569 let start_time = js_sys::Date::now();
2570
2571 let timeout_ms = 5000.0; loop {
2574 let storage_rc = get_storage_with_fallback(db_name);
2575
2576 if let Some(storage) = storage_rc {
2577 let is_leader =
2578 match with_storage_async!(storage, "wait_for_leadership", |s| s.is_leader()) {
2579 Some(v) => v,
2580 None => continue,
2581 };
2582
2583 if is_leader {
2584 log::info!("Became leader for {}", db_name);
2585
2586 #[cfg(feature = "telemetry")]
2588 if let Some(ref metrics) = self.metrics {
2589 let duration_ms = js_sys::Date::now() - start_time;
2590 metrics.leader_election_duration().observe(duration_ms);
2591 metrics.is_leader().set(1.0);
2592 metrics.leadership_changes_total().inc();
2593 }
2594
2595 return Ok(());
2596 }
2597 }
2598
2599 if js_sys::Date::now() - start_time > timeout_ms {
2601 #[cfg(feature = "telemetry")]
2603 if let Some(ref metrics) = self.metrics {
2604 let duration_ms = js_sys::Date::now() - start_time;
2605 metrics.leader_election_duration().observe(duration_ms);
2606 }
2607
2608 return Err(JsValue::from_str("Timeout waiting for leadership"));
2609 }
2610
2611 let promise = js_sys::Promise::new(&mut |resolve, _| {
2613 let window = web_sys::window().expect("should have window");
2614 let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, 100);
2615 });
2616 let _ = wasm_bindgen_futures::JsFuture::from(promise).await;
2617 }
2618 }
2619
2620 #[wasm_bindgen(js_name = "requestLeadership")]
2622 pub async fn request_leadership(&mut self) -> Result<(), JsValue> {
2623 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2624
2625 let db_name = &self.name;
2626 log::debug!("Requesting leadership for {}", db_name);
2627
2628 #[cfg(feature = "telemetry")]
2630 let telemetry_data = if self.metrics.is_some() {
2631 let start_time = js_sys::Date::now();
2632 let was_leader = self
2633 .is_leader_wasm()
2634 .await
2635 .ok()
2636 .and_then(|v| v.as_bool())
2637 .unwrap_or(false);
2638
2639 if let Some(ref metrics) = self.metrics {
2640 metrics.leader_elections_total().inc();
2641 }
2642
2643 Some((start_time, was_leader))
2644 } else {
2645 None
2646 };
2647
2648 let storage_rc = get_storage_with_fallback(db_name);
2649
2650 if let Some(storage) = storage_rc {
2651 {
2652 let result = with_storage_async!(storage, "request_leadership", |s| s
2654 .start_leader_election())
2655 .ok_or_else(|| {
2656 JsValue::from_str("Failed to acquire storage lock for leadership request")
2657 })?;
2658 result.map_err(|e| {
2659 JsValue::from_str(&format!("Failed to request leadership: {}", e))
2660 })?;
2661
2662 log::debug!("Re-election triggered for {}", db_name);
2663 } #[cfg(feature = "telemetry")]
2667 if let Some((start_time, was_leader)) = telemetry_data {
2668 if let Some(ref metrics) = self.metrics {
2669 let duration_ms = js_sys::Date::now() - start_time;
2671 metrics.leader_election_duration().observe(duration_ms);
2672
2673 let is_leader_now = self
2675 .is_leader_wasm()
2676 .await
2677 .ok()
2678 .and_then(|v| v.as_bool())
2679 .unwrap_or(false);
2680
2681 metrics
2683 .is_leader()
2684 .set(if is_leader_now { 1.0 } else { 0.0 });
2685
2686 if was_leader != is_leader_now {
2688 metrics.leadership_changes_total().inc();
2689 }
2690 }
2691 }
2692
2693 Ok(())
2694 } else {
2695 Err(JsValue::from_str(&format!(
2696 "No storage found for database: {}",
2697 db_name
2698 )))
2699 }
2700 }
2701
2702 #[wasm_bindgen(js_name = "getLeaderInfo")]
2704 pub async fn get_leader_info(&mut self) -> Result<JsValue, JsValue> {
2705 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2706
2707 let db_name = &self.name;
2708
2709 let storage_rc = get_storage_with_fallback(db_name);
2710
2711 if let Some(storage) = storage_rc {
2712 let is_leader = with_storage_async!(storage, "get_leader_info", |s| s.is_leader())
2713 .ok_or_else(|| {
2714 JsValue::from_str(&format!(
2715 "Failed to access storage for database: {}",
2716 db_name
2717 ))
2718 })?;
2719
2720 let leader_id_str = if is_leader {
2723 format!("leader_{}", db_name)
2724 } else {
2725 "unknown".to_string()
2726 };
2727
2728 let obj = js_sys::Object::new();
2730 js_sys::Reflect::set(&obj, &"isLeader".into(), &JsValue::from_bool(is_leader))?;
2731 js_sys::Reflect::set(&obj, &"leaderId".into(), &JsValue::from_str(&leader_id_str))?;
2732 js_sys::Reflect::set(
2733 &obj,
2734 &"leaseExpiry".into(),
2735 &JsValue::from_f64(js_sys::Date::now()),
2736 )?;
2737
2738 Ok(obj.into())
2739 } else {
2740 Err(JsValue::from_str(&format!(
2741 "No storage found for database: {}",
2742 db_name
2743 )))
2744 }
2745 }
2746
2747 #[wasm_bindgen(js_name = "queueWrite")]
2758 pub async fn queue_write(&mut self, sql: String) -> Result<(), JsValue> {
2759 self.queue_write_with_timeout(sql, 5000).await
2760 }
2761
2762 #[wasm_bindgen(js_name = "queueWriteWithTimeout")]
2768 pub async fn queue_write_with_timeout(
2769 &mut self,
2770 sql: String,
2771 timeout_ms: u32,
2772 ) -> Result<(), JsValue> {
2773 use crate::storage::write_queue::{WriteQueueMessage, WriteResponse, send_write_request};
2774 use std::cell::RefCell;
2775 use std::rc::Rc;
2776
2777 log::debug!("Queuing write: {}", sql);
2778
2779 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2781 let is_leader = {
2782 let storage_rc = get_storage_with_fallback(&self.name);
2783
2784 if let Some(storage) = storage_rc {
2785 with_storage_async!(storage, "queue_write_is_leader", |s| s.is_leader())
2786 .unwrap_or(false)
2787 } else {
2788 false
2789 }
2790 };
2791
2792 if is_leader {
2793 log::debug!("We are leader, executing directly");
2794 return self
2795 .execute_internal(&sql)
2796 .await
2797 .map(|_| ())
2798 .map_err(|e| JsValue::from_str(&format!("Execute failed: {}", e)));
2799 }
2800
2801 let request_id = send_write_request(&self.name, &sql)
2803 .map_err(|e| JsValue::from_str(&format!("Failed to send write request: {}", e)))?;
2804
2805 log::debug!("Write request sent with ID: {}", request_id);
2806
2807 let response_received = Rc::new(RefCell::new(false));
2809 let response_error = Rc::new(RefCell::new(None::<String>));
2810
2811 let response_received_clone = response_received.clone();
2812 let response_error_clone = response_error.clone();
2813 let request_id_clone = request_id.clone();
2814
2815 let callback = Closure::wrap(Box::new(move |msg: JsValue| {
2817 if let Ok(json_str) = js_sys::JSON::stringify(&msg) {
2819 if let Some(json_str) = json_str.as_string() {
2820 if let Ok(message) = serde_json::from_str::<WriteQueueMessage>(&json_str) {
2821 if let WriteQueueMessage::WriteResponse(response) = message {
2822 match response {
2823 WriteResponse::Success { request_id, .. } => {
2824 if request_id == request_id_clone {
2825 *response_received_clone.borrow_mut() = true;
2826 log::debug!("Write response received: Success");
2827 }
2828 }
2829 WriteResponse::Error {
2830 request_id,
2831 error_message,
2832 } => {
2833 if request_id == request_id_clone {
2834 *response_received_clone.borrow_mut() = true;
2835 *response_error_clone.borrow_mut() = Some(error_message);
2836 log::debug!("Write response received: Error");
2837 }
2838 }
2839 }
2840 }
2841 }
2842 }
2843 }
2844 }) as Box<dyn FnMut(JsValue)>);
2845
2846 use crate::storage::write_queue::register_write_queue_listener;
2848 let callback_fn = callback.as_ref().unchecked_ref();
2849 register_write_queue_listener(&self.name, callback_fn)
2850 .map_err(|e| JsValue::from_str(&format!("Failed to register listener: {}", e)))?;
2851
2852 callback.forget();
2854
2855 let start_time = js_sys::Date::now();
2857 let timeout_f64 = timeout_ms as f64;
2858
2859 loop {
2860 if *response_received.borrow() {
2862 if let Some(error_msg) = response_error.borrow().as_ref() {
2863 return Err(JsValue::from_str(&format!("Write failed: {}", error_msg)));
2864 }
2865 log::info!("Write completed successfully");
2866 return Ok(());
2867 }
2868
2869 let elapsed = js_sys::Date::now() - start_time;
2871 if elapsed > timeout_f64 {
2872 return Err(JsValue::from_str("Write request timed out"));
2873 }
2874
2875 wasm_bindgen_futures::JsFuture::from(js_sys::Promise::new(&mut |resolve, _reject| {
2877 if let Some(window) = web_sys::window() {
2878 let _ =
2879 window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, 100);
2880 } else {
2881 log::error!("Window unavailable in timeout handler");
2882 }
2883 }))
2884 .await
2885 .ok();
2886 }
2887 }
2888
2889 #[wasm_bindgen(js_name = "isLeader")]
2890 pub async fn is_leader_wasm(&self) -> Result<JsValue, JsValue> {
2891 use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
2893
2894 let db_name = &self.name;
2895 log::debug!("isLeader() called for database: {} (self.name)", db_name);
2896
2897 let storage_rc = get_storage_with_fallback(db_name);
2898
2899 if let Some(storage) = storage_rc {
2900 log::debug!("Found storage for {}, calling is_leader()", db_name);
2901 let is_leader = with_storage_async!(storage, "is_leader_wasm", |s| s.is_leader())
2902 .ok_or_else(|| {
2903 JsValue::from_str(&format!(
2904 "Failed to access storage for database: {}",
2905 db_name
2906 ))
2907 })?;
2908 log::debug!("is_leader() = {} for {}", is_leader, db_name);
2909
2910 Ok(JsValue::from_bool(is_leader))
2912 } else {
2913 log::error!("ERROR: No storage found for database: {}", db_name);
2914 Err(JsValue::from_str(&format!(
2915 "No storage found for database: {}",
2916 db_name
2917 )))
2918 }
2919 }
2920
2921 pub async fn is_leader(&self) -> Result<bool, JsValue> {
2923 let result = self.is_leader_wasm().await?;
2924 Ok(result.as_bool().unwrap_or(false))
2925 }
2926
2927 #[wasm_bindgen(js_name = "onDataChange")]
2928 pub fn on_data_change_wasm(&mut self, callback: &js_sys::Function) -> Result<(), JsValue> {
2929 log::debug!("Registering onDataChange callback for {}", self.name);
2930
2931 self.on_data_change_callback = Some(callback.clone());
2933
2934 use crate::storage::broadcast_notifications::register_change_listener;
2936
2937 let db_name = &self.name;
2938 register_change_listener(db_name, callback).map_err(|e| {
2939 JsValue::from_str(&format!("Failed to register change listener: {}", e))
2940 })?;
2941
2942 log::debug!("onDataChange callback registered for {}", self.name);
2943 Ok(())
2944 }
2945
2946 #[wasm_bindgen(js_name = "reloadFromIndexedDB")]
2950 pub async fn reload_from_indexed_db(&mut self) -> Result<(), JsValue> {
2951 log::info!("Reloading data from IndexedDB for {}", self.name);
2952
2953 let db_name = self.name.clone();
2954
2955 let pool_key = db_name.trim_end_matches(".db");
2957 crate::connection_pool::force_close_connection(pool_key);
2958 self.connection_state.db.set(std::ptr::null_mut());
2959 log::info!("[RELOAD] Closed SQLite connection for {}", db_name);
2960
2961 crate::storage::wasm_indexeddb::restore_from_indexeddb_force(&db_name)
2963 .await
2964 .map_err(|e| JsValue::from_str(&format!("Failed to restore from IndexedDB: {}", e)))?;
2965 log::info!("[RELOAD] Restored from IndexedDB for {}", db_name);
2966
2967 use crate::vfs::indexeddb_vfs::STORAGE_REGISTRY;
2969 STORAGE_REGISTRY.with(|reg| unsafe {
2970 let registry = &*reg.get();
2971 if let Some(storage_rc) = registry.get(&db_name) {
2972 storage_rc.reload_cache_from_global_storage();
2973 log::info!("[RELOAD] Reloaded BlockStorage cache for {}", db_name);
2974 }
2975 });
2976
2977 use std::ffi::CString;
2979
2980 let vfs_name = format!("vfs_{}", db_name.trim_end_matches(".db"));
2981 let pool_key = db_name.trim_end_matches(".db").to_string();
2982 let db_name_for_closure = db_name.clone();
2983 let vfs_name_for_closure = vfs_name.clone();
2984
2985 let new_state = crate::connection_pool::get_or_create_connection(&pool_key, || {
2986 let mut db = std::ptr::null_mut();
2987 let db_name_cstr = CString::new(db_name_for_closure.clone())
2988 .map_err(|_| "Invalid database name".to_string())?;
2989 let vfs_cstr = CString::new(vfs_name_for_closure.as_str())
2990 .map_err(|_| "Invalid VFS name".to_string())?;
2991
2992 log::info!(
2993 "[RELOAD] Reopening database: {} with VFS: {}",
2994 db_name_for_closure,
2995 vfs_name_for_closure
2996 );
2997
2998 let ret = unsafe {
2999 sqlite_wasm_rs::sqlite3_open_v2(
3000 db_name_cstr.as_ptr(),
3001 &mut db as *mut _,
3002 sqlite_wasm_rs::SQLITE_OPEN_READWRITE | sqlite_wasm_rs::SQLITE_OPEN_CREATE,
3003 vfs_cstr.as_ptr(),
3004 )
3005 };
3006
3007 if ret != sqlite_wasm_rs::SQLITE_OK {
3008 let err_msg = unsafe {
3009 let msg_ptr = sqlite_wasm_rs::sqlite3_errmsg(db);
3010 if !msg_ptr.is_null() {
3011 std::ffi::CStr::from_ptr(msg_ptr)
3012 .to_string_lossy()
3013 .into_owned()
3014 } else {
3015 "Unknown error".to_string()
3016 }
3017 };
3018 return Err(format!("Failed to reopen database: {}", err_msg));
3019 }
3020
3021 log::info!("[RELOAD] Database reopened successfully");
3022 Ok(db)
3023 })
3024 .map_err(|e| JsValue::from_str(&format!("Failed to reopen connection: {}", e)))?;
3025
3026 self.connection_state = new_state;
3027 log::info!("[RELOAD] Connection state updated for {}", db_name);
3028
3029 Ok(())
3030 }
3031
3032 #[wasm_bindgen(js_name = "enableOptimisticUpdates")]
3034 pub async fn enable_optimistic_updates(&mut self, enabled: bool) -> Result<(), JsValue> {
3035 self.optimistic_updates_manager
3036 .borrow_mut()
3037 .set_enabled(enabled);
3038 log::debug!(
3039 "Optimistic updates {}",
3040 if enabled { "enabled" } else { "disabled" }
3041 );
3042 Ok(())
3043 }
3044
3045 #[wasm_bindgen(js_name = "isOptimisticMode")]
3047 pub async fn is_optimistic_mode(&self) -> bool {
3048 self.optimistic_updates_manager.borrow().is_enabled()
3049 }
3050
3051 #[wasm_bindgen(js_name = "trackOptimisticWrite")]
3053 pub async fn track_optimistic_write(&mut self, sql: String) -> Result<String, JsValue> {
3054 let id = self
3055 .optimistic_updates_manager
3056 .borrow_mut()
3057 .track_write(sql);
3058 Ok(id)
3059 }
3060
3061 #[wasm_bindgen(js_name = "getPendingWritesCount")]
3063 pub async fn get_pending_writes_count(&self) -> usize {
3064 self.optimistic_updates_manager.borrow().get_pending_count()
3065 }
3066
3067 #[wasm_bindgen(js_name = "clearOptimisticWrites")]
3069 pub async fn clear_optimistic_writes(&mut self) -> Result<(), JsValue> {
3070 self.optimistic_updates_manager.borrow_mut().clear_all();
3071 Ok(())
3072 }
3073
3074 #[wasm_bindgen(js_name = "enableCoordinationMetrics")]
3076 pub async fn enable_coordination_metrics(&mut self, enabled: bool) -> Result<(), JsValue> {
3077 self.coordination_metrics_manager
3078 .borrow_mut()
3079 .set_enabled(enabled);
3080 Ok(())
3081 }
3082
3083 #[wasm_bindgen(js_name = "isCoordinationMetricsEnabled")]
3085 pub async fn is_coordination_metrics_enabled(&self) -> bool {
3086 self.coordination_metrics_manager.borrow().is_enabled()
3087 }
3088
3089 #[wasm_bindgen(js_name = "recordLeadershipChange")]
3091 pub async fn record_leadership_change(&mut self, became_leader: bool) -> Result<(), JsValue> {
3092 self.coordination_metrics_manager
3093 .borrow_mut()
3094 .record_leadership_change(became_leader);
3095 Ok(())
3096 }
3097
3098 #[wasm_bindgen(js_name = "recordNotificationLatency")]
3100 pub async fn record_notification_latency(&mut self, latency_ms: f64) -> Result<(), JsValue> {
3101 self.coordination_metrics_manager
3102 .borrow_mut()
3103 .record_notification_latency(latency_ms);
3104 Ok(())
3105 }
3106
3107 #[wasm_bindgen(js_name = "recordWriteConflict")]
3109 pub async fn record_write_conflict(&mut self) -> Result<(), JsValue> {
3110 self.coordination_metrics_manager
3111 .borrow_mut()
3112 .record_write_conflict();
3113 Ok(())
3114 }
3115
3116 #[wasm_bindgen(js_name = "recordFollowerRefresh")]
3118 pub async fn record_follower_refresh(&mut self) -> Result<(), JsValue> {
3119 self.coordination_metrics_manager
3120 .borrow_mut()
3121 .record_follower_refresh();
3122 Ok(())
3123 }
3124
3125 #[wasm_bindgen(js_name = "getCoordinationMetrics")]
3127 pub async fn get_coordination_metrics(&self) -> Result<String, JsValue> {
3128 self.coordination_metrics_manager
3129 .borrow()
3130 .get_metrics_json()
3131 .map_err(|e| JsValue::from_str(&e))
3132 }
3133
3134 #[wasm_bindgen(js_name = "resetCoordinationMetrics")]
3136 pub async fn reset_coordination_metrics(&mut self) -> Result<(), JsValue> {
3137 self.coordination_metrics_manager.borrow_mut().reset();
3138 Ok(())
3139 }
3140}
3141
3142#[cfg(target_arch = "wasm32")]
3144#[wasm_bindgen]
3145pub struct WasmColumnValue {
3146 #[allow(dead_code)]
3147 inner: ColumnValue,
3148}
3149
3150#[cfg(target_arch = "wasm32")]
3151#[wasm_bindgen]
3152impl WasmColumnValue {
3153 #[wasm_bindgen(js_name = "createNull")]
3154 pub fn create_null() -> WasmColumnValue {
3155 WasmColumnValue {
3156 inner: ColumnValue::Null,
3157 }
3158 }
3159
3160 #[wasm_bindgen(js_name = "createInteger")]
3161 pub fn create_integer(value: i64) -> WasmColumnValue {
3162 WasmColumnValue {
3163 inner: ColumnValue::Integer(value),
3164 }
3165 }
3166
3167 #[wasm_bindgen(js_name = "createReal")]
3168 pub fn create_real(value: f64) -> WasmColumnValue {
3169 WasmColumnValue {
3170 inner: ColumnValue::Real(value),
3171 }
3172 }
3173
3174 #[wasm_bindgen(js_name = "createText")]
3175 pub fn create_text(value: String) -> WasmColumnValue {
3176 WasmColumnValue {
3177 inner: ColumnValue::Text(value),
3178 }
3179 }
3180
3181 #[wasm_bindgen(js_name = "createBlob")]
3182 pub fn create_blob(value: &[u8]) -> WasmColumnValue {
3183 WasmColumnValue {
3184 inner: ColumnValue::Blob(value.to_vec()),
3185 }
3186 }
3187
3188 #[wasm_bindgen(js_name = "createBigInt")]
3189 pub fn create_bigint(value: &str) -> WasmColumnValue {
3190 WasmColumnValue {
3191 inner: ColumnValue::BigInt(value.to_string()),
3192 }
3193 }
3194
3195 #[wasm_bindgen(js_name = "createDate")]
3196 pub fn create_date(timestamp: f64) -> WasmColumnValue {
3197 WasmColumnValue {
3198 inner: ColumnValue::Date(timestamp as i64),
3199 }
3200 }
3201
3202 #[wasm_bindgen(js_name = "fromJsValue")]
3203 pub fn from_js_value(value: &JsValue) -> WasmColumnValue {
3204 if value.is_null() || value.is_undefined() {
3205 WasmColumnValue {
3206 inner: ColumnValue::Null,
3207 }
3208 } else if let Some(s) = value.as_string() {
3209 if let Ok(parsed) = s.parse::<i64>() {
3211 WasmColumnValue {
3212 inner: ColumnValue::Integer(parsed),
3213 }
3214 } else {
3215 WasmColumnValue {
3216 inner: ColumnValue::Text(s),
3217 }
3218 }
3219 } else if let Some(n) = value.as_f64() {
3220 if n.fract() == 0.0 && n >= i64::MIN as f64 && n <= i64::MAX as f64 {
3221 WasmColumnValue {
3222 inner: ColumnValue::Integer(n as i64),
3223 }
3224 } else {
3225 WasmColumnValue {
3226 inner: ColumnValue::Real(n),
3227 }
3228 }
3229 } else if value.is_object() {
3230 if js_sys::Date::new(value).get_time().is_finite() {
3232 let timestamp = js_sys::Date::new(value).get_time() as i64;
3233 WasmColumnValue {
3234 inner: ColumnValue::Date(timestamp),
3235 }
3236 } else {
3237 WasmColumnValue {
3239 inner: ColumnValue::Text(format!("{:?}", value)),
3240 }
3241 }
3242 } else {
3243 WasmColumnValue {
3244 inner: ColumnValue::Null,
3245 }
3246 }
3247 }
3248
3249 pub fn null() -> WasmColumnValue {
3253 Self::create_null()
3254 }
3255
3256 pub fn integer(value: f64) -> WasmColumnValue {
3258 Self::create_integer(value as i64)
3259 }
3260
3261 pub fn real(value: f64) -> WasmColumnValue {
3262 Self::create_real(value)
3263 }
3264
3265 pub fn text(value: String) -> WasmColumnValue {
3266 Self::create_text(value)
3267 }
3268
3269 pub fn blob(value: Vec<u8>) -> WasmColumnValue {
3270 Self::create_blob(&value)
3271 }
3272
3273 pub fn big_int(value: String) -> WasmColumnValue {
3274 Self::create_bigint(&value)
3275 }
3276
3277 pub fn date(timestamp_ms: f64) -> WasmColumnValue {
3278 Self::create_date(timestamp_ms)
3279 }
3280}