lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }