lib

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

idb.rs (9468B)


      1 //! Browser event roots follow the qualified local transaction ownership pattern.
      2 use super::BrowserError;
      3 use futures::channel::oneshot;
      4 use js_sys::Uint8Array;
      5 use std::{
      6     cell::{Cell, RefCell},
      7     rc::Rc,
      8 };
      9 use wasm_bindgen::{JsCast, JsValue, closure::Closure};
     10 use web_sys::{
     11     CryptoKey, Event, IdbDatabase, IdbFactory, IdbOpenDbRequest, IdbRequest, IdbTransaction,
     12 };
     13 
     14 const STORE: &str = "provider";
     15 type Callback = Closure<dyn FnMut(Event)>;
     16 
     17 pub(super) struct Seed {
     18     pub key: CryptoKey,
     19     pub binding: Vec<u8>,
     20 }
     21 struct OpenRoots {
     22     request: IdbOpenDbRequest,
     23     _upgrade: Callback,
     24     _success: Callback,
     25     _error: Callback,
     26 }
     27 impl Drop for OpenRoots {
     28     fn drop(&mut self) {
     29         self.request.set_onupgradeneeded(None);
     30         self.request.set_onsuccess(None);
     31         self.request.set_onerror(None);
     32     }
     33 }
     34 pub(super) async fn open(
     35     factory: &IdbFactory,
     36     name: &str,
     37     seed: Option<Seed>,
     38 ) -> Result<IdbDatabase, BrowserError> {
     39     let request = factory
     40         .open_with_u32(name, 1)
     41         .map_err(|_| BrowserError::Unavailable)?;
     42     let create = seed.is_some();
     43     let created = Rc::new(Cell::new(false));
     44     let failure = Rc::new(Cell::new(None));
     45     let (send, observe) = oneshot::channel();
     46     let reply = Rc::new(RefCell::new(Some(send)));
     47     let upgrade = {
     48         let request = request.clone();
     49         let created = created.clone();
     50         let failure = failure.clone();
     51         Closure::new(move |_: Event| {
     52             let result = (|| {
     53                 let seed = seed.as_ref().ok_or(BrowserError::MissingNamespace)?;
     54                 let db = request
     55                     .result()
     56                     .map_err(|_| BrowserError::Unavailable)?
     57                     .dyn_into::<IdbDatabase>()
     58                     .map_err(|_| BrowserError::IncompatibleSchema)?;
     59                 let store = db
     60                     .create_object_store(STORE)
     61                     .map_err(|_| BrowserError::Aborted)?;
     62                 store
     63                     .add_with_key(seed.key.as_ref(), &JsValue::from_str("key"))
     64                     .map_err(|_| BrowserError::Aborted)?;
     65                 store
     66                     .add_with_key(
     67                         &Uint8Array::from(seed.binding.as_slice()),
     68                         &JsValue::from_str("binding"),
     69                     )
     70                     .map_err(|_| BrowserError::Aborted)?;
     71                 created.set(true);
     72                 Ok(())
     73             })();
     74             if let Err(error) = result {
     75                 failure.set(Some(error));
     76                 if let Some(tx) = request.transaction() {
     77                     let _ = tx.abort();
     78                 }
     79             }
     80         })
     81     };
     82     let success = {
     83         let request = request.clone();
     84         let failure = failure.clone();
     85         let created = created.clone();
     86         let reply = reply.clone();
     87         Closure::new(move |_: Event| {
     88             let result = (|| {
     89                 let db = request
     90                     .result()
     91                     .map_err(|_| BrowserError::Unavailable)?
     92                     .dyn_into::<IdbDatabase>()
     93                     .map_err(|_| BrowserError::IncompatibleSchema)?;
     94                 let checked = if let Some(error) = failure.get() {
     95                     Err(error)
     96                 } else if create && !created.get() {
     97                     Err(BrowserError::NamespaceExists)
     98                 } else {
     99                     schema(&db)
    100                 };
    101                 if let Err(error) = checked {
    102                     db.close();
    103                     return Err(error);
    104                 }
    105                 Ok(db)
    106             })();
    107             if let Some(send) = reply.borrow_mut().take() {
    108                 let _ = send.send(result);
    109             }
    110         })
    111     };
    112     let error = {
    113         let request = request.clone();
    114         let failure = failure.clone();
    115         let reply = reply.clone();
    116         Closure::new(move |_: Event| {
    117             let error = failure.get().unwrap_or_else(|| {
    118                 if request
    119                     .error()
    120                     .ok()
    121                     .flatten()
    122                     .is_some_and(|e| e.name() == "VersionError")
    123                 {
    124                     BrowserError::IncompatibleSchema
    125                 } else {
    126                     BrowserError::Aborted
    127                 }
    128             });
    129             if let Some(send) = reply.borrow_mut().take() {
    130                 let _ = send.send(Err(error));
    131             }
    132         })
    133     };
    134     request.set_onupgradeneeded(Some(upgrade.as_ref().unchecked_ref()));
    135     request.set_onsuccess(Some(success.as_ref().unchecked_ref()));
    136     request.set_onerror(Some(error.as_ref().unchecked_ref()));
    137     let _roots = OpenRoots {
    138         request,
    139         _upgrade: upgrade,
    140         _success: success,
    141         _error: error,
    142     };
    143     observe.await.unwrap_or(Err(BrowserError::CommitUnknown))
    144 }
    145 fn schema(db: &IdbDatabase) -> Result<(), BrowserError> {
    146     if db.version() != 1.0
    147         || db.object_store_names().length() != 1
    148         || !db.object_store_names().contains(STORE)
    149     {
    150         return Err(BrowserError::IncompatibleSchema);
    151     }
    152     let tx = db
    153         .transaction_with_str(STORE)
    154         .map_err(|_| BrowserError::Unavailable)?;
    155     let store = tx
    156         .object_store(STORE)
    157         .map_err(|_| BrowserError::IncompatibleSchema)?;
    158     if store.auto_increment()
    159         || !store
    160             .key_path()
    161             .map_err(|_| BrowserError::IncompatibleSchema)?
    162             .is_null()
    163         || store.index_names().length() != 0
    164     {
    165         return Err(BrowserError::IncompatibleSchema);
    166     }
    167     Ok(())
    168 }
    169 struct Terminal {
    170     tx: IdbTransaction,
    171     observe: oneshot::Receiver<Result<(), BrowserError>>,
    172     _complete: Callback,
    173     _abort: Callback,
    174 }
    175 impl Terminal {
    176     fn new(tx: IdbTransaction) -> Self {
    177         let (send, observe) = oneshot::channel();
    178         let reply = Rc::new(RefCell::new(Some(send)));
    179         let complete = {
    180             let reply = reply.clone();
    181             Closure::new(move |_: Event| {
    182                 if let Some(send) = reply.borrow_mut().take() {
    183                     let _ = send.send(Ok(()));
    184                 }
    185             })
    186         };
    187         let abort = Closure::new(move |_: Event| {
    188             if let Some(send) = reply.borrow_mut().take() {
    189                 let _ = send.send(Err(BrowserError::Aborted));
    190             }
    191         });
    192         tx.set_oncomplete(Some(complete.as_ref().unchecked_ref()));
    193         tx.set_onabort(Some(abort.as_ref().unchecked_ref()));
    194         Self {
    195             tx,
    196             observe,
    197             _complete: complete,
    198             _abort: abort,
    199         }
    200     }
    201     async fn wait(&mut self) -> Result<(), BrowserError> {
    202         (&mut self.observe)
    203             .await
    204             .unwrap_or(Err(BrowserError::CommitUnknown))
    205     }
    206 }
    207 impl Drop for Terminal {
    208     fn drop(&mut self) {
    209         self.tx.set_oncomplete(None);
    210         self.tx.set_onabort(None);
    211     }
    212 }
    213 struct ReadRoot {
    214     request: IdbRequest,
    215     _success: Callback,
    216 }
    217 impl Drop for ReadRoot {
    218     fn drop(&mut self) {
    219         self.request.set_onsuccess(None);
    220     }
    221 }
    222 pub(super) async fn load(db: &IdbDatabase) -> Result<(CryptoKey, Vec<u8>), BrowserError> {
    223     let tx = db
    224         .transaction_with_str(STORE)
    225         .map_err(|_| BrowserError::Closed)?;
    226     let mut terminal = Terminal::new(tx.clone());
    227     let store = match tx.object_store(STORE) {
    228         Ok(store) => store,
    229         Err(_) => {
    230             let _ = tx.abort();
    231             terminal.wait().await?;
    232             return Err(BrowserError::IncompatibleSchema);
    233         }
    234     };
    235     let values = Rc::new(RefCell::new([None, None, None]));
    236     let mut roots = Vec::with_capacity(3);
    237     for index in 0..3 {
    238         let request = match index {
    239             0 => store.get(&JsValue::from_str("key")),
    240             1 => store.get(&JsValue::from_str("binding")),
    241             _ => store.count(),
    242         };
    243         let request = match request {
    244             Ok(request) => request,
    245             Err(_) => {
    246                 let _ = tx.abort();
    247                 terminal.wait().await?;
    248                 return Err(BrowserError::IncompatibleSchema);
    249             }
    250         };
    251         let success = {
    252             let request = request.clone();
    253             let values = values.clone();
    254             let tx = tx.clone();
    255             Closure::new(move |_: Event| match request.result() {
    256                 Ok(value) => values.borrow_mut()[index] = Some(value),
    257                 Err(_) => {
    258                     let _ = tx.abort();
    259                 }
    260             })
    261         };
    262         request.set_onsuccess(Some(success.as_ref().unchecked_ref()));
    263         roots.push(ReadRoot {
    264             request,
    265             _success: success,
    266         });
    267     }
    268     terminal.wait().await?;
    269     let mut values = values.borrow_mut();
    270     let key = values[0].take().ok_or(BrowserError::CommitUnknown)?;
    271     if key.is_undefined() {
    272         return Err(BrowserError::MissingKey);
    273     }
    274     let key = key
    275         .dyn_into::<CryptoKey>()
    276         .map_err(|_| BrowserError::KeyMismatch)?;
    277     let binding = values[1]
    278         .take()
    279         .ok_or(BrowserError::CommitUnknown)?
    280         .dyn_into::<Uint8Array>()
    281         .map_err(|_| BrowserError::KeyMismatch)?;
    282     if binding.length() > 170
    283         || binding.length() < 42
    284         || values[2].take().and_then(|v| v.as_f64()) != Some(2.0)
    285     {
    286         return Err(BrowserError::IncompatibleSchema);
    287     }
    288     Ok((key, binding.to_vec()))
    289 }