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 }