browser.rs (22870B)
1 use super::{ 2 Batch, Commit, Error, LIVE_BYTES_MAX, Mutation, Namespace, OpenMode, RECORD_BYTES_MAX, 3 RecordKey, 4 }; 5 use futures::channel::oneshot; 6 use js_sys::{ArrayBuffer, Function, Object, Reflect, Uint8Array}; 7 use std::{ 8 cell::{Cell, RefCell}, 9 future::poll_fn, 10 rc::{Rc, Weak}, 11 task::{Poll, Waker}, 12 }; 13 use wasm_bindgen::{JsCast, JsValue, closure::Closure}; 14 use wasm_bindgen_futures::spawn_local; 15 use web_sys::{ 16 Event, IdbCursorWithValue, IdbDatabase, IdbFactory, IdbKeyRange, IdbObjectStore, 17 IdbOpenDbRequest, IdbRequest, IdbTransaction, IdbTransactionMode, 18 }; 19 20 #[cfg(feature = "workspace")] 21 mod snapshot; 22 #[cfg(feature = "workspace")] 23 pub use snapshot::{ReadSnapshot, RecordPrefix}; 24 25 const STORE: &str = "records"; 26 const WORK_MAX: usize = 32; 27 type EventCallback = Closure<dyn FnMut(Event)>; 28 29 fn classify(value: JsValue) -> Error { 30 match value 31 .dyn_ref::<web_sys::DomException>() 32 .map(web_sys::DomException::name) 33 .as_deref() 34 { 35 Some("QuotaExceededError") => Error::Capacity, 36 Some("VersionError") => Error::IncompatibleSchema, 37 Some("InvalidStateError") => Error::Closed, 38 _ => Error::Unavailable, 39 } 40 } 41 fn key(value: RecordKey) -> JsValue { 42 Uint8Array::from(value.as_bytes().as_slice()).into() 43 } 44 fn bytes(value: JsValue) -> Result<Option<Vec<u8>>, Error> { 45 if value.is_undefined() { 46 return Ok(None); 47 } 48 let value = value 49 .dyn_into::<Uint8Array>() 50 .map_err(|_| Error::CorruptRecord)?; 51 if value.length() as usize > RECORD_BYTES_MAX { 52 return Err(Error::CorruptRecord); 53 } 54 Ok(Some(value.to_vec())) 55 } 56 57 fn record_key(raw: JsValue) -> Result<RecordKey, Error> { 58 let view = if let Some(view) = raw.dyn_ref::<Uint8Array>() { 59 view.clone() 60 } else if raw.is_instance_of::<ArrayBuffer>() { 61 Uint8Array::new(&raw) 62 } else { 63 return Err(Error::CorruptRecord); 64 }; 65 if view.length() != 32 { 66 return Err(Error::CorruptRecord); 67 } 68 let mut value = [0; 32]; 69 view.copy_to(&mut value); 70 Ok(RecordKey::new(value)) 71 } 72 fn lookup(store: &IdbObjectStore, record: RecordKey) -> Result<IdbRequest, JsValue> { 73 let range = IdbKeyRange::only(&key(record))?; 74 store.open_cursor_with_range(range.as_ref()) 75 } 76 fn lookup_value(request: &IdbRequest, expected: RecordKey) -> Result<Option<Vec<u8>>, Error> { 77 let value = request.result().map_err(classify)?; 78 if value.is_null() { 79 return Ok(None); 80 } 81 let cursor = value 82 .dyn_into::<IdbCursorWithValue>() 83 .map_err(|_| Error::CorruptRecord)?; 84 if record_key(cursor.key().map_err(classify)?)? != expected { 85 return Err(Error::CorruptRecord); 86 } 87 // A cursor distinguishes absent keys from stored undefined. Undefined is 88 // foreign data, never permission to overwrite an allegedly missing value. 89 let value = bytes(cursor.value().map_err(classify)?)?.ok_or(Error::CorruptRecord)?; 90 Ok(Some(value)) 91 } 92 93 fn write_transaction(db: &IdbDatabase) -> Result<IdbTransaction, Error> { 94 // The pinned web-sys options binding requires a global unstable cfg. Keep 95 // that compiler input unchanged and use the checked standard host method. 96 let options = Object::new(); 97 if !Reflect::set(&options, &"durability".into(), &"strict".into()).map_err(classify)? { 98 return Err(Error::Unavailable); 99 } 100 let method = Reflect::get(db, &"transaction".into()) 101 .map_err(classify)? 102 .dyn_into::<Function>() 103 .map_err(|_| Error::Unavailable)?; 104 let tx = method 105 .call3(db, &STORE.into(), &"readwrite".into(), &options) 106 .map_err(classify)? 107 .dyn_into::<IdbTransaction>() 108 .map_err(|_| Error::Unavailable)?; 109 if Reflect::get(&tx, &"durability".into()) 110 .map_err(classify)? 111 .as_string() 112 .as_deref() 113 != Some("strict") 114 { 115 let _ = tx.abort(); 116 return Err(Error::Unavailable); 117 } 118 Ok(tx) 119 } 120 121 struct State { 122 db: IdbDatabase, 123 closing: Cell<bool>, 124 count: Cell<usize>, 125 bytes: Cell<usize>, 126 waiters: RefCell<Vec<Weak<RefCell<Option<Waker>>>>>, 127 version_change: RefCell<Option<EventCallback>>, 128 } 129 impl State { 130 fn detach_callbacks(&self) { 131 self.db.set_onversionchange(None); 132 let retired = { self.version_change.borrow_mut().take() }; 133 drop(retired); 134 } 135 fn stop(&self) { 136 self.closing.set(true); 137 if self.count.get() == 0 { 138 self.db.close(); 139 } 140 self.wake(); 141 } 142 fn wake(&self) { 143 self.waiters.borrow_mut().retain(|weak| { 144 if let Some(signal) = weak.upgrade() { 145 if let Some(waker) = signal.borrow_mut().take() { 146 waker.wake(); 147 } 148 true 149 } else { 150 false 151 } 152 }); 153 } 154 fn admit(self: &Rc<Self>, bytes: usize) -> Result<Work, Error> { 155 if self.closing.get() { 156 return Err(Error::Closed); 157 } 158 let total = self.bytes.get().checked_add(bytes).ok_or(Error::Capacity)?; 159 if self.count.get() >= WORK_MAX || total > LIVE_BYTES_MAX { 160 return Err(Error::Capacity); 161 } 162 self.count.set(self.count.get() + 1); 163 self.bytes.set(total); 164 Ok(Work { 165 state: self.clone(), 166 bytes, 167 }) 168 } 169 } 170 impl Drop for State { 171 fn drop(&mut self) { 172 self.db.set_onversionchange(None); 173 self.db.close(); 174 } 175 } 176 struct Work { 177 state: Rc<State>, 178 bytes: usize, 179 } 180 impl Drop for Work { 181 fn drop(&mut self) { 182 self.state.count.set(self.state.count.get() - 1); 183 self.state.bytes.set(self.state.bytes.get() - self.bytes); 184 if self.state.closing.get() && self.state.count.get() == 0 { 185 self.state.db.close(); 186 } 187 self.state.wake(); 188 } 189 } 190 191 /// One explicit connection. Clones share admission, accepted work and closure. 192 /// Independent opens use independent handles; IndexedDB serializes conflicts. 193 #[derive(Clone)] 194 pub struct Database { 195 state: Rc<State>, 196 } 197 impl Database { 198 /// Explicitly opens the exact namespace. Dropped observation cannot leak a 199 /// subsequently opened connection or cancel an accepted schema transaction. 200 pub async fn open(namespace: Namespace, mode: OpenMode) -> Result<Self, Error> { 201 let factory = Reflect::get(&js_sys::global(), &JsValue::from_str("indexedDB")) 202 .map_err(classify)? 203 .dyn_into::<IdbFactory>() 204 .map_err(|_| Error::Unavailable)?; 205 let request = factory 206 .open_with_u32(&namespace.name(), 1) 207 .map_err(classify)?; 208 let (send, observe) = oneshot::channel(); 209 spawn_local(async move { 210 let _ = send.send(open(request, mode).await); 211 }); 212 observe.await.unwrap_or(Err(Error::Unavailable)) 213 } 214 /// Reads exact bytes, acknowledging the read transaction only on complete. 215 /// Missing is distinct from an empty value and from a missing namespace. 216 pub async fn get(&self, record: RecordKey) -> Result<Option<Vec<u8>>, Error> { 217 let work = self.state.admit(RECORD_BYTES_MAX)?; 218 let (send, observe) = oneshot::channel(); 219 spawn_local(async move { 220 let owner = work; 221 let result = match owner 222 .state 223 .db 224 .transaction_with_str_and_mode(STORE, IdbTransactionMode::Readonly) 225 { 226 Ok(tx) => read(tx, record).await, 227 Err(error) => Err(classify(error)), 228 }; 229 let _ = send.send(result); 230 }); 231 observe.await.unwrap_or(Err(Error::CommitUnknown)) 232 } 233 /// Atomically compares original values and installs all replacements. 234 /// All requests are enqueued in active callbacks; no user future runs 235 /// inside a transaction. Only the complete event returns a Commit. 236 pub async fn compare_exchange(&self, batch: Batch) -> Result<Commit, Error> { 237 self.exchange(batch, None).await 238 } 239 /// Runs a trusted host's synchronous eligibility check in each active 240 /// write callback. Refusal aborts the whole transaction, including earlier 241 /// writes. Captures must obey the concrete host's retained-input budget. 242 pub async fn compare_exchange_checked( 243 &self, 244 batch: Batch, 245 guard: impl Fn() -> bool + 'static, 246 ) -> Result<Commit, Error> { 247 self.exchange(batch, Some(Rc::new(guard))).await 248 } 249 async fn exchange( 250 &self, 251 batch: Batch, 252 guard: Option<Rc<dyn Fn() -> bool>>, 253 ) -> Result<Commit, Error> { 254 let work = self.state.admit(batch.bytes)?; 255 let (send, observe) = oneshot::channel(); 256 spawn_local(async move { 257 let owner = work; 258 let result = match write_transaction(&owner.state.db) { 259 Ok(tx) => exchange(tx, batch, guard).await, 260 Err(error) => Err(error), 261 }; 262 let _ = send.send(result); 263 }); 264 observe.await.unwrap_or(Err(Error::CommitUnknown)) 265 } 266 /// Stops admission immediately when polled, drains every accepted job and 267 /// closes the connection and detaches callbacks even while closed handles 268 /// remain alive. A cancelled observer can explicitly resume close. 269 pub async fn close(&self) -> Result<(), Error> { 270 self.state.stop(); 271 if self.state.count.get() == 0 { 272 self.state.detach_callbacks(); 273 return Ok(()); 274 } 275 let signal = Rc::new(RefCell::new(None)); 276 { 277 let mut waiters = self.state.waiters.borrow_mut(); 278 waiters.retain(|weak| weak.strong_count() > 0); 279 if waiters.len() >= WORK_MAX { 280 return Err(Error::Capacity); 281 } 282 waiters.push(Rc::downgrade(&signal)); 283 } 284 poll_fn(|cx| { 285 if self.state.count.get() == 0 { 286 return Poll::Ready(()); 287 } 288 *signal.borrow_mut() = Some(cx.waker().clone()); 289 Poll::Pending 290 }) 291 .await; 292 self.state.detach_callbacks(); 293 Ok(()) 294 } 295 } 296 297 struct OpenHandlers { 298 request: IdbOpenDbRequest, 299 _upgrade: Closure<dyn FnMut(Event)>, 300 _success: Closure<dyn FnMut(Event)>, 301 _error: Closure<dyn FnMut(Event)>, 302 } 303 impl Drop for OpenHandlers { 304 fn drop(&mut self) { 305 self.request.set_onupgradeneeded(None); 306 self.request.set_onsuccess(None); 307 self.request.set_onerror(None); 308 } 309 } 310 async fn open(request: IdbOpenDbRequest, mode: OpenMode) -> Result<Database, Error> { 311 let created = Rc::new(Cell::new(false)); 312 let failure = Rc::new(Cell::new(None)); 313 let (send, observe) = oneshot::channel(); 314 let reply = Rc::new(RefCell::new(Some(send))); 315 let upgrade = { 316 let request = request.clone(); 317 let created = created.clone(); 318 let failure = failure.clone(); 319 Closure::new(move |_: Event| { 320 let result = (|| { 321 if mode == OpenMode::Existing { 322 return Err(Error::MissingNamespace); 323 } 324 let db = request 325 .result() 326 .map_err(classify)? 327 .dyn_into::<IdbDatabase>() 328 .map_err(|_| Error::IncompatibleSchema)?; 329 db.create_object_store(STORE).map_err(classify)?; 330 created.set(true); 331 Ok(()) 332 })(); 333 if let Err(error) = result { 334 failure.set(Some(error)); 335 if let Some(tx) = request.transaction() { 336 let _ = tx.abort(); 337 } 338 } 339 }) 340 }; 341 let success = { 342 let request = request.clone(); 343 let created = created.clone(); 344 let failure = failure.clone(); 345 let reply = reply.clone(); 346 Closure::new(move |_: Event| { 347 let result = (|| { 348 let db = request 349 .result() 350 .map_err(classify)? 351 .dyn_into::<IdbDatabase>() 352 .map_err(|_| Error::IncompatibleSchema)?; 353 let validation = if let Some(error) = failure.get() { 354 Err(error) 355 } else if mode == OpenMode::CreateNew && !created.get() { 356 Err(Error::NamespaceExists) 357 } else { 358 validate_schema(&db) 359 }; 360 if let Err(error) = validation { 361 db.close(); 362 return Err(error); 363 } 364 let state = Rc::new(State { 365 db, 366 closing: Cell::new(false), 367 count: Cell::new(0), 368 bytes: Cell::new(0), 369 waiters: RefCell::new(Vec::new()), 370 version_change: RefCell::new(None), 371 }); 372 let weak = Rc::downgrade(&state); 373 let changed = Closure::new(move |_: Event| { 374 if let Some(state) = weak.upgrade() { 375 state.stop(); 376 state.db.close(); 377 } 378 }); 379 state 380 .db 381 .set_onversionchange(Some(changed.as_ref().unchecked_ref())); 382 *state.version_change.borrow_mut() = Some(changed); 383 Ok(Database { state }) 384 })(); 385 if let Some(send) = reply.borrow_mut().take() { 386 let _ = send.send(result); 387 } 388 }) 389 }; 390 let error = { 391 let request = request.clone(); 392 let reply = reply.clone(); 393 let failure = failure.clone(); 394 Closure::new(move |_: Event| { 395 let error = failure.get().unwrap_or_else(|| { 396 request 397 .error() 398 .ok() 399 .flatten() 400 .map(|e| classify(e.into())) 401 .unwrap_or(Error::Unavailable) 402 }); 403 if let Some(send) = reply.borrow_mut().take() { 404 let _ = send.send(Err(error)); 405 } 406 }) 407 }; 408 request.set_onupgradeneeded(Some(upgrade.as_ref().unchecked_ref())); 409 request.set_onsuccess(Some(success.as_ref().unchecked_ref())); 410 request.set_onerror(Some(error.as_ref().unchecked_ref())); 411 let _handlers = OpenHandlers { 412 request, 413 _upgrade: upgrade, 414 _success: success, 415 _error: error, 416 }; 417 observe.await.unwrap_or(Err(Error::Unavailable)) 418 } 419 fn validate_schema(db: &IdbDatabase) -> Result<(), Error> { 420 if db.version() != 1.0 421 || db.object_store_names().length() != 1 422 || !db.object_store_names().contains(STORE) 423 { 424 return Err(Error::IncompatibleSchema); 425 } 426 let tx = db.transaction_with_str(STORE).map_err(classify)?; 427 let store = tx.object_store(STORE).map_err(classify)?; 428 if store.auto_increment() 429 || !store.key_path().map_err(classify)?.is_null() 430 || store.index_names().length() != 0 431 { 432 return Err(Error::IncompatibleSchema); 433 } 434 Ok(()) 435 } 436 437 struct Completion { 438 tx: IdbTransaction, 439 result: oneshot::Receiver<Result<(), Error>>, 440 _complete: Closure<dyn FnMut(Event)>, 441 _abort: Closure<dyn FnMut(Event)>, 442 _error: Closure<dyn FnMut(Event)>, 443 } 444 impl Completion { 445 fn new(tx: IdbTransaction, failure: Rc<Cell<Option<Error>>>) -> Self { 446 let (send, result) = oneshot::channel(); 447 let reply = Rc::new(RefCell::new(Some(send))); 448 let complete = { 449 let reply = reply.clone(); 450 let failure = failure.clone(); 451 Closure::new(move |_: Event| { 452 // An observed local refusal must never become a committed claim if 453 // an unexpected host failed to abort the transaction. 454 let result = if failure.get().is_some() { 455 Err(Error::CommitUnknown) 456 } else { 457 Ok(()) 458 }; 459 if let Some(send) = reply.borrow_mut().take() { 460 let _ = send.send(result); 461 } 462 }) 463 }; 464 let abort = { 465 let tx = tx.clone(); 466 let failure = failure.clone(); 467 Closure::new(move |_: Event| { 468 let error = failure.get().unwrap_or_else(|| { 469 tx.error() 470 .map(|e| { 471 if e.name() == "QuotaExceededError" { 472 Error::Capacity 473 } else { 474 Error::Aborted 475 } 476 }) 477 .unwrap_or(Error::Aborted) 478 }); 479 if let Some(send) = reply.borrow_mut().take() { 480 let _ = send.send(Err(error)); 481 } 482 }) 483 }; 484 let error = { 485 let tx = tx.clone(); 486 let failure = failure.clone(); 487 Closure::new(move |event: Event| { 488 let quota = event 489 .target() 490 .and_then(|target| target.dyn_into::<IdbRequest>().ok()) 491 .and_then(|request| request.error().ok().flatten()) 492 .is_some_and(|error| error.name() == "QuotaExceededError"); 493 // Remember asynchronous request failure even if another host 494 // listener prevents its default abort. Unexpected completion 495 // then remains unknown, never a successful partial batch. 496 refuse( 497 &tx, 498 &failure, 499 if quota { 500 Error::Capacity 501 } else { 502 Error::Aborted 503 }, 504 ); 505 }) 506 }; 507 tx.set_oncomplete(Some(complete.as_ref().unchecked_ref())); 508 tx.set_onabort(Some(abort.as_ref().unchecked_ref())); 509 tx.set_onerror(Some(error.as_ref().unchecked_ref())); 510 Self { 511 tx, 512 result, 513 _complete: complete, 514 _abort: abort, 515 _error: error, 516 } 517 } 518 async fn wait(&mut self) -> Result<(), Error> { 519 (&mut self.result) 520 .await 521 .unwrap_or(Err(Error::CommitUnknown)) 522 } 523 } 524 impl Drop for Completion { 525 fn drop(&mut self) { 526 self.tx.set_oncomplete(None); 527 self.tx.set_onabort(None); 528 self.tx.set_onerror(None); 529 } 530 } 531 struct RequestHandler { 532 request: IdbRequest, 533 _success: Closure<dyn FnMut(Event)>, 534 } 535 impl Drop for RequestHandler { 536 fn drop(&mut self) { 537 self.request.set_onsuccess(None); 538 } 539 } 540 fn refuse(tx: &IdbTransaction, failure: &Cell<Option<Error>>, error: Error) { 541 if failure.get().is_none() { 542 failure.set(Some(error)); 543 } 544 let _ = tx.abort(); 545 } 546 async fn read(tx: IdbTransaction, record: RecordKey) -> Result<Option<Vec<u8>>, Error> { 547 let failure = Rc::new(Cell::new(None)); 548 let mut completion = Completion::new(tx.clone(), failure.clone()); 549 let value = Rc::new(RefCell::new(None)); 550 let request = match tx 551 .object_store(STORE) 552 .and_then(|store| lookup(&store, record)) 553 { 554 Ok(request) => request, 555 Err(error) => { 556 refuse(&tx, &failure, classify(error)); 557 completion.wait().await?; 558 return Err(Error::CommitUnknown); 559 } 560 }; 561 let success = { 562 let request = request.clone(); 563 let value = value.clone(); 564 let tx = tx.clone(); 565 Closure::new(move |_: Event| match lookup_value(&request, record) { 566 Ok(result) => *value.borrow_mut() = Some(result), 567 Err(error) => refuse(&tx, &failure, error), 568 }) 569 }; 570 request.set_onsuccess(Some(success.as_ref().unchecked_ref())); 571 let _handler = RequestHandler { 572 request, 573 _success: success, 574 }; 575 completion.wait().await?; 576 value.borrow_mut().take().ok_or(Error::CommitUnknown) 577 } 578 async fn exchange( 579 tx: IdbTransaction, 580 batch: Batch, 581 guard: Option<Rc<dyn Fn() -> bool>>, 582 ) -> Result<Commit, Error> { 583 let failure = Rc::new(Cell::new(None)); 584 let mut completion = Completion::new(tx.clone(), failure.clone()); 585 let mut handlers = Vec::with_capacity(batch.entries.len()); 586 let count = batch.entries.len(); 587 let store = match tx.object_store(STORE) { 588 Ok(store) => store, 589 Err(error) => { 590 refuse(&tx, &failure, classify(error)); 591 completion.wait().await?; 592 return Err(Error::CommitUnknown); 593 } 594 }; 595 queue_batch(&store, &tx, batch, guard, &failure, &mut handlers); 596 completion.wait().await?; 597 Ok(Commit { records: count }) 598 } 599 600 fn queue_batch( 601 store: &IdbObjectStore, 602 tx: &IdbTransaction, 603 batch: Batch, 604 guard: Option<Rc<dyn Fn() -> bool>>, 605 failure: &Rc<Cell<Option<Error>>>, 606 handlers: &mut Vec<RequestHandler>, 607 ) { 608 // All reads are queued in this active turn. Each callback queues its write 609 // synchronously; any later conflict aborts every earlier write atomically. 610 for entry in batch.entries { 611 let request = match lookup(store, entry.key) { 612 Ok(request) => request, 613 Err(error) => { 614 refuse(tx, failure, classify(error)); 615 break; 616 } 617 }; 618 let success = { 619 let request = request.clone(); 620 let store = store.clone(); 621 let tx = tx.clone(); 622 let failure = failure.clone(); 623 let guard = guard.clone(); 624 Closure::new(move |_: Event| { 625 if failure.get().is_some() { 626 return; 627 } 628 if guard.as_ref().is_some_and(|check| !check()) { 629 refuse(&tx, &failure, Error::GuardRefused); 630 return; 631 } 632 if let Err(error) = apply(&store, &request, &entry) { 633 refuse(&tx, &failure, error); 634 } 635 }) 636 }; 637 request.set_onsuccess(Some(success.as_ref().unchecked_ref())); 638 handlers.push(RequestHandler { 639 request, 640 _success: success, 641 }); 642 } 643 } 644 fn apply(store: &IdbObjectStore, request: &IdbRequest, entry: &Mutation) -> Result<(), Error> { 645 let actual = lookup_value(request, entry.key)?; 646 if actual != entry.expected { 647 return Err(Error::Conflict); 648 } 649 match &entry.replacement { 650 Some(value) => store.put_with_key(&Uint8Array::from(value.as_slice()), &key(entry.key)), 651 None => store.delete(&key(entry.key)), 652 } 653 .map_err(classify)?; 654 Ok(()) 655 }