Use DB tx manager in ManagesTransactions trait

`DatabaseTransactionsManager` was introduced in Laravel to keep track of
things like pending transactions and fire transaction events, so that
e.g. dispatches could hook into transaction state.

Our trait was not using it yet, resulting in missing `afterCommit`
behavior (see PHPLIB-373)

Author: paulinevos

src/Concerns/ManagesTransactions.php

@@ -8,9 +8,12 @@
 use MongoDB\Client;
 use MongoDB\Driver\Exception\RuntimeException;
 use MongoDB\Driver\Session;
+use MongoDB\Laravel\Connection;
 use Throwable;
 
+use function max;
 use function MongoDB\with_transaction;
+use function property_exists;
 
 /**
  * @internal
@@ -55,32 +58,93 @@ private function getSessionOrThrow(): Session
      */
     public function beginTransaction(array $options = []): void
     {
+        $this->runCallbacksBeforeTransaction();
+
         $this->getSessionOrCreate()->startTransaction($options);
+
+        $this->handleInitialTransactionState();
+    }
+
+    private function handleInitialTransactionState(): void
+    {
         $this->transactions = 1;
+
+        $this->transactionsManager?->begin(
+            $this->getName(),
+            $this->transactions,
+        );
+
+        $this->fireConnectionEvent('beganTransaction');
     }
 
     /**
      * Commit transaction in this session.
      */
     public function commit(): void
     {
+        $this->fireConnectionEvent('committing');
         $this->getSessionOrThrow()->commitTransaction();
-        $this->transactions = 0;
+
+        $this->handleCommitState();
+    }
+
+    private function handleCommitState(): void
+    {
+        [$levelBeingCommitted, $this->transactions] = [
+            $this->transactions,
+            max(0, $this->transactions - 1),
+        ];
+
+        $this->transactionsManager?->commit(
+            $this->getName(),
+            $levelBeingCommitted,
+            $this->transactions,
+        );
+
+        $this->fireConnectionEvent('committed');
     }
 
     /**
      * Abort transaction in this session.
      */
     public function rollBack($toLevel = null): void
     {
-        $this->getSessionOrThrow()->abortTransaction();
+        $session = $this->getSessionOrThrow();
+        if ($session->isInTransaction()) {
+            $session->abortTransaction();
+        }
+
+        $this->handleRollbackState();
+    }
+
+    private function handleRollbackState(): void
+    {
         $this->transactions = 0;
+
+        $this->transactionsManager?->rollback(
+            $this->getName(),
+            $this->transactions,
+        );
+
+        $this->fireConnectionEvent('rollingBack');
+    }
+
+    private function runCallbacksBeforeTransaction(): void
+    {
+        // ToDo: remove conditional once we stop supporting Laravel 10.x
+        if (property_exists(Connection::class, 'beforeStartingTransaction')) {
+            foreach ($this->beforeStartingTransaction as $beforeTransactionCallback) {
+                $beforeTransactionCallback($this);
+            }
+        }
     }
 
     /**
      * Static transaction function realize the with_transaction functionality provided by MongoDB.
      *
-     * @param  int $attempts
+     * @param int $attempts
+     *
+     * @throws Throwable
      */
     public function transaction(Closure $callback, $attempts = 1, array $options = []): mixed
     {
@@ -93,15 +157,20 @@ public function transaction(Closure $callback, $attempts = 1, array $options = [
 
             if ($attemptsLeft < 0) {
                 $session->abortTransaction();
+                $this->handleRollbackState();
 
                 return;
             }
 
+            $this->runCallbacksBeforeTransaction();
+            $this->handleInitialTransactionState();
+
             // Catch, store, and re-throw any exception thrown during execution
             // of the callable. The last exception is re-thrown if the transaction
             // was aborted because the number of callback attempts has been exceeded.
             try {
                 $callbackResult = $callback($this);
+                $this->fireConnectionEvent('committing');
             } catch (Throwable $throwable) {
                 throw $throwable;
             }
@@ -110,9 +179,12 @@ public function transaction(Closure $callback, $attempts = 1, array $options = [
         with_transaction($this->getSessionOrCreate(), $callbackFunction, $options);
 
         if ($attemptsLeft < 0 && $throwable) {
+            $this->handleRollbackState();
             throw $throwable;
         }
 
+        $this->handleCommitState();
+
         return $callbackResult;
     }
 }