fix: raise error on nested transaction instead of silent no-op

Previously, calling transaction() inside an active transaction silently
yielded without any transactional semantics, which is a correctness
trap. Now raises OperationalError so callers discover the issue
immediately. Users needing nested transactions can use SAVEPOINT directly.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -5,7 +5,7 @@
 from contextlib import asynccontextmanager
 from typing import Any
 
-from dqliteclient.exceptions import ConnectionError, ProtocolError
+from dqliteclient.exceptions import ConnectionError, OperationalError, ProtocolError
 from dqliteclient.protocol import DqliteProtocol
 
 
@@ -150,9 +150,9 @@ async def fetchval(self, sql: str, params: list[Any] | None = None) -> Any:
     async def transaction(self) -> AsyncIterator[None]:
         """Context manager for transactions."""
         if self._in_transaction:
-            # Nested transaction - just yield
-            yield
-            return
+            raise OperationalError(
+                0, "Nested transactions are not supported; use SAVEPOINT directly"
+            )
 
         await self.execute("BEGIN")
         self._in_transaction = True

tests/test_connection.py

@@ -94,6 +94,41 @@ async def test_execute_not_connected(self) -> None:
         with pytest.raises(ConnectionError, match="Not connected"):
             await conn.execute("SELECT 1")
 
+    async def test_nested_transaction_raises(self) -> None:
+        """Nested transaction() should raise, not silently no-op."""
+        conn = DqliteConnection("localhost:9001")
+
+        mock_reader = AsyncMock()
+        mock_writer = MagicMock()
+        mock_writer.drain = AsyncMock()
+        mock_writer.close = MagicMock()
+        mock_writer.wait_closed = AsyncMock()
+
+        from dqlitewire.messages import DbResponse, ResultResponse, WelcomeResponse
+
+        responses = [
+            WelcomeResponse(heartbeat_timeout=15000).encode(),
+            DbResponse(db_id=1).encode(),
+            ResultResponse(last_insert_id=0, rows_affected=0).encode(),  # BEGIN
+        ]
+        mock_reader.read.side_effect = responses
+
+        with patch("asyncio.open_connection", return_value=(mock_reader, mock_writer)):
+            await conn.connect()
+
+        # Mock execute for BEGIN
+        async def mock_execute(sql: str, params=None):
+            return (0, 0)
+
+        conn.execute = mock_execute  # type: ignore[assignment]
+
+        from dqliteclient.exceptions import OperationalError
+
+        async with conn.transaction():
+            with pytest.raises(OperationalError, match="[Nn]ested"):
+                async with conn.transaction():
+                    pass
+
     async def test_fetch_not_connected(self) -> None:
         conn = DqliteConnection("localhost:9001")