Preserve the server error code on dbapi OperationalError

dqliteclient.OperationalError carries a typed ``code`` attribute (the
SQLite extended error code forwarded from the server), but the dbapi
_call_client wrapper stringified the exception and dropped the code.
Two in-tree callers (``_is_no_transaction_error`` in the dbapi layer
and ``is_disconnect`` in the SQLAlchemy dialect) do
``getattr(exc, "code", None) in LEADER_ERROR_CODES`` — both guards
were silently dead code for the dbapi-remapped path. Teach
``dqlitedbapi.OperationalError`` to carry an optional ``code`` field
and forward it through _call_client.

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

Author: antoineleclair

src/dqlitedbapi/cursor.py

@@ -45,7 +45,11 @@ async def _call_client(coro: Coroutine[Any, Any, Any]) -> Any:
     try:
         return await coro
     except _client_exc.OperationalError as e:
-        raise OperationalError(str(e)) from e
+        # Forward the SQLite extended error code so callers that branch
+        # on leader-change / busy / integrity codes (see
+        # ``_is_no_transaction_error`` and the SQLAlchemy dialect's
+        # ``is_disconnect``) continue to work after the remap.
+        raise OperationalError(str(e), code=e.code) from e
     except _client_exc.DqliteConnectionError as e:
         raise OperationalError(str(e)) from e
     except _client_exc.ClusterError as e:

src/dqlitedbapi/exceptions.py

@@ -32,9 +32,18 @@ class DataError(DatabaseError):
 
 
 class OperationalError(DatabaseError):
-    """Error related to database operation."""
-
-    pass
+    """Error related to database operation.
+
+    Optional ``code`` attribute carries the SQLite extended error code
+    forwarded from the dqlite server (e.g. ``SQLITE_IOERR_NOT_LEADER``).
+    Callers can inspect ``getattr(exc, "code", None)`` to branch on
+    specific wire-level failures without importing the lower-level
+    client exception module.
+    """
+
+    def __init__(self, message: object = "", code: int | None = None) -> None:
+        super().__init__(message)
+        self.code = code
 
 
 class IntegrityError(DatabaseError):

tests/test_dbapi_hardening.py

@@ -348,3 +348,39 @@ def test_detects_row_returning(self, sql: str) -> None:
     )
     def test_detects_non_row_returning(self, sql: str) -> None:
         assert not _is_row_returning(sql)
+
+
+class TestOperationalErrorCode:
+    """dbapi OperationalError carries the SQLite extended error code
+    forwarded from the client layer. Consumers like
+    ``_is_no_transaction_error`` and the SQLAlchemy dialect's
+    ``is_disconnect`` key on ``getattr(exc, 'code', None)``.
+    """
+
+    def test_default_code_is_none(self) -> None:
+        from dqlitedbapi.exceptions import OperationalError
+
+        e = OperationalError("boom")
+        assert e.code is None
+        assert str(e) == "boom"
+
+    def test_explicit_code_preserved(self) -> None:
+        from dqlitedbapi.exceptions import OperationalError
+
+        e = OperationalError("not leader", code=10250)
+        assert e.code == 10250
+
+    def test_call_client_preserves_client_code(self) -> None:
+        import asyncio
+
+        import dqliteclient.exceptions as _client_exc
+        from dqlitedbapi.cursor import _call_client
+        from dqlitedbapi.exceptions import OperationalError
+
+        async def raiser() -> None:
+            raise _client_exc.OperationalError(10250, "not the leader")
+
+        with pytest.raises(OperationalError) as excinfo:
+            asyncio.run(_call_client(raiser()))
+
+        assert excinfo.value.code == 10250