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