1use crate::types::DatabaseError;
2use wasm_bindgen::prelude::*;
3
4#[inline]
45pub fn normalize_db_name(name: &str) -> String {
46 if name.ends_with(".db") {
47 name.to_string()
48 } else {
49 format!("{}.db", name)
50 }
51}
52
53#[wasm_bindgen]
54extern "C" {
55 #[wasm_bindgen(js_namespace = console)]
56 fn log(s: &str);
57}
58
59#[derive(Debug, Clone)]
61pub struct MemoryInfo {
62 pub available_bytes: u64,
64 pub total_bytes: Option<u64>,
66 pub used_bytes: Option<u64>,
68}
69
70pub fn console_log(message: &str) {
72 log(message);
73}
74
75pub fn format_bytes(bytes: usize) -> String {
77 const UNITS: &[&str] = &["B", "KB", "MB", "GB"];
78 const THRESHOLD: f64 = 1024.0;
79
80 if bytes == 0 {
81 return "0 B".to_string();
82 }
83
84 let mut size = bytes as f64;
85 let mut unit_index = 0;
86
87 while size >= THRESHOLD && unit_index < UNITS.len() - 1 {
88 size /= THRESHOLD;
89 unit_index += 1;
90 }
91
92 if unit_index == 0 {
93 format!("{} {}", bytes, UNITS[unit_index])
94 } else {
95 format!("{:.1} {}", size, UNITS[unit_index])
96 }
97}
98
99pub fn generate_id() -> String {
101 let timestamp = js_sys::Date::now() as u64;
102 let random = (js_sys::Math::random() * 1000000.0) as u32;
103 format!("{}_{}", timestamp, random)
104}
105
106pub fn validate_sql(sql: &str) -> Result<(), String> {
108 let sql_lower = sql.to_lowercase();
109
110 let dangerous_keywords = ["drop", "delete", "truncate", "alter"];
112
113 for keyword in dangerous_keywords {
114 if sql_lower.contains(keyword) {
115 return Err(format!(
116 "Potentially dangerous SQL keyword detected: {}",
117 keyword
118 ));
119 }
120 }
121
122 Ok(())
123}
124
125pub fn check_available_memory() -> Option<MemoryInfo> {
148 #[cfg(target_arch = "wasm32")]
149 {
150 check_memory_wasm()
152 }
153
154 #[cfg(not(target_arch = "wasm32"))]
155 {
156 check_memory_native()
158 }
159}
160
161#[cfg(target_arch = "wasm32")]
163fn check_memory_wasm() -> Option<MemoryInfo> {
164 let estimated_total: u64 = 2 * 1024 * 1024 * 1024; let estimated_available: u64 = 1536 * 1024 * 1024; let estimated_used: u64 = estimated_total - estimated_available;
176
177 log::debug!(
178 "WASM memory estimate (conservative): {} MB available, {} MB total",
179 estimated_available / (1024 * 1024),
180 estimated_total / (1024 * 1024)
181 );
182
183 Some(MemoryInfo {
184 available_bytes: estimated_available,
185 total_bytes: Some(estimated_total),
186 used_bytes: Some(estimated_used),
187 })
188}
189
190#[cfg(not(target_arch = "wasm32"))]
192fn check_memory_native() -> Option<MemoryInfo> {
193 #[cfg(target_os = "linux")]
194 {
195 check_memory_linux()
196 }
197
198 #[cfg(target_os = "macos")]
199 {
200 check_memory_macos()
201 }
202
203 #[cfg(target_os = "windows")]
204 {
205 check_memory_windows()
206 }
207
208 #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
209 {
210 None
212 }
213}
214
215#[cfg(target_os = "linux")]
217fn check_memory_linux() -> Option<MemoryInfo> {
218 use std::fs;
219
220 let meminfo = fs::read_to_string("/proc/meminfo").ok()?;
221
222 let mut mem_available = None;
223 let mut mem_total = None;
224
225 for line in meminfo.lines() {
226 if line.starts_with("MemAvailable:") {
227 mem_available = line
228 .split_whitespace()
229 .nth(1)
230 .and_then(|s| s.parse::<u64>().ok())
231 .map(|kb| kb * 1024); } else if line.starts_with("MemTotal:") {
233 mem_total = line
234 .split_whitespace()
235 .nth(1)
236 .and_then(|s| s.parse::<u64>().ok())
237 .map(|kb| kb * 1024); }
239
240 if mem_available.is_some() && mem_total.is_some() {
241 break;
242 }
243 }
244
245 let available_bytes = mem_available?;
246 let total = mem_total;
247 let used = total.map(|t| t.saturating_sub(available_bytes));
248
249 Some(MemoryInfo {
250 available_bytes,
251 total_bytes: total,
252 used_bytes: used,
253 })
254}
255
256#[cfg(target_os = "macos")]
258fn check_memory_macos() -> Option<MemoryInfo> {
259 use std::process::Command;
260
261 let vm_stat_output = Command::new("vm_stat").output().ok()?;
263 let vm_stat_str = String::from_utf8_lossy(&vm_stat_output.stdout);
264
265 let mut page_size = 4096u64; let mut pages_free = 0u64;
267 let mut pages_inactive = 0u64;
268
269 for line in vm_stat_str.lines() {
270 if line.contains("page size of") {
271 if let Some(size_str) = line.split("page size of ").nth(1) {
272 if let Some(size) = size_str.split_whitespace().next() {
273 page_size = size.parse().unwrap_or(4096);
274 }
275 }
276 } else if line.starts_with("Pages free:") {
277 pages_free = line
278 .split(':')
279 .nth(1)
280 .and_then(|s| s.trim().trim_end_matches('.').parse().ok())
281 .unwrap_or(0);
282 } else if line.starts_with("Pages inactive:") {
283 pages_inactive = line
284 .split(':')
285 .nth(1)
286 .and_then(|s| s.trim().trim_end_matches('.').parse().ok())
287 .unwrap_or(0);
288 }
289 }
290
291 let available_bytes = (pages_free + pages_inactive) * page_size;
292
293 let total_output = Command::new("sysctl").arg("hw.memsize").output().ok()?;
295
296 let total_str = String::from_utf8_lossy(&total_output.stdout);
297 let total_bytes = total_str
298 .split(':')
299 .nth(1)
300 .and_then(|s| s.trim().parse().ok());
301
302 Some(MemoryInfo {
303 available_bytes,
304 total_bytes,
305 used_bytes: total_bytes.map(|t| t.saturating_sub(available_bytes)),
306 })
307}
308
309#[cfg(target_os = "windows")]
311fn check_memory_windows() -> Option<MemoryInfo> {
312 use std::mem;
313
314 #[repr(C)]
315 struct MemoryStatusEx {
316 dw_length: u32,
317 dw_memory_load: u32,
318 ull_total_phys: u64,
319 ull_avail_phys: u64,
320 ull_total_page_file: u64,
321 ull_avail_page_file: u64,
322 ull_total_virtual: u64,
323 ull_avail_virtual: u64,
324 ull_avail_extended_virtual: u64,
325 }
326
327 unsafe extern "system" {
328 unsafe fn GlobalMemoryStatusEx(lp_buffer: *mut MemoryStatusEx) -> i32;
329 }
330
331 unsafe {
332 let mut mem_status: MemoryStatusEx = mem::zeroed();
333 mem_status.dw_length = mem::size_of::<MemoryStatusEx>() as u32;
334
335 if GlobalMemoryStatusEx(&mut mem_status) == 0 {
336 return None;
337 }
338
339 let available_bytes = mem_status.ull_avail_phys;
340 let total_bytes = mem_status.ull_total_phys;
341 let used_bytes = total_bytes.saturating_sub(available_bytes);
342
343 Some(MemoryInfo {
344 available_bytes,
345 total_bytes: Some(total_bytes),
346 used_bytes: Some(used_bytes),
347 })
348 }
349}
350
351pub fn estimate_export_memory_requirement(database_size_bytes: u64) -> u64 {
375 const BLOCK_BUFFER_SIZE: u64 = 20 * 1024 * 1024; const OVERHEAD_MULTIPLIER: f64 = 1.5; const SAFETY_MARGIN: f64 = 1.2; let base_requirement = database_size_bytes as f64 * OVERHEAD_MULTIPLIER;
386 let with_buffers = base_requirement + BLOCK_BUFFER_SIZE as f64;
387 let with_safety = with_buffers * SAFETY_MARGIN;
388
389 with_safety as u64
390}
391
392pub fn validate_memory_for_export(database_size_bytes: u64) -> Result<(), DatabaseError> {
416 let required_memory = estimate_export_memory_requirement(database_size_bytes);
417
418 match check_available_memory() {
419 Some(mem_info) => {
420 if mem_info.available_bytes < required_memory {
421 let available_mb = mem_info.available_bytes as f64 / (1024.0 * 1024.0);
422 let required_mb = required_memory as f64 / (1024.0 * 1024.0);
423
424 return Err(DatabaseError::new(
425 "INSUFFICIENT_MEMORY",
426 &format!(
427 "Insufficient memory for export. Available: {:.1} MB, Required: {:.1} MB. \
428 Consider using streaming export with smaller chunk sizes or closing other applications.",
429 available_mb, required_mb
430 ),
431 ));
432 }
433
434 log::info!(
436 "Memory check passed: {} MB available, {} MB required for export",
437 mem_info.available_bytes / (1024 * 1024),
438 required_memory / (1024 * 1024)
439 );
440
441 Ok(())
442 }
443 None => {
444 log::warn!(
446 "Cannot determine available memory. Proceeding with export of {} MB database. \
447 Monitor memory usage carefully.",
448 database_size_bytes / (1024 * 1024)
449 );
450
451 Ok(())
452 }
453 }
454}
455
456#[cfg(test)]
457mod tests {
458 use super::*;
459
460 #[test]
461 fn test_format_bytes() {
462 assert_eq!(format_bytes(0), "0 B");
463 assert_eq!(format_bytes(512), "512 B");
464 assert_eq!(format_bytes(1024), "1.0 KB");
465 assert_eq!(format_bytes(1536), "1.5 KB");
466 assert_eq!(format_bytes(1048576), "1.0 MB");
467 }
468
469 #[test]
470 fn test_validate_sql() {
471 assert!(validate_sql("SELECT * FROM users").is_ok());
472 assert!(validate_sql("INSERT INTO users (name) VALUES ('test')").is_ok());
473 assert!(validate_sql("DROP TABLE users").is_err());
474 assert!(validate_sql("DELETE FROM users WHERE id = 1").is_err());
475 }
476
477 #[test]
478 fn test_normalize_db_name() {
479 assert_eq!(normalize_db_name("mydb.db"), "mydb.db");
481 assert_eq!(normalize_db_name("test.db"), "test.db");
482
483 assert_eq!(normalize_db_name("mydb"), "mydb.db");
485 assert_eq!(normalize_db_name("test"), "test.db");
486
487 assert_eq!(normalize_db_name(""), ".db");
489 assert_eq!(normalize_db_name("a"), "a.db");
490 assert_eq!(normalize_db_name("my.database"), "my.database.db");
491
492 assert_eq!(normalize_db_name("mydb_backup"), "mydb_backup.db");
494 assert_eq!(normalize_db_name("testdb"), "testdb.db");
495 }
496
497 #[test]
498 fn test_normalize_db_name_idempotent() {
499 let names = vec!["mydb", "test.db", "complex.name.db", "simple"];
501 for name in names {
502 let once = normalize_db_name(name);
503 let twice = normalize_db_name(&once);
504 assert_eq!(
505 once, twice,
506 "normalize_db_name should be idempotent for '{}'",
507 name
508 );
509 }
510 }
511}