brawny 0.1.13__py3-none-any.whl

brawny/db/mappers.py

@@ -0,0 +1,182 @@
+"""Row to model mappers for database results.
+
+Centralized conversion from database rows (dicts) to domain models.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from uuid import UUID
+
+from brawny.db.base_new import BlockState, BlockHashEntry, ABICacheEntry, ProxyCacheEntry
+from brawny.model.types import (
+    JobConfig,
+    TxIntent,
+    TxAttempt,
+    SignerState,
+    NonceReservation,
+    GasParams,
+)
+from brawny.model.enums import IntentStatus, AttemptStatus, NonceStatus
+
+
+def row_to_block_state(row: dict[str, Any]) -> BlockState:
+    """Convert database row to BlockState."""
+    return BlockState(
+        chain_id=row["chain_id"],
+        last_processed_block_number=row["last_processed_block_number"],
+        last_processed_block_hash=row["last_processed_block_hash"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def row_to_block_hash_entry(row: dict[str, Any]) -> BlockHashEntry:
+    """Convert database row to BlockHashEntry."""
+    return BlockHashEntry(
+        id=row["id"],
+        chain_id=row["chain_id"],
+        block_number=row["block_number"],
+        block_hash=row["block_hash"],
+        inserted_at=row["inserted_at"],
+    )
+
+
+def row_to_job_config(row: dict[str, Any]) -> JobConfig:
+    """Convert database row to JobConfig."""
+    return JobConfig(
+        job_id=row["job_id"],
+        job_name=row["job_name"],
+        enabled=bool(row["enabled"]),
+        check_interval_blocks=row["check_interval_blocks"],
+        last_checked_block_number=row["last_checked_block_number"],
+        last_triggered_block_number=row["last_triggered_block_number"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def row_to_signer_state(row: dict[str, Any]) -> SignerState:
+    """Convert database row to SignerState."""
+    return SignerState(
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        next_nonce=row["next_nonce"],
+        last_synced_chain_nonce=row["last_synced_chain_nonce"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        gap_started_at=row.get("gap_started_at"),
+        alias=row.get("alias"),
+    )
+
+
+def row_to_nonce_reservation(row: dict[str, Any]) -> NonceReservation:
+    """Convert database row to NonceReservation."""
+    intent_id = row["intent_id"]
+    # Handle string UUIDs (SQLite stores as string)
+    if intent_id and isinstance(intent_id, str):
+        intent_id = UUID(intent_id)
+    return NonceReservation(
+        id=row["id"],
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        nonce=row["nonce"],
+        status=NonceStatus(row["status"]),
+        intent_id=intent_id,
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def row_to_intent(row: dict[str, Any]) -> TxIntent:
+    """Convert database row to TxIntent."""
+    intent_id = row["intent_id"]
+    # Handle string UUIDs (SQLite stores as string)
+    if isinstance(intent_id, str):
+        intent_id = UUID(intent_id)
+
+    # Parse metadata_json once at DB boundary
+    metadata_json = row.get("metadata_json")
+    metadata = json.loads(metadata_json) if metadata_json else {}
+
+    return TxIntent(
+        intent_id=intent_id,
+        job_id=row["job_id"],
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        idempotency_key=row["idempotency_key"],
+        to_address=row["to_address"],
+        data=row["data"],
+        value_wei=row["value_wei"],
+        gas_limit=row["gas_limit"],
+        max_fee_per_gas=row["max_fee_per_gas"],
+        max_priority_fee_per_gas=row["max_priority_fee_per_gas"],
+        min_confirmations=row["min_confirmations"],
+        deadline_ts=row["deadline_ts"],
+        retry_after=row.get("retry_after"),
+        retry_count=row.get("retry_count", 0),
+        status=IntentStatus(row["status"]),
+        claim_token=row["claim_token"],
+        claimed_at=row["claimed_at"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        broadcast_group=row.get("broadcast_group"),
+        broadcast_endpoints_json=row.get("broadcast_endpoints_json"),
+        metadata=metadata,
+    )
+
+
+def row_to_attempt(row: dict[str, Any]) -> TxAttempt:
+    """Convert database row to TxAttempt."""
+    attempt_id = row["attempt_id"]
+    intent_id = row["intent_id"]
+    replaces_attempt_id = row.get("replaces_attempt_id")
+
+    # Handle string UUIDs (SQLite stores as string)
+    if isinstance(attempt_id, str):
+        attempt_id = UUID(attempt_id)
+    if isinstance(intent_id, str):
+        intent_id = UUID(intent_id)
+    if replaces_attempt_id and isinstance(replaces_attempt_id, str):
+        replaces_attempt_id = UUID(replaces_attempt_id)
+
+    return TxAttempt(
+        attempt_id=attempt_id,
+        intent_id=intent_id,
+        nonce=row["nonce"],
+        tx_hash=row["tx_hash"],
+        gas_params=GasParams.from_json(row["gas_params_json"]),
+        status=AttemptStatus(row["status"]),
+        error_code=row.get("error_code"),
+        error_detail=row.get("error_detail"),
+        replaces_attempt_id=replaces_attempt_id,
+        broadcast_block=row.get("broadcast_block"),
+        broadcast_at=row.get("broadcast_at"),
+        included_block=row.get("included_block"),
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        broadcast_group=row.get("broadcast_group"),
+        endpoint_url=row.get("endpoint_url"),
+    )
+
+
+def row_to_abi_cache(row: dict[str, Any]) -> ABICacheEntry:
+    """Convert database row to ABICacheEntry."""
+    return ABICacheEntry(
+        chain_id=row["chain_id"],
+        address=row["address"],
+        abi_json=row["abi_json"],
+        source=row["source"],
+        resolved_at=row["resolved_at"],
+    )
+
+
+def row_to_proxy_cache(row: dict[str, Any]) -> ProxyCacheEntry:
+    """Convert database row to ProxyCacheEntry."""
+    return ProxyCacheEntry(
+        chain_id=row["chain_id"],
+        proxy_address=row["proxy_address"],
+        implementation_address=row["implementation_address"],
+        resolved_at=row["resolved_at"],
+    )

brawny/db/migrate.py

@@ -0,0 +1,349 @@
+"""Database migration management for brawny.
+
+Handles schema migrations for both PostgreSQL and SQLite.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from brawny.model.errors import DatabaseError
+
+if TYPE_CHECKING:
+    from brawny.db.base import Database
+
+
+MIGRATIONS_DIR = Path(__file__).parent / "migrations"
+
+
+@dataclass
+class Migration:
+    """Represents a database migration."""
+
+    version: str
+    filename: str
+    sql: str
+    applied_at: datetime | None = None
+
+    @property
+    def is_applied(self) -> bool:
+        return self.applied_at is not None
+
+
+def discover_migrations() -> list[Migration]:
+    """Discover all migration files in the migrations directory.
+
+    Returns:
+        List of Migration objects sorted by version
+
+    Raises:
+        DatabaseError: If duplicate migration versions are found
+    """
+    migrations: list[Migration] = []
+    seen_versions: dict[str, str] = {}
+
+    if not MIGRATIONS_DIR.exists():
+        return migrations
+
+    for file_path in sorted(MIGRATIONS_DIR.glob("*.sql")):
+        # Extract version from filename (e.g., "001_init.sql" -> "001")
+        match = re.match(r"^(\d+)_.*\.sql$", file_path.name)
+        if match:
+            version = match.group(1)
+
+            # Check for duplicate version numbers
+            if version in seen_versions:
+                raise DatabaseError(
+                    f"Duplicate migration version {version}: "
+                    f"{seen_versions[version]} and {file_path.name}"
+                )
+            seen_versions[version] = file_path.name
+
+            sql = file_path.read_text()
+            migrations.append(
+                Migration(
+                    version=version,
+                    filename=file_path.name,
+                    sql=sql,
+                )
+            )
+
+    return sorted(migrations, key=lambda m: m.version)
+
+
+def get_applied_migrations(db: Database) -> set[str]:
+    """Get set of applied migration versions.
+
+    Args:
+        db: Database connection
+
+    Returns:
+        Set of version strings that have been applied
+    """
+    try:
+        # Check if migrations table exists
+        result = db.execute_returning(
+            """
+            SELECT version, applied_at
+            FROM schema_migrations
+            ORDER BY version
+            """
+        )
+        return {row["version"] for row in result}
+    except Exception:
+        # Table doesn't exist yet
+        return set()
+
+
+def get_pending_migrations(db: Database) -> list[Migration]:
+    """Get list of migrations that haven't been applied.
+
+    Args:
+        db: Database connection
+
+    Returns:
+        List of pending Migration objects
+    """
+    applied = get_applied_migrations(db)
+    all_migrations = discover_migrations()
+    return [m for m in all_migrations if m.version not in applied]
+
+
+def get_migration_status(db: Database) -> list[Migration]:
+    """Get status of all migrations.
+
+    Args:
+        db: Database connection
+
+    Returns:
+        List of all migrations with applied_at set if applied
+    """
+    applied: dict[str, datetime] = {}
+
+    try:
+        result = db.execute_returning(
+            """
+            SELECT version, applied_at
+            FROM schema_migrations
+            ORDER BY version
+            """
+        )
+        for row in result:
+            applied[row["version"]] = row["applied_at"]
+    except Exception:
+        pass
+
+    all_migrations = discover_migrations()
+    for migration in all_migrations:
+        if migration.version in applied:
+            migration.applied_at = applied[migration.version]
+
+    return all_migrations
+
+
+def run_migration(db: Database, migration: Migration) -> None:
+    """Run a single migration.
+
+    Args:
+        db: Database connection
+        migration: Migration to run
+
+    Raises:
+        DatabaseError: If migration fails
+    """
+    try:
+        if db.dialect == "sqlite" and migration.version == "012":
+            with db.transaction():
+                existing = {
+                    r["name"].lower()
+                    for r in db.execute_returning("PRAGMA table_info(tx_intents)")
+                }
+                if "claimed_by" in existing:
+                    db.execute(
+                        "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
+                        (migration.version,),
+                    )
+                    return
+                try:
+                    db.execute(
+                        "ALTER TABLE tx_intents ADD COLUMN claimed_by VARCHAR(200)"
+                    )
+                except Exception as exc:
+                    if "duplicate column name" not in str(exc).lower():
+                        raise
+                db.execute(
+                    "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
+                    (migration.version,),
+                )
+            return
+
+        with db.transaction():
+            # Split SQL into individual statements for SQLite compatibility
+            # SQLite can only execute one statement at a time
+            statements = _split_sql_statements(migration.sql)
+            for stmt in statements:
+                stmt = stmt.strip()
+                if not stmt:
+                    continue
+                try:
+                    db.execute(stmt)
+                except DatabaseError as e:
+                    if _is_duplicate_column_error(e, stmt):
+                        # Idempotent safety for already-applied schema changes.
+                        continue
+                    raise
+    except Exception as e:
+        raise DatabaseError(
+            f"Migration {migration.version} ({migration.filename}) failed: {e}"
+        )
+
+
+def _is_duplicate_column_error(error: Exception, stmt: str) -> bool:
+    """Return True if the error indicates an already-existing column."""
+    message = str(error).lower()
+    if "duplicate column name" in message or "already exists" in message:
+        if "add column" in stmt.lower():
+            return True
+    return False
+
+
+def _split_sql_statements(sql: str) -> list[str]:
+    """Split SQL into individual statements.
+
+    Handles semicolons, comments, and multi-line statements.
+
+    Args:
+        sql: SQL text with multiple statements
+
+    Returns:
+        List of individual statements
+    """
+    # Remove SQL comments
+    lines = []
+    for line in sql.split('\n'):
+        # Remove -- comments
+        if '--' in line:
+            line = line[:line.index('--')]
+        lines.append(line)
+    sql = '\n'.join(lines)
+
+    # Split on semicolons, but be careful about strings
+    # This is a simple split - for production, use a proper SQL parser
+    statements = []
+    current = []
+    in_string = False
+    string_char = None
+
+    for char in sql:
+        if char in ('"', "'") and not in_string:
+            in_string = True
+            string_char = char
+            current.append(char)
+        elif char == string_char and in_string:
+            in_string = False
+            string_char = None
+            current.append(char)
+        elif char == ';' and not in_string:
+            stmt = ''.join(current).strip()
+            if stmt:
+                statements.append(stmt)
+            current = []
+        else:
+            current.append(char)
+
+    # Don't forget the last statement if no trailing semicolon
+    stmt = ''.join(current).strip()
+    if stmt:
+        statements.append(stmt)
+
+    return statements
+
+
+def run_pending_migrations(db: Database) -> list[Migration]:
+    """Run all pending migrations.
+
+    Args:
+        db: Database connection
+
+    Returns:
+        List of migrations that were applied
+
+    Raises:
+        DatabaseError: If any migration fails
+    """
+    pending = get_pending_migrations(db)
+
+    for migration in pending:
+        run_migration(db, migration)
+        migration.applied_at = datetime.utcnow()
+
+    verify_critical_schema(db)
+
+    return pending
+
+
+def verify_critical_schema(db: Database) -> None:
+    """Hard-fail if critical columns missing. Runs for daemon + CLI."""
+    # If earlier schemas lacked any of these, reduce to the minimum needed for safe operation.
+    required = {"intent_id", "status", "claim_token", "claimed_at", "claimed_by"}
+
+    if db.dialect == "sqlite":
+        rows = db.execute_returning("PRAGMA table_info(tx_intents)")
+        existing = {r["name"].lower() for r in rows}
+    else:
+        rows = db.execute_returning(
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_schema = current_schema() AND table_name = 'tx_intents'"
+        )
+        existing = {r["column_name"].lower() for r in rows}
+
+    missing = required - existing
+    if missing:
+        raise RuntimeError(
+            f"FATAL: tx_intents missing columns {missing}. "
+            f"Migration 012 may have failed. Check DB manually."
+        )
+
+
+class Migrator:
+    """High-level migration management interface."""
+
+    def __init__(self, db: Database) -> None:
+        self.db = db
+
+    def status(self) -> list[dict[str, str | bool]]:
+        """Get migration status as a list of dicts.
+
+        Returns:
+            List of dicts with version, filename, applied, and applied_at
+        """
+        migrations = get_migration_status(self.db)
+        return [
+            {
+                "version": m.version,
+                "filename": m.filename,
+                "applied": m.is_applied,
+                "applied_at": m.applied_at.isoformat() if m.applied_at else None,
+            }
+            for m in migrations
+        ]
+
+    def pending(self) -> list[Migration]:
+        """Get pending migrations."""
+        return get_pending_migrations(self.db)
+
+    def migrate(self) -> list[Migration]:
+        """Run all pending migrations.
+
+        Returns:
+            List of applied migrations
+        """
+        return run_pending_migrations(self.db)
+
+    def has_pending(self) -> bool:
+        """Check if there are pending migrations."""
+        return len(self.pending()) > 0