feat(database): provide active transaction (instead of database) to async upgrade needed callback

BREAKING CHANGE: The callback provided to
`OpenDbRequestBuilder::with_on_upgrade_needed_fut` must now accept a
reference to a `Transaction` rather than a `Database`. For most cases,
existing code can be made compatible by calling `Transaction::database`
in order to get access to the underlying database. The caveat is that
the `Transaction::database` provides a reference, rather than ownership
of the `Database`.

Author: mgoldenberg

internal_macros/src/generic_bounds.rs

@@ -52,7 +52,7 @@ make_opts!(Opts => {
     db_version => crate::factory::DBVersion,
     blocked_cb => ::core::ops::FnOnce(crate::database::VersionChangeEvent) -> crate::Result<()> + 'static,
     upgrade_cb => ::core::ops::FnOnce(crate::database::VersionChangeEvent, &crate::transaction::Transaction<'_>) -> crate::Result<()> + 'static,
-    upgrade_async_cb => ::core::ops::AsyncFnOnce(crate::database::VersionChangeEvent, crate::database::Database) -> crate::Result<()> + 'static,
+    upgrade_async_cb => ::core::ops::AsyncFnOnce(crate::database::VersionChangeEvent, &crate::transaction::Transaction<'_>) -> crate::Result<()> + 'static,
 });
 
 #[inline]

src/future/open_db/listener.rs

@@ -176,11 +176,21 @@ const _: () = {
                     };
 
                     Self::set_status(&status, Status::Pending, LBL_UPGRADE)?;
-                    let fut = callback(VersionChangeEvent::new(evt), db);
-
                     wasm_bindgen_futures::spawn_local(async move {
-                        let result = match fut.await {
-                            Ok(()) => Status::Ok,
+                        let db = db;
+                        let result = match Transaction::from_raw_version_change_event(&db, &evt) {
+                            Ok(mut transaction) => {
+                                match callback(VersionChangeEvent::new(evt), &transaction).await {
+                                    Ok(_) => {
+                                        // If the callback succeeded, we want to ensure that
+                                        // the transaction is committed when dropped and not
+                                        // aborted.
+                                        transaction.on_drop(OnTransactionDrop::Commit);
+                                        Status::Ok
+                                    }
+                                    Err(e) => Status::Err(e),
+                                }
+                            }
                             Err(e) => Status::Err(e),
                         };
                         let _ = Self::set_status(&status, result, LBL_UPGRADE);

tests/tests/example_reproductions.rs

@@ -44,54 +44,53 @@ pub async fn multi_threaded_executor() {
 #[wasm_bindgen_test]
 #[cfg(all(feature = "tx-done", feature = "async-upgrade"))]
 pub async fn opening_a_database_and_making_some_schema_changes() {
-    use indexed_db_futures::database::{Database, VersionChangeEvent};
+    use indexed_db_futures::database::Database;
     use indexed_db_futures::prelude::*;
     use indexed_db_futures::transaction::TransactionMode;
 
     let _ = Database::open("opening_a_database_and_making_some_schema_changes")
         .with_version(2u8)
         .with_on_blocked(|_| Ok(()))
-        .with_on_upgrade_needed_fut(|event: VersionChangeEvent, db: Database| {
+        .with_on_upgrade_needed_fut(async |event, tx| {
+            let db = tx.db();
             // Convert versions from floats to integers to allow using them in match expressions
             let old_version = event.old_version() as u64;
             let new_version = event.new_version().map(|v| v as u64);
 
-            async move {
-                match (old_version, new_version) {
-                    (0, Some(1)) => {
-                        db.create_object_store("my_store")
-                            .with_auto_increment(true)
-                            .build()?;
+            match (old_version, new_version) {
+                (0, Some(1)) => {
+                    db.create_object_store("my_store")
+                        .with_auto_increment(true)
+                        .build()?;
+                }
+                (prev, Some(2)) => {
+                    if prev == 1 {
+                        db.delete_object_store("my_store")?;
                     }
-                    (prev, Some(2)) => {
-                        if prev == 1 {
-                            db.delete_object_store("my_store")?;
-                        }
 
-                        // Create an object store and await its transaction before inserting data.
-                        db.create_object_store("my_other_store")
-                            .with_auto_increment(true)
-                            .build()?
-                            .transaction()
-                            .on_done()?
-                            .await
-                            .into_result()?;
-
-                        //- Start a new transaction & add some data
-                        let tx = db
-                            .transaction("my_other_store")
-                            .with_mode(TransactionMode::Readwrite)
-                            .build()?;
-                        let store = tx.object_store("my_other_store")?;
-                        store.add("foo").await?;
-                        store.add("bar").await?;
-                        tx.commit().await?;
-                    }
-                    _ => {}
+                    // Create an object store and await its transaction before inserting data.
+                    db.create_object_store("my_other_store")
+                        .with_auto_increment(true)
+                        .build()?
+                        .transaction()
+                        .on_done()?
+                        .await
+                        .into_result()?;
+
+                    //- Start a new transaction & add some data
+                    let tx = db
+                        .transaction("my_other_store")
+                        .with_mode(TransactionMode::Readwrite)
+                        .build()?;
+                    let store = tx.object_store("my_other_store")?;
+                    store.add("foo").await?;
+                    store.add("bar").await?;
+                    tx.commit().await?;
                 }
-
-                Ok(())
+                _ => {}
             }
+
+            Ok(())
         })
         .await
         .expect("Error opening DB");

tests/tests/transaction/on_done.rs

@@ -40,7 +40,8 @@ pub mod async_upgrade {
 
         let err = Database::open(random_str())
             .with_version(2u8)
-            .with_on_upgrade_needed_fut(move |_, db: Database| async move {
+            .with_on_upgrade_needed_fut(async |_, tx| {
+                let db = tx.db();
                 // Create an object store and await its transaction
                 db.create_object_store(STORE_NAME)
                     .with_auto_increment(true)
@@ -74,7 +75,8 @@ pub mod async_upgrade {
             .with_version(2u8)
             .with_on_upgrade_needed_fut({
                 let events = Arc::clone(&events);
-                move |_, db: Database| async move {
+                async move |_, tx| {
+                    let db = tx.db();
                     events.lock().unwrap().push(Event::CallbackStart);
 
                     // Create an object store and await its transaction