allow executing any requests inside the versionchange transaction

Author: Ekleog

README.md

@@ -33,7 +33,11 @@ async fn example() -> anyhow::Result<()> {
     let db = factory
         .open("database", 1, |evt| async move {
             let db = evt.database();
-            db.build_object_store("store").auto_increment().create()?;
+            let store = db.build_object_store("store").auto_increment().create()?;
+
+            // You can also add objects from this callback
+            store.add(&JsString::from("foo")).await?;
+
             Ok(())
         })
         .await
@@ -44,8 +48,8 @@ async fn example() -> anyhow::Result<()> {
         .rw()
         .run(|t| async move {
             let store = t.object_store("store")?;
-            store.add(&JsString::from("foo")).await?;
             store.add(&JsString::from("bar")).await?;
+            store.add(&JsString::from("baz")).await?;
             Ok(())
         })
         .await?;
@@ -69,9 +73,9 @@ async fn example() -> anyhow::Result<()> {
         .rw()
         .run(|t| async move {
             let store = t.object_store("store")?;
-            store.add(&JsString::from("baz")).await?;
-            if store.count().await? > 2 {
-                // Oops! In this example, we have 3 items by this point
+            store.add(&JsString::from("quux")).await?;
+            if store.count().await? > 3 {
+                // Oops! In this example, we have 4 items by this point
                 Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
                     "Too many objects in store",
@@ -86,7 +90,7 @@ async fn example() -> anyhow::Result<()> {
     db.transaction(&["store"])
         .run(|t| async move {
             let num_items = t.object_store("store")?.count().await?;
-            assert_eq!(num_items, 2);
+            assert_eq!(num_items, 3);
             Ok(())
         })
         .await?;

examples/basic.rs

@@ -12,7 +12,11 @@ async fn example() -> anyhow::Result<()> {
     let db = factory
         .open("database", 1, |evt| async move {
             let db = evt.database();
-            db.build_object_store("store").auto_increment().create()?;
+            let store = db.build_object_store("store").auto_increment().create()?;
+
+            // You can also add objects from this callback
+            store.add(&JsString::from("foo")).await?;
+
             Ok(())
         })
         .await
@@ -23,8 +27,8 @@ async fn example() -> anyhow::Result<()> {
         .rw()
         .run(|t| async move {
             let store = t.object_store("store")?;
-            store.add(&JsString::from("foo")).await?;
             store.add(&JsString::from("bar")).await?;
+            store.add(&JsString::from("baz")).await?;
             Ok(())
         })
         .await?;
@@ -48,9 +52,9 @@ async fn example() -> anyhow::Result<()> {
         .rw()
         .run(|t| async move {
             let store = t.object_store("store")?;
-            store.add(&JsString::from("baz")).await?;
-            if store.count().await? > 2 {
-                // Oops! In this example, we have 3 items by this point
+            store.add(&JsString::from("quux")).await?;
+            if store.count().await? > 3 {
+                // Oops! In this example, we have 4 items by this point
                 Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
                     "Too many objects in store",
@@ -65,7 +69,7 @@ async fn example() -> anyhow::Result<()> {
     db.transaction(&["store"])
         .run(|t| async move {
             let num_items = t.object_store("store")?.count().await?;
-            assert_eq!(num_items, 2);
+            assert_eq!(num_items, 3);
             Ok(())
         })
         .await?;

src/factory.rs

@@ -1,4 +1,4 @@
-use crate::{utils::generic_request, Database};
+use crate::{transaction::TransactionPoller, utils::generic_request, Database, Transaction};
 use futures_channel::oneshot;
 use futures_util::{
     future::{self, Either},
@@ -127,7 +127,14 @@ impl<Err: 'static> Factory<Err> {
                 completion?;
             }
             Either::Left((evt, completion_fut)) => {
-                on_upgrade_needed(evt.expect("Closure dropped before its end of scope")).await?;
+                let evt = evt.expect("Closure dropped before its end of scope");
+                let transaction = evt.transaction().as_sys().clone();
+                TransactionPoller {
+                    fut: on_upgrade_needed(evt),
+                    transaction,
+                    pending_requests: 0,
+                }
+                .await?;
                 completion_fut.await?;
             }
         }
@@ -147,21 +154,31 @@ impl<Err: 'static> Factory<Err> {
 pub struct VersionChangeEvent<Err> {
     sys: IdbVersionChangeEvent,
     db: Database<Err>,
+    transaction: Transaction<Err>,
 }
 
 impl<Err> VersionChangeEvent<Err> {
     fn from_sys(sys: IdbVersionChangeEvent) -> VersionChangeEvent<Err> {
-        let db_sys = sys
+        let db_req = sys
             .target()
             .expect("IDBVersionChangeEvent had no target")
             .dyn_into::<IdbOpenDbRequest>()
-            .expect("IDBVersionChangeEvent target was not an IDBOpenDBRequest")
+            .expect("IDBVersionChangeEvent target was not an IDBOpenDBRequest");
+        let db_sys = db_req
             .result()
             .expect("IDBOpenDBRequest had no result in its on_upgrade_needed handler")
             .dyn_into::<IdbDatabase>()
             .expect("IDBOpenDBRequest result was not an IDBDatabase");
+        let transaction_sys = db_req
+            .transaction()
+            .expect("IDBOpenDBRequest had no associated transaction");
         let db = Database::from_sys(db_sys);
-        VersionChangeEvent { sys, db }
+        let transaction = Transaction::from_sys(transaction_sys);
+        VersionChangeEvent {
+            sys,
+            db,
+            transaction,
+        }
     }
 
     /// The version before the database upgrade, clamped to `u32::MAX`
@@ -184,4 +201,11 @@ impl<Err> VersionChangeEvent<Err> {
     pub fn database(&self) -> &Database<Err> {
         &self.db
     }
+
+    /// The `versionchange` transaction that triggered this event
+    ///
+    /// This transaction can be used to submit further requests.
+    pub fn transaction(&self) -> &Transaction<Err> {
+        &self.transaction
+    }
 }

src/transaction.rs

@@ -126,19 +126,24 @@ pub(crate) async fn transaction_request<Err>(req: IdbRequest) -> crate::Result<J
 }
 
 /// Wrapper for [`IDBTransaction`](https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction)
+#[derive(Debug)]
 pub struct Transaction<Err> {
     sys: IdbTransaction,
     _phantom: PhantomData<Err>,
 }
 
 impl<Err> Transaction<Err> {
-    fn from_sys(sys: IdbTransaction) -> Transaction<Err> {
+    pub(crate) fn from_sys(sys: IdbTransaction) -> Transaction<Err> {
         Transaction {
             sys,
             _phantom: PhantomData,
         }
     }
 
+    pub(crate) fn as_sys(&self) -> &IdbTransaction {
+        &self.sys
+    }
+
     /// Returns an [`ObjectStore`] that can be used to operate on data in this transaction
     ///
     /// Internally, this uses [`IDBTransaction::object_store`](https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction/objectStore).
@@ -153,11 +158,11 @@ impl<Err> Transaction<Err> {
 }
 
 pin_project_lite::pin_project! {
-    struct TransactionPoller<F> {
+    pub(crate) struct TransactionPoller<F> {
         #[pin]
-        fut: F,
-        transaction: IdbTransaction,
-        pending_requests: usize,
+        pub(crate) fut: F,
+        pub(crate) transaction: IdbTransaction,
+        pub(crate) pending_requests: usize,
     }
 }
 

tests/js-panic.rs

@@ -34,3 +34,23 @@ async fn other_awaits_panic() {
 
     tx.send(()).unwrap();
 }
+
+#[wasm_bindgen_test]
+#[should_panic(expected = "Transaction blocked without any request under way")]
+async fn await_in_versionchange_panics() {
+    let factory = Factory::<anyhow::Error>::get().unwrap();
+
+    let (tx, rx) = futures_channel::oneshot::channel();
+
+    factory
+        .open("baz", 1, |evt| async move {
+            let db = evt.database();
+            db.build_object_store("data").auto_increment().create()?;
+            rx.await.context("awaiting for something external")?;
+            Ok(())
+        })
+        .await
+        .unwrap();
+
+    tx.send(()).unwrap();
+}