Skip to main content

absurder_sql/
lib.rs

1#[cfg(target_arch = "wasm32")]
2use std::rc::Rc;
3#[cfg(target_arch = "wasm32")]
4use wasm_bindgen::prelude::*;
5
6// Conditional rusqlite import: same crate, different features
7// Make this public so child crates can use it
8// When encryption is enabled, rusqlite uses bundled-sqlcipher-vendored-openssl feature
9// When bundled-sqlite is enabled, rusqlite uses bundled feature
10#[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// Enable better panic messages and memory allocation
22#[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// Initialize logging infrastructure for WASM
30#[cfg(all(target_arch = "wasm32", feature = "console_log"))]
31#[wasm_bindgen(start)]
32pub fn init_logger() {
33    // Initialize console_log for browser logging
34    // Use Info level for production, Debug for development
35    #[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// Use centralized normalize_db_name from utils - SINGLE SOURCE OF TRUTH
46// See utils.rs for documentation and rationale
47#[cfg(target_arch = "wasm32")]
48use crate::utils::normalize_db_name;
49
50// Module declarations
51mod 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// Re-export main public API
67#[cfg(not(target_arch = "wasm32"))]
68pub use database::SqliteIndexedDB;
69
70// WASM: Track databases currently being opened to serialize SQLite connection initialization
71#[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// Type alias for native platforms
78#[cfg(not(target_arch = "wasm32"))]
79pub type Database = SqliteIndexedDB;
80
81pub use types::DatabaseConfig;
82pub use types::{ColumnValue, DatabaseError, QueryResult, Row, TransactionOptions};
83
84// Re-export VFS
85pub use vfs::indexeddb_vfs::IndexedDBVFS;
86
87/// DRY macro for async storage operations with interior mutability
88#[cfg(target_arch = "wasm32")]
89macro_rules! with_storage_async {
90    ($storage:expr, $operation:expr, |$s:ident| $body:expr) => {{
91        // BlockStorage uses RefCell for interior mutability, no outer borrow needed
92        let $s = &*$storage;
93        Some($body.await)
94    }};
95}
96
97// WASM Database implementation using sqlite-wasm-rs
98#[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    /// Get the SQLite database pointer from the shared connection
122    /// Uses Cell::get() to avoid RefCell borrow checking - eliminates reentrancy panics
123    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    /// Check if a SQL statement is a write operation
132    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    /// Get metrics for observability
141    ///
142    /// Returns a reference to the Metrics instance for tracking queries, errors, and performance
143    #[cfg(feature = "telemetry")]
144    pub fn metrics(&self) -> Option<&crate::telemetry::Metrics> {
145        self.metrics.as_ref()
146    }
147
148    /// Check write permission - only leader can write (unless override enabled)
149    async fn check_write_permission(&mut self, sql: &str) -> Result<(), DatabaseError> {
150        if !Self::is_write_operation(sql) {
151            // Not a write operation, allow it
152            return Ok(());
153        }
154
155        // Check if non-leader writes are allowed
156        if self.allow_non_leader_writes {
157            log::info!("WRITE_ALLOWED: Non-leader writes enabled for {}", self.name);
158            return Ok(());
159        }
160
161        // Check if this instance is the leader
162        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            // No storage found - allow by default (single-instance mode)
186            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        // CRITICAL: Use DRY helper to normalize name WITH .db extension
225        // This ensures Database.name, GLOBAL_STORAGE keys, and IndexedDB keys all match
226        let normalized_name = normalize_db_name(&config.name);
227
228        // Use a unique VFS name per database to avoid interference
229        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            // Create and register VFS only if it doesn't exist
239            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            // Ensure BlockStorage exists for this database in the registry
247            // The existing VFS will find it via STORAGE_REGISTRY
248            let _vfs = crate::vfs::IndexedDBVFS::new(&normalized_name).await?;
249            log::info!("BlockStorage ensured for {}", normalized_name);
250        }
251
252        // CRITICAL: Synchronize SQLite connection opening to prevent WAL initialization conflicts
253        // Wait if another task is currently opening a connection to this database
254        #[cfg(target_arch = "wasm32")]
255        {
256            const MAX_OPEN_WAIT_MS: u32 = 1000; // Reduced from 5000 - 1s is sufficient
257            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 // Someone else is opening
265                    } else {
266                        set.insert(config.name.clone());
267                        true // We got it
268                    }
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        // Use connection pooling to share connections between instances
301        let (connection_state, db) = {
302            let vfs_name_str = vfs_name.clone(); // Capture the VFS name to use in closure
303            let filename_copy = normalized_name.clone(); // Capture filename for logging
304            let pool_key = normalized_name.trim_end_matches(".db").to_string(); // Pool uses name without .db
305            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        // Apply configuration options via PRAGMA statements
375        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        // CRITICAL: Set busy_timeout FIRST to handle concurrent access
408        // This makes SQLite wait and retry for up to 10 seconds when the database is locked
409        // instead of immediately returning SQLITE_BUSY errors during parallel operations
410        log::debug!("Setting busy_timeout to 10000ms for concurrent access handling");
411        exec_sql(db, "PRAGMA busy_timeout = 10000")?;
412
413        // Apply page_size (must be set before any tables are created)
414        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        // Apply cache_size
420        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        // Apply journal_mode
426        // WAL mode is now fully supported via shared memory (xShm*) implementation
427        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        // Apply auto_vacuum (must be set before any tables are created)
474        if let Some(auto_vacuum) = config.auto_vacuum {
475            let vacuum_mode = if auto_vacuum { 1 } else { 0 }; // 0=none, 1=full, 2=incremental
476            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        // Initialize metrics for telemetry
483        #[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(), // CRITICAL: Use normalized name WITH .db to match registry
494            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        // CRITICAL: Release the SQLite open lock ONLY after Database is fully constructed
512        // This ensures WAL initialization and all setup completes before another instance can start
513        #[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    /// Open a database with a specific VFS using connection pooling
527    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        // Normalize the database name WITH .db extension
533        let normalized_name = normalize_db_name(filename);
534        let pool_key = normalized_name.trim_end_matches(".db").to_string();
535
536        // Use connection pooling with custom VFS
537        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        // Initialize metrics for telemetry
581        #[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, // CRITICAL: Store normalized name WITH .db
592            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), // Default 2GB limit
607        })
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        // Create span for query execution and enter context
615        #[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            // Attach baggage from context
628            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            // Enter span context
635            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        // Track query execution metrics
645        #[cfg(feature = "telemetry")]
646        #[cfg(feature = "telemetry")]
647        if let Some(metrics) = &self.metrics {
648            metrics.queries_total().inc();
649        }
650
651        // Validate connection pointer before using it
652        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                // Get actual error message from SQLite
676                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                // Track error
686                #[cfg(feature = "telemetry")]
687                #[cfg(feature = "telemetry")]
688                if let Some(metrics) = &self.metrics {
689                    metrics.errors_total().inc();
690                }
691
692                // Finish span with error
693                #[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                    // Exit span context
705                    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            // Get column names
722            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            // Execute and fetch rows
737            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                    // Get SQLite error message before finalizing
788                    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                    // Track error
800                    #[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            // Track query duration
816            #[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            // Non-SELECT statements - Use prepare/step to properly handle PRAGMA results
830            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                // Get actual error message from SQLite
843                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                // Track error
853                #[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            // Get column info for PRAGMA statements that return results
865            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                // This is a PRAGMA or other statement that returns rows
871                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                // Fetch all rows
886                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                        // Get SQLite error message before finalizing
919                        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                        // Track error
931                        #[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                // Regular non-SELECT statement
944                let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
945                if step_ret != sqlite_wasm_rs::SQLITE_DONE {
946                    // Get SQLite error message before finalizing
947                    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                    // Track error
959                    #[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            // Finalize to complete the statement
972            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            // Track query duration
984            #[cfg(feature = "telemetry")]
985            if let Some(metrics) = &self.metrics {
986                metrics.query_duration().observe(execution_time_ms);
987            }
988
989            // Finish span successfully
990            #[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                // Exit span context
1005                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        // Create span for query execution
1029        #[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        // Ensure metrics are propagated to BlockStorage before execution
1047        #[cfg(feature = "telemetry")]
1048        self.ensure_metrics_propagated();
1049
1050        // Track query execution metrics
1051        #[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            // Get actual error message from SQLite
1072            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            // Track error
1082            #[cfg(feature = "telemetry")]
1083            if let Some(metrics) = &self.metrics {
1084                metrics.errors_total().inc();
1085            }
1086
1087            // Finish span with error
1088            #[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        // Bind parameters
1106        let mut text_cstrings = Vec::new(); // Keep CStrings alive
1107        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                        // Sanitize string by removing null bytes (SQLite text shouldn't contain them)
1120                        let sanitized = val.replace('\0', "");
1121                        // Safe: after removing null bytes, CString::new cannot fail
1122                        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); // Keep alive
1132                        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                // Track error
1148                #[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            // Get column names
1164            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            // Execute and fetch rows
1179            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                    // Get SQLite error message before finalizing
1230                    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                    // Track error
1242                    #[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            // Track query duration
1259            #[cfg(feature = "telemetry")]
1260            if let Some(metrics) = &self.metrics {
1261                metrics.query_duration().observe(execution_time_ms);
1262            }
1263
1264            // Finish span successfully for SELECT query
1265            #[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            // Non-SELECT statements
1287            let step_ret = unsafe { sqlite_wasm_rs::sqlite3_step(stmt) };
1288            // Track error
1289            #[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            // Track query duration
1316            #[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            // Finish span successfully
1328            #[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    /// Set telemetry metrics for this database instance
1352    #[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    /// Set span recorder for distributed tracing
1359    #[cfg(feature = "telemetry")]
1360    pub fn set_span_recorder(&mut self, recorder: Option<crate::telemetry::SpanRecorder>) {
1361        self.span_recorder = recorder;
1362    }
1363
1364    /// Get span context for distributed tracing
1365    #[cfg(feature = "telemetry")]
1366    pub fn get_span_context(&self) -> Option<&crate::telemetry::SpanContext> {
1367        self.span_context.as_ref()
1368    }
1369
1370    /// Get span recorder for distributed tracing
1371    #[cfg(feature = "telemetry")]
1372    pub fn get_span_recorder(&self) -> Option<&crate::telemetry::SpanRecorder> {
1373        self.span_recorder.as_ref()
1374    }
1375    /// Ensure metrics are propagated to BlockStorage
1376    #[cfg(feature = "telemetry")]
1377    fn ensure_metrics_propagated(&self) {
1378        // Propagate metrics to BlockStorage via STORAGE_REGISTRY
1379        #[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        // Check if connection is already null (e.g., after import force-close)
1403        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        // Checkpoint WAL data before close using PASSIVE mode (non-blocking)
1412        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        // Sync to IndexedDB before closing to ensure data persists
1419        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        // Stop leader election before closing
1428        #[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        // NOTE: Do NOT call release_connection here
1461        // The Drop impl will handle releasing the connection when the Database instance is dropped
1462        // Calling it here would cause a double-release when both close() and Drop are called
1463
1464        log::info!(
1465            "Closed database: {} (connection will be released on Drop)",
1466            self.name
1467        );
1468        Ok(())
1469    }
1470
1471    /// Query database and return rows (alias for execute that returns rows)
1472    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        // Start timing for telemetry
1479        #[cfg(all(target_arch = "wasm32", feature = "telemetry"))]
1480        let start_time = js_sys::Date::now();
1481
1482        // Create span for VFS sync operation with automatic context linking
1483        #[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            // Automatically link to parent span via context and copy baggage
1489            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            // Enter this span's context
1498            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        // Track sync operation start
1508        #[cfg(feature = "telemetry")]
1509        if let Some(ref metrics) = self.metrics {
1510            metrics.sync_operations_total().inc();
1511        }
1512
1513        // Track blocks persisted for span attributes
1514        #[cfg(feature = "telemetry")]
1515        let mut blocks_count = 0;
1516
1517        // Trigger VFS sync to persist all blocks to IndexedDB
1518        #[cfg(target_arch = "wasm32")]
1519        {
1520            use crate::storage::vfs_sync;
1521
1522            // CRITICAL: Checkpoint WAL and flush page cache to ensure all data is in GLOBAL_STORAGE
1523            let db_ptr = self.connection_state.db.get();
1524            if !db_ptr.is_null() {
1525                // Step 1: Checkpoint WAL to write all WAL data to main database
1526                // TRUNCATE mode ensures WAL is cleared after checkpoint
1527                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                // Step 2: Flush page cache to VFS
1548                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            // Collect blocks from GLOBAL_STORAGE (where VFS writes them)
1555            // CRITICAL: Use self.name WITH .db - matches main branch behavior
1556            // Database.name already normalized by normalize_db_name() in Database::new()
1557            let storage_name = &self.name;
1558
1559            // Advance commit marker
1560            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            // Send notification after successful sync
1710            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(&notification) {
1722                log::warn!("Failed to send change notification: {}", e);
1723                // Don't fail the sync if notification fails
1724            }
1725        }
1726
1727        // Record sync duration
1728        #[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        // Finish span successfully
1735        #[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            // Exit span context
1763            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        // Release the connection back to the pool
1778        // The pool will close it if this was the last reference
1779        // Pool uses name without .db, so strip it
1780        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        // CRITICAL: Stop heartbeat interval synchronously to prevent leaks
1786        use crate::vfs::indexeddb_vfs::get_storage_with_fallback;
1787        if let Some(storage_rc) = get_storage_with_fallback(&self.name) {
1788            // No outer borrow needed - BlockStorage uses RefCell for interior mutability
1789            let storage = &*storage_rc;
1790            // Try to borrow manager - if it fails, skip (already being cleaned)
1791            if let Ok(mut manager_ref) = storage.leader_election.try_borrow_mut() {
1792                if let Some(ref mut manager) = *manager_ref {
1793                    // Clear interval if it exists (idempotent)
1794                    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                    // Note: heartbeat closure is intentionally leaked (via forget())
1807                    // and becomes a no-op when heartbeat_valid is set to false
1808                }
1809            } else {
1810                // Manager already borrowed - skip (first DB is cleaning up)
1811                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        // Keep BlockStorage in STORAGE_REGISTRY so multiple Database instances
1822        // with the same name share the same BlockStorage and leader election state
1823        // Blocks persist in GLOBAL_STORAGE across Database instances
1824        log::debug!(
1825            "Closed database: {} (BlockStorage remains in registry)",
1826            self.name
1827        );
1828    }
1829}
1830
1831// Add wasm_bindgen exports for the main Database struct
1832#[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        // Normalize database name: ensure it has .db suffix
1838        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        // Start listening for write queue requests (leader will process them)
1851        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    /// Get the database name
1913    #[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    /// Get all database names stored in IndexedDB
1930    ///
1931    /// Returns an array of database names (sorted alphabetically)
1932    #[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        // Get databases from persistent list (localStorage)
1942        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        // Get databases from STORAGE_REGISTRY (currently open)
1956        // SAFETY: WASM is single-threaded, no concurrent access possible
1957        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        // Get databases from GLOBAL_STORAGE (in-memory persistent storage)
1967        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        // Convert to sorted vector
1979        let mut result_vec: Vec<String> = db_names.into_iter().collect();
1980        result_vec.sort();
1981
1982        // Convert to JavaScript array
1983        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    /// Delete a database from storage
1995    ///
1996    /// Removes database from both STORAGE_REGISTRY and GLOBAL_STORAGE
1997    #[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        // Normalize database name
2004        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        // Remove from STORAGE_REGISTRY
2013        use crate::vfs::indexeddb_vfs::remove_storage_from_registry;
2014        remove_storage_from_registry(&normalized_name);
2015
2016        // Remove from GLOBAL_STORAGE
2017        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        // Remove from GLOBAL_METADATA
2026        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        // Remove from commit markers
2035        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        // Delete from IndexedDB (typed web-sys API — no eval, so it works under
2048        // MV3's strict CSP where 'unsafe-eval' is forbidden).
2049        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        // Remove from persistent list
2078        Self::remove_database_from_persistent_list(&normalized_name)?;
2079
2080        Ok(())
2081    }
2082
2083    /// Add database name to persistent list in localStorage
2084    #[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    /// Add database name to persistent list in localStorage
2104    #[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    /// Remove database name from persistent list in localStorage
2162    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    /// Get database names from persistent list in localStorage
2188    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    /// Start listening for write queue requests (leader processes these)
2225    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            // Parse the message
2237            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                            // Check if we're the leader
2244                            let storage_rc = get_storage_with_fallback(&db_name_inner);
2245
2246                            if let Some(storage) = storage_rc {
2247                                // Spawn async task to process the write
2248                                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                                    // Create a temporary database instance to execute the SQL
2268                                    match Database::new_wasm(db_name_inner.clone()).await {
2269                                        Ok(mut db) => {
2270                                            // Execute the SQL
2271                                            match db.execute_internal(&request.sql).await {
2272                                                Ok(result) => {
2273                                                    // Send success response
2274                                                    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                                                    // Send error response
2297                                                    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        // Check write permission before executing
2343        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        // Check write permission before executing
2364        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, &params)
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    /// Force close connection and remove from pool (for test cleanup)
2383    #[wasm_bindgen(js_name = "forceCloseConnection")]
2384    pub async fn force_close_connection(&mut self) -> Result<(), JsValue> {
2385        // First do normal close to cleanup
2386        let _ = self.close_internal().await;
2387
2388        // Then force-remove from connection pool
2389        // Pool uses name without .db, so strip it
2390        let pool_key = self.name.trim_end_matches(".db");
2391        crate::connection_pool::force_close_connection(pool_key);
2392
2393        // CRITICAL: Single source of truth for ALL cleanup
2394        #[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    /// Allow non-leader writes (for single-tab apps or testing)
2412    #[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    /// Export database to SQLite .db file format
2420    ///
2421    /// Returns the complete database as a Uint8Array that can be downloaded
2422    /// or saved as a standard SQLite .db file.
2423    ///
2424    /// # Example
2425    /// ```javascript
2426    /// const dbBytes = await db.exportToFile();
2427    /// const blob = new Blob([dbBytes], { type: 'application/x-sqlite3' });
2428    /// const url = URL.createObjectURL(blob);
2429    /// const a = document.createElement('a');
2430    /// a.href = url;
2431    /// a.download = 'database.db';
2432    /// a.click();
2433    /// ```
2434    #[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            // Get storage and sync AFTER lock - this ensures only one export syncs at a time
2443            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            // CRITICAL: Checkpoint WAL to flush SQLite data to VFS blocks before export
2451            // Without this, data stays in SQLite's WAL buffer and doesn't appear in exported bytes
2452            log::info!("[EXPORT] ===== Step 4: Checkpointing WAL");
2453            if !self.connection_state.db.get().is_null() {
2454                // Use raw SQLite call since export_to_file takes &self, not &mut self
2455                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            // Reload after checkpoint so the awaited sync/export path sees the canonical
2477            // post-checkpoint block state instead of any stale pre-checkpoint cache.
2478            #[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    /// Test method for concurrent locking - simple increment counter
2513    #[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        // Simulate some work
2526        let result = value + 1;
2527
2528        // Small delay to test serialization
2529        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    /// Import SQLite database from .db file bytes
2545    ///
2546    /// Replaces the current database contents with the imported data.
2547    /// This will close the current database connection and clear all existing data.
2548    ///
2549    /// # Arguments
2550    /// * `file_data` - SQLite .db file as Uint8Array
2551    ///
2552    /// # Returns
2553    /// * `Ok(())` - Import successful
2554    /// * `Err(JsValue)` - Import failed (invalid file, validation error, etc.)
2555    ///
2556    /// # Example
2557    /// ```javascript
2558    /// // From file input
2559    /// const fileInput = document.getElementById('dbFile');
2560    /// const file = fileInput.files[0];
2561    /// const arrayBuffer = await file.arrayBuffer();
2562    /// const uint8Array = new Uint8Array(arrayBuffer);
2563    ///
2564    /// await db.importFromFile(uint8Array);
2565    ///
2566    /// // Database is immediately usable after import (no reopen needed)
2567    /// const result = await db.execute('SELECT * FROM imported_table');
2568    /// ```
2569    ///
2570    /// # Warning
2571    /// This operation is destructive and will replace all existing database data.
2572    #[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    /// Wait for this instance to become leader
2673    #[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        // Track leader election attempt
2678        #[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; // 5 second timeout
2687
2688        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                    // Record telemetry on successful leadership acquisition
2702                    #[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            // Check timeout
2715            if js_sys::Date::now() - start_time > timeout_ms {
2716                // Record telemetry on timeout
2717                #[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            // Wait a bit before checking again
2727            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    /// Request leadership (triggers re-election check)
2736    #[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        // Record telemetry data before the request
2744        #[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                // Trigger leader election
2768                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            } // Drop the borrow here
2779
2780            // Record telemetry after election (after dropping borrow)
2781            #[cfg(feature = "telemetry")]
2782            if let Some((start_time, was_leader)) = telemetry_data {
2783                if let Some(ref metrics) = self.metrics {
2784                    // Record election duration
2785                    let duration_ms = js_sys::Date::now() - start_time;
2786                    metrics.leader_election_duration().observe(duration_ms);
2787
2788                    // Check if leadership status changed
2789                    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                    // Update is_leader gauge
2797                    metrics
2798                        .is_leader()
2799                        .set(if is_leader_now { 1.0 } else { 0.0 });
2800
2801                    // Track leadership changes
2802                    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    /// Get leader information
2818    #[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            // Get leader info - we'll use simpler data for now
2836            // Real implementation would need public getters on BlockStorage
2837            let leader_id_str = if is_leader {
2838                format!("leader_{}", db_name)
2839            } else {
2840                "unknown".to_string()
2841            };
2842
2843            // Create JavaScript object
2844            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    /// Queue a write operation to be executed by the leader
2863    ///
2864    /// Non-leader tabs can use this to request writes from the leader.
2865    /// The write is forwarded via BroadcastChannel and executed by the leader.
2866    ///
2867    /// # Arguments
2868    /// * `sql` - SQL statement to execute (must be a write operation)
2869    ///
2870    /// # Returns
2871    /// Result indicating success or failure
2872    #[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    /// Queue a write operation with a specific timeout
2878    ///
2879    /// # Arguments
2880    /// * `sql` - SQL statement to execute
2881    /// * `timeout_ms` - Timeout in milliseconds
2882    #[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        // Check if we're the leader - if so, just execute directly
2895        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        // Send write request to leader
2917        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        // Wait for response with timeout
2923        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        // Set up listener for response
2931        let callback = Closure::wrap(Box::new(move |msg: JsValue| {
2932            // Parse the message
2933            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        // Register listener
2962        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        // Keep callback alive
2968        callback.forget();
2969
2970        // Wait for response with polling (timeout_ms)
2971        let start_time = js_sys::Date::now();
2972        let timeout_f64 = timeout_ms as f64;
2973
2974        loop {
2975            // Check if response received
2976            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            // Check timeout
2985            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            // Wait a bit before checking again
2991            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        // Get the storage from STORAGE_REGISTRY
3007        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            // Return as JsValue boolean
3026            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    /// Check if this instance is the leader (non-wasm version for internal use/tests)
3037    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        // Store the callback
3047        self.on_data_change_callback = Some(callback.clone());
3048
3049        // Register listener for BroadcastChannel notifications from other tabs
3050        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    /// Reload data from IndexedDB into memory
3062    /// Call this when another tab has written data and you need to see the changes
3063    /// This closes and reopens the SQLite connection to invalidate its page cache
3064    #[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        // Step 1: Close the SQLite connection to invalidate page cache
3071        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        // Step 2: Restore from IndexedDB into global storage (force reload)
3077        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        // Step 3: Reload BlockStorage cache from global storage
3083        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        // Step 4: Reopen the SQLite connection
3093        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    /// Enable or disable optimistic updates mode
3148    #[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    /// Check if optimistic mode is enabled
3161    #[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    /// Track an optimistic write
3167    #[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    /// Get count of pending writes
3177    #[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    /// Clear all optimistic writes
3183    #[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    /// Enable or disable coordination metrics tracking
3190    #[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    /// Check if coordination metrics tracking is enabled
3199    #[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    /// Record a leadership change
3205    #[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    /// Record a notification latency in milliseconds
3214    #[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    /// Record a write conflict (non-leader write attempt)
3223    #[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    /// Record a follower refresh
3232    #[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    /// Get coordination metrics as JSON string
3241    #[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    /// Reset all coordination metrics
3250    #[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// Export WasmColumnValue for WASM
3258#[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            // Check if it's a large number string
3325            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            // Check if it's a Date
3346            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                // Convert to string for other objects
3353                WasmColumnValue {
3354                    inner: ColumnValue::Text(format!("{:?}", value)),
3355                }
3356            }
3357        } else {
3358            WasmColumnValue {
3359                inner: ColumnValue::Null,
3360            }
3361        }
3362    }
3363
3364    // --- Rust-friendly alias constructors used in wasm tests ---
3365    // These mirror the create* methods but with simpler names and
3366    // argument types matching test usage.
3367    pub fn null() -> WasmColumnValue {
3368        Self::create_null()
3369    }
3370
3371    // Tests call integer(42.0), so accept f64 and cast to i64.
3372    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}