fix(transaction): tolerate desynced cleanup rollback on startTransaction

A pooled connection can report a transaction it no longer holds after a
reconnect: Swoole's PDOProxy keeps its own inTransaction counter and does
not reset it in reconnect(), so it still reports an open transaction while
the underlying connection has none. startTransaction()'s cleanup rollBack()
then throws "There is no active transaction", which was rewrapped as
"Failed to start transaction" and aborted an otherwise-valid start.

Because the pool reclaims (rather than destroys) the connection on error,
the desynced connection stays in rotation and every subsequent transaction
on it fails the same way.

Make the pre-begin cleanup best-effort: swallow a PDOException from the
rollback and continue to beginTransaction() on the (clean, reconnected)
connection. The utopia PDO wrapper is unaffected as it reads the real
connection state; this only hardens the path when wrapped by a proxy that
tracks transactions independently.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: loks0n

src/Database/Adapter/SQL.php

@@ -68,11 +68,18 @@ public function startTransaction(): bool
     {
         try {
             if ($this->inTransaction === 0) {
-                if ($this->getPDO()->inTransaction()) {
-                    $this->getPDO()->rollBack();
-                } else {
-                    // If no active transaction, this has no effect.
-                    $this->getPDO()->prepare('ROLLBACK')->execute();
+                try {
+                    if ($this->getPDO()->inTransaction()) {
+                        $this->getPDO()->rollBack();
+                    } else {
+                        // If no active transaction, this has no effect.
+                        $this->getPDO()->prepare('ROLLBACK')->execute();
+                    }
+                } catch (PDOException) {
+                    // A pooled connection can report a transaction it no longer
+                    // holds after a reconnect (e.g. Swoole PDOProxy keeps its own
+                    // counter), making this cleanup rollback throw. It is best
+                    // effort; swallow it and begin a fresh transaction below.
                 }
 
                 $this->getPDO()->beginTransaction();

tests/unit/SQLTransactionTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Tests\Unit;
+
+use PDOException;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\MySQL;
+
+class SQLTransactionTest extends TestCase
+{
+    /**
+     * A pooled connection (e.g. Swoole PDOProxy) can keep its own transaction
+     * counter that survives a reconnect, so it reports an open transaction the
+     * underlying connection no longer holds. The cleanup rollBack() then throws
+     * "There is no active transaction". startTransaction() must swallow that and
+     * still begin a fresh transaction instead of surfacing it as a failure.
+     */
+    public function testStartTransactionRecoversFromDesyncedRollback(): void
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $pdo->method('inTransaction')->willReturn(true);
+        $pdo->method('rollBack')->willThrowException(
+            new PDOException('There is no active transaction')
+        );
+        $pdo->expects($this->once())
+            ->method('beginTransaction')
+            ->willReturn(true);
+
+        $adapter = new MySQL($pdo);
+
+        $this->assertTrue($adapter->startTransaction());
+        $this->assertTrue($adapter->inTransaction());
+    }
+}