fix: add a passthrough method to access underlying transaction depth

Author: LucianBuzzo

libs/driver-adapters/src/queryable.rs

@@ -361,7 +361,9 @@ impl JsQueryable {
         isolation: Option<IsolationLevel>,
     ) -> quaint::Result<Box<dyn Transaction + 'a>> {
         let tx = self.driver_proxy.start_transaction(isolation).await?;
-        tx.depth += 1;
+
+        tx.increment_depth();
+
         self.server_reset_query(tx.as_ref()).await?;
         Ok(tx)
     }

libs/driver-adapters/src/transaction.rs

@@ -1,7 +1,4 @@
-use std::{
-    future::Future,
-    sync::atomic::{AtomicI32, Ordering},
-};
+use std::sync::atomic::{AtomicI32, Ordering};
 
 use async_trait::async_trait;
 use prisma_metrics::gauge;

quaint/src/connector/queryable.rs

@@ -1,7 +1,6 @@
 use super::{DescribedQuery, ExternalConnector, IsolationLevel, ResultSet, Transaction};
 use std::borrow::Cow;
 
-use super::{DescribedQuery, IsolationLevel, ResultSet, Transaction};
 use crate::ast::*;
 use async_trait::async_trait;
 

query-engine/connector-test-kit-rs/query-engine-tests/tests/new/interactive_tx.rs

@@ -556,6 +556,7 @@ mod interactive_tx {
         let known_err = error.as_known().unwrap();
 
         assert_eq!(known_err.error_code, Cow::Borrowed("P2028"));
+
         assert!(known_err
             .message
             .contains("A rollback cannot be executed on a transaction that was rolled back"));
@@ -593,9 +594,12 @@ mod interactive_tx {
         let known_err = error.as_known().unwrap();
 
         assert_eq!(known_err.error_code, Cow::Borrowed("P2028"));
-        assert!(known_err
-            .message
-            .contains("A commit cannot be executed on a transaction that was rolled back"));
+        assert!(
+            known_err
+                .message
+                .contains("A commit cannot be executed on a transaction that was rolled back"),
+            "{known_err:?}"
+        );
 
         // Check that the commit didn't work
         insta::assert_snapshot!(
@@ -630,9 +634,13 @@ mod interactive_tx {
         let known_err = error.as_known().unwrap();
 
         assert_eq!(known_err.error_code, Cow::Borrowed("P2028"));
-        assert!(known_err
-            .message
-            .contains("A rollback cannot be executed on a committed transaction"));
+
+        assert!(
+            known_err
+                .message
+                .contains("A rollback cannot be executed on a committed transaction"),
+            "{known_err:?}"
+        );
 
         // Check that the commit worked
         insta::assert_snapshot!(

query-engine/core/src/interactive_transactions/manager.rs

@@ -191,7 +191,8 @@ impl ItxManager {
     pub async fn commit_tx(&self, tx_id: &TxId) -> crate::Result<()> {
         let transaction_entry = self.get_transaction(tx_id, "commit").await?;
         let mut tx = transaction_entry.lock().await;
-        let depth = tx.depth();
+        let depth = tx.depth()?;
+
         if depth > 1 {
             tx.release_savepoint().await
         } else {
@@ -202,7 +203,7 @@ impl ItxManager {
     pub async fn rollback_tx(&self, tx_id: &TxId) -> crate::Result<()> {
         let transaction_entry = self.get_transaction(tx_id, "rollback").await?;
         let mut tx = transaction_entry.lock().await;
-        let depth = tx.depth();
+        let depth = tx.depth()?;
         if depth > 1 {
             tx.rollback_to_savepoint().await
         } else {

query-engine/core/src/interactive_transactions/transaction.rs

@@ -99,6 +99,22 @@ impl TransactionState {
         }
     }
 
+    // Allow depth to be called on the transaction even if it's closed.
+    // This is usefule for the manger to handle nested transactions in a sane
+    // way, and allows useful error messages to propagate, since depth tracking
+    // is an internal detail of the engine.
+    // If the transaction is closed, we return 0, since the depth is not tracked
+    // anymore, and we allow the usual error message for rollback/commit/savepointX
+    // to be returned.
+    fn depth(&self) -> crate::Result<i32> {
+        match self {
+            Self::Open { tx, .. } => Ok(tx.depth()),
+            Self::Committed => Ok(0),
+            Self::RolledBack => Ok(0),
+            Self::Expired { .. } => Ok(0),
+        }
+    }
+
     fn as_closed(&self) -> Option<ClosedTransaction> {
         match self {
             Self::Open { .. } => None,
@@ -197,11 +213,8 @@ impl InteractiveTransaction {
         })
     }
 
-    pub fn depth(&mut self) -> i32 {
-        match self.state.as_open("depth") {
-            Ok(state) => state.depth(),
-            Err(_) => 0,
-        }
+    pub fn depth(&mut self) -> crate::Result<i32> {
+        self.state.depth()
     }
 
     pub async fn commit(&mut self) -> crate::Result<()> {