SimpleMem/cross/storage_sqlite.py

# pyright: reportMissingImports=false, reportUnknownVariableType=false, reportUnknownParameterType=false, reportUnknownMemberType=false, reportUnknownArgumentType=false, reportMissingParameterType=false, reportUnusedCallResult=false, reportUnusedImport=false, reportDeprecated=false
import json
import logging
import sqlite3
from collections.abc import Iterable, Sequence
from datetime import datetime, timezone
from pathlib import Path
from types import TracebackType
from typing import Optional, Type, cast
from uuid import uuid4

from .types import (
    ConsolidationRun,
    CrossObservation,
    EventKind,
    MemoryLink,
    ObservationType,
    RedactionLevel,
    SessionEvent,
    SessionRecord,
    SessionStatus,
    SessionSummary,
)


logger = logging.getLogger(__name__)


class SQLiteStorage:
    """Manages SQLite database for cross-session memory."""

    db_path: Path
    conn: sqlite3.Connection

    def __init__(self, db_path: str = "~/.simplemem-cross/cross_memory.db"):
        self.db_path = Path(db_path).expanduser()
        self.db_path.parent.mkdir(parents=True, exist_ok=True)
        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        self.conn.row_factory = sqlite3.Row
        self._configure_connection()
        self._run_migrations()

    def __enter__(self) -> "SQLiteStorage":
        return self

    def __exit__(
        self,
        exc_type: Optional[Type[BaseException]],
        exc: Optional[BaseException],
        tb: Optional[TracebackType],
    ) -> None:
        self.close()

    def close(self) -> None:
        try:
            self.conn.close()
        except sqlite3.Error:
            logger.exception("Failed to close SQLite connection")

    def _configure_connection(self) -> None:
        try:
            _ = self.conn.execute("PRAGMA journal_mode=WAL")
            _ = self.conn.execute("PRAGMA foreign_keys=ON")
            _ = self.conn.execute("PRAGMA synchronous=NORMAL")
        except sqlite3.Error:
            logger.exception("Failed to configure SQLite connection")
            raise

    def _run_migrations(self) -> None:
        schema_statements = [
            """
            CREATE TABLE IF NOT EXISTS sessions (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                tenant_id TEXT NOT NULL DEFAULT 'default',
                content_session_id TEXT UNIQUE NOT NULL,
                memory_session_id TEXT UNIQUE NOT NULL,
                project TEXT NOT NULL,
                user_prompt TEXT,
                started_at TEXT NOT NULL,
                ended_at TEXT,
                status TEXT CHECK(status IN ('active', 'completed', 'failed')) DEFAULT 'active',
                metadata_json TEXT
            )
            """,
            """
            CREATE TABLE IF NOT EXISTS session_events (
                event_id INTEGER PRIMARY KEY AUTOINCREMENT,
                memory_session_id TEXT NOT NULL,
                timestamp TEXT NOT NULL,
                kind TEXT CHECK(kind IN ('message', 'tool_use', 'file_change', 'note', 'system')) NOT NULL,
                title TEXT,
                payload_json TEXT,
                redaction_level TEXT DEFAULT 'none',
                FOREIGN KEY(memory_session_id) REFERENCES sessions(memory_session_id) ON DELETE CASCADE
            )
            """,
            """
            CREATE TABLE IF NOT EXISTS observations (
                obs_id INTEGER PRIMARY KEY AUTOINCREMENT,
                memory_session_id TEXT NOT NULL,
                timestamp TEXT NOT NULL,
                type TEXT CHECK(type IN ('decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change')) NOT NULL,
                title TEXT NOT NULL,
                subtitle TEXT,
                facts_json TEXT,
                narrative TEXT,
                concepts_json TEXT,
                files_json TEXT,
                vector_ref TEXT,
                FOREIGN KEY(memory_session_id) REFERENCES sessions(memory_session_id) ON DELETE CASCADE
            )
            """,
            """
            CREATE TABLE IF NOT EXISTS session_summaries (
                summary_id INTEGER PRIMARY KEY AUTOINCREMENT,
                memory_session_id TEXT NOT NULL,
                timestamp TEXT NOT NULL,
                request TEXT,
                investigated TEXT,
                learned TEXT,
                completed TEXT,
                next_steps TEXT,
                vector_ref TEXT,
                FOREIGN KEY(memory_session_id) REFERENCES sessions(memory_session_id) ON DELETE CASCADE
            )
            """,
            """
            CREATE TABLE IF NOT EXISTS memory_links (
                link_id INTEGER PRIMARY KEY AUTOINCREMENT,
                memory_entry_id TEXT NOT NULL,
                source_kind TEXT NOT NULL,
                source_id INTEGER NOT NULL,
                score REAL DEFAULT 0.0,
                timestamp TEXT NOT NULL
            )
            """,
            """
            CREATE TABLE IF NOT EXISTS consolidation_runs (
                run_id INTEGER PRIMARY KEY AUTOINCREMENT,
                tenant_id TEXT NOT NULL DEFAULT 'default',
                timestamp TEXT NOT NULL,
                policy_json TEXT,
                stats_json TEXT
            )
            """,
        ]
        index_statements = [
            "CREATE INDEX IF NOT EXISTS idx_sessions_tenant ON sessions(tenant_id)",
            "CREATE INDEX IF NOT EXISTS idx_sessions_content_id ON sessions(content_session_id)",
            "CREATE INDEX IF NOT EXISTS idx_sessions_memory_id ON sessions(memory_session_id)",
            "CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)",
            "CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)",
            "CREATE INDEX IF NOT EXISTS idx_events_session ON session_events(memory_session_id)",
            "CREATE INDEX IF NOT EXISTS idx_events_kind ON session_events(kind)",
            "CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(memory_session_id)",
            "CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type)",
            "CREATE INDEX IF NOT EXISTS idx_summaries_session ON session_summaries(memory_session_id)",
            "CREATE INDEX IF NOT EXISTS idx_links_entry ON memory_links(memory_entry_id)",
            "CREATE INDEX IF NOT EXISTS idx_links_source ON memory_links(source_kind, source_id)",
        ]
        try:
            cursor = self.conn.cursor()
            for statement in schema_statements:
                _ = cursor.execute(statement)
            for statement in index_statements:
                _ = cursor.execute(statement)
            self.conn.commit()
        except sqlite3.Error:
            logger.exception("Failed to run SQLite migrations")
            self.conn.rollback()
            raise

    def create_session(
        self,
        tenant_id: str,
        content_session_id: str,
        project: str,
        user_prompt: Optional[str] = None,
        metadata: Optional[dict[str, object]] = None,
    ) -> SessionRecord:
        memory_session_id = str(uuid4())
        started_at = self._now_iso()
        metadata_json = json.dumps(metadata) if metadata is not None else None
        try:
            cursor = self.conn.cursor()
            cursor.execute(
                """
                INSERT OR IGNORE INTO sessions (
                    tenant_id, content_session_id, memory_session_id, project,
                    user_prompt, started_at, status, metadata_json
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    tenant_id,
                    content_session_id,
                    memory_session_id,
                    project,
                    user_prompt,
                    started_at,
                    "active",
                    metadata_json,
                ),
            )
            self.conn.commit()
        except sqlite3.Error:
            logger.exception("Failed to create session")
            self.conn.rollback()
            raise
        session = self.get_session_by_content_id(content_session_id)
        if session is None:
            raise RuntimeError("Failed to retrieve session after insert")
        return session

    def get_session_by_content_id(
        self, content_session_id: str
    ) -> Optional[SessionRecord]:
        return self._fetch_session(
            "SELECT * FROM sessions WHERE content_session_id = ?",
            (content_session_id,),
        )

    def get_session_by_memory_id(
        self, memory_session_id: str
    ) -> Optional[SessionRecord]:
        return self._fetch_session(
            "SELECT * FROM sessions WHERE memory_session_id = ?",
            (memory_session_id,),
        )

    def get_session_by_id(self, session_id: int) -> Optional[SessionRecord]:
        return self._fetch_session("SELECT * FROM sessions WHERE id = ?", (session_id,))

    def update_session_status(
        self,
        memory_session_id: str,
        status: SessionStatus,
        ended_at: Optional[str] = None,
    ) -> None:
        status_value = self._enum_to_value(status)
        if ended_at is None and status_value in {"completed", "failed"}:
            ended_at = self._now_iso()
        try:
            _ = self.conn.execute(
                """
                UPDATE sessions
                SET status = ?, ended_at = ?
                WHERE memory_session_id = ?
                """,
                (status_value, ended_at, memory_session_id),
            )
            self.conn.commit()
        except sqlite3.Error:
            logger.exception("Failed to update session status")
            self.conn.rollback()
            raise

    def list_sessions(
        self,
        tenant_id: Optional[str] = None,
        project: Optional[str] = None,
        status: Optional[SessionStatus] = None,
        limit: int = 50,
        offset: int = 0,
    ) -> list[SessionRecord]:
        where_clauses = []
        params: list[object] = []
        if tenant_id:
            where_clauses.append("tenant_id = ?")
            params.append(tenant_id)
        if project:
            where_clauses.append("project = ?")
            params.append(project)
        if status:
            status_value = self._enum_to_value(status)
            where_clauses.append("status = ?")
            params.append(status_value)
        where_sql = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
        query = (
            f"SELECT * FROM sessions {where_sql} "
            "ORDER BY started_at DESC LIMIT ? OFFSET ?"
        )
        params.extend([limit, offset])
        try:
            cursor = self.conn.execute(query, params)
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_session(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to list sessions")
            raise

    def add_event(
        self,
        memory_session_id: str,
        kind: EventKind,
        title: Optional[str] = None,
        payload_json: Optional[dict[str, object]] = None,
        redaction_level: Optional[RedactionLevel] = None,
    ) -> int:
        timestamp = self._now_iso()
        kind_value = self._enum_to_value(kind)
        redaction_value = self._enum_to_value(redaction_level, default="none")
        payload_text = json.dumps(payload_json) if payload_json is not None else None
        try:
            cursor = self.conn.execute(
                """
                INSERT INTO session_events (
                    memory_session_id, timestamp, kind, title, payload_json, redaction_level
                ) VALUES (?, ?, ?, ?, ?, ?)
                """,
                (
                    memory_session_id,
                    timestamp,
                    kind_value,
                    title,
                    payload_text,
                    redaction_value,
                ),
            )
            self.conn.commit()
            return self._lastrowid(cursor, "Failed to create session event")
        except sqlite3.Error:
            logger.exception("Failed to add session event")
            self.conn.rollback()
            raise

    def get_events_for_session(
        self,
        memory_session_id: str,
        kinds: Optional[Sequence[EventKind]] = None,
    ) -> list[SessionEvent]:
        params: list[object] = [memory_session_id]
        kind_clause = ""
        if kinds:
            placeholders = ",".join(["?"] * len(kinds))
            kind_clause = f" AND kind IN ({placeholders})"
            params.extend([k.value if hasattr(k, "value") else str(k) for k in kinds])
        query = (
            "SELECT * FROM session_events WHERE memory_session_id = ?"
            f"{kind_clause} ORDER BY timestamp ASC"
        )
        try:
            cursor = self.conn.execute(query, params)
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_event(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch session events")
            raise

    def store_observation(
        self,
        memory_session_id: str,
        type: ObservationType,
        title: str,
        subtitle: Optional[str] = None,
        facts_json: Optional[dict[str, object]] = None,
        narrative: Optional[str] = None,
        concepts_json: Optional[Iterable[str]] = None,
        files_json: Optional[Iterable[str]] = None,
        vector_ref: Optional[str] = None,
    ) -> int:
        timestamp = self._now_iso()
        type_value = type.value if hasattr(type, "value") else str(type)
        try:
            cursor = self.conn.execute(
                """
                INSERT INTO observations (
                    memory_session_id, timestamp, type, title, subtitle, facts_json,
                    narrative, concepts_json, files_json, vector_ref
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    memory_session_id,
                    timestamp,
                    type_value,
                    title,
                    subtitle,
                    json.dumps(facts_json) if facts_json is not None else None,
                    narrative,
                    json.dumps(list(concepts_json))
                    if concepts_json is not None
                    else None,
                    json.dumps(list(files_json)) if files_json is not None else None,
                    vector_ref,
                ),
            )
            self.conn.commit()
            return self._lastrowid(cursor, "Failed to store observation")
        except sqlite3.Error:
            logger.exception("Failed to store observation")
            self.conn.rollback()
            raise

    def get_observations_for_session(
        self, memory_session_id: str
    ) -> list[CrossObservation]:
        try:
            cursor = self.conn.execute(
                """
                SELECT * FROM observations
                WHERE memory_session_id = ?
                ORDER BY timestamp ASC
                """,
                (memory_session_id,),
            )
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_observation(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch observations for session")
            raise

    def get_recent_observations(
        self,
        project: str,
        limit: int = 50,
        types: Optional[Sequence[ObservationType]] = None,
    ) -> list[CrossObservation]:
        params: list[object] = [project]
        type_clause = ""
        if types:
            placeholders = ",".join(["?"] * len(types))
            type_clause = f" AND observations.type IN ({placeholders})"
            params.extend([t.value if hasattr(t, "value") else str(t) for t in types])
        query = (
            """
            SELECT observations.* FROM observations
            JOIN sessions ON sessions.memory_session_id = observations.memory_session_id
            WHERE sessions.project = ?
            """
            f"{type_clause} ORDER BY observations.timestamp DESC LIMIT ?"
        )
        params.append(limit)
        try:
            cursor = self.conn.execute(query, params)
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_observation(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch recent observations")
            raise

    def get_observations_by_ids(self, obs_ids: list[int]) -> list[CrossObservation]:
        if not obs_ids:
            return []
        placeholders = ",".join(["?"] * len(obs_ids))
        query = f"SELECT * FROM observations WHERE obs_id IN ({placeholders})"
        try:
            cursor = self.conn.execute(query, obs_ids)
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_observation(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch observations by ids")
            raise

    def store_summary(
        self,
        memory_session_id: str,
        request: Optional[str] = None,
        investigated: Optional[str] = None,
        learned: Optional[str] = None,
        completed: Optional[str] = None,
        next_steps: Optional[str] = None,
        vector_ref: Optional[str] = None,
    ) -> int:
        timestamp = self._now_iso()
        try:
            cursor = self.conn.execute(
                """
                INSERT INTO session_summaries (
                    memory_session_id, timestamp, request, investigated,
                    learned, completed, next_steps, vector_ref
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    memory_session_id,
                    timestamp,
                    request,
                    investigated,
                    learned,
                    completed,
                    next_steps,
                    vector_ref,
                ),
            )
            self.conn.commit()
            return self._lastrowid(cursor, "Failed to store session summary")
        except sqlite3.Error:
            logger.exception("Failed to store session summary")
            self.conn.rollback()
            raise

    def get_summary_for_session(
        self, memory_session_id: str
    ) -> Optional[SessionSummary]:
        try:
            cursor = self.conn.execute(
                """
                SELECT * FROM session_summaries
                WHERE memory_session_id = ?
                ORDER BY timestamp DESC
                LIMIT 1
                """,
                (memory_session_id,),
            )
            row = cast(Optional[sqlite3.Row], cursor.fetchone())
            return self._row_to_summary(row) if row else None
        except sqlite3.Error:
            logger.exception("Failed to fetch session summary")
            raise

    def get_recent_summaries(
        self, project: str, limit: int = 10
    ) -> list[SessionSummary]:
        try:
            cursor = self.conn.execute(
                """
                SELECT session_summaries.* FROM session_summaries
                JOIN sessions ON sessions.memory_session_id = session_summaries.memory_session_id
                WHERE sessions.project = ?
                ORDER BY session_summaries.timestamp DESC
                LIMIT ?
                """,
                (project, limit),
            )
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_summary(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch recent summaries")
            raise

    def create_link(
        self,
        memory_entry_id: str,
        source_kind: str,
        source_id: int,
        score: float = 0.0,
    ) -> int:
        timestamp = self._now_iso()
        try:
            cursor = self.conn.execute(
                """
                INSERT INTO memory_links (
                    memory_entry_id, source_kind, source_id, score, timestamp
                ) VALUES (?, ?, ?, ?, ?)
                """,
                (memory_entry_id, source_kind, source_id, score, timestamp),
            )
            self.conn.commit()
            return self._lastrowid(cursor, "Failed to create memory link")
        except sqlite3.Error:
            logger.exception("Failed to create memory link")
            self.conn.rollback()
            raise

    def get_links_for_entry(self, memory_entry_id: str) -> list[MemoryLink]:
        try:
            cursor = self.conn.execute(
                """
                SELECT * FROM memory_links
                WHERE memory_entry_id = ?
                ORDER BY score DESC, timestamp DESC
                """,
                (memory_entry_id,),
            )
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_link(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch links for entry")
            raise

    def get_links_for_source(
        self, source_kind: str, source_id: int
    ) -> list[MemoryLink]:
        try:
            cursor = self.conn.execute(
                """
                SELECT * FROM memory_links
                WHERE source_kind = ? AND source_id = ?
                ORDER BY score DESC, timestamp DESC
                """,
                (source_kind, source_id),
            )
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_link(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch links for source")
            raise

    def record_consolidation_run(
        self,
        tenant_id: str,
        policy_json: Optional[dict[str, object]] = None,
        stats_json: Optional[dict[str, object]] = None,
    ) -> int:
        timestamp = self._now_iso()
        try:
            cursor = self.conn.execute(
                """
                INSERT INTO consolidation_runs (
                    tenant_id, timestamp, policy_json, stats_json
                ) VALUES (?, ?, ?, ?)
                """,
                (
                    tenant_id,
                    timestamp,
                    json.dumps(policy_json) if policy_json is not None else None,
                    json.dumps(stats_json) if stats_json is not None else None,
                ),
            )
            self.conn.commit()
            return self._lastrowid(cursor, "Failed to record consolidation run")
        except sqlite3.Error:
            logger.exception("Failed to record consolidation run")
            self.conn.rollback()
            raise

    def get_recent_consolidation_runs(
        self,
        tenant_id: str,
        limit: int = 10,
    ) -> list[ConsolidationRun]:
        try:
            cursor = self.conn.execute(
                """
                SELECT * FROM consolidation_runs
                WHERE tenant_id = ?
                ORDER BY timestamp DESC
                LIMIT ?
                """,
                (tenant_id, limit),
            )
            rows = cast(list[sqlite3.Row], cursor.fetchall())
            return [self._row_to_consolidation_run(row) for row in rows]
        except sqlite3.Error:
            logger.exception("Failed to fetch consolidation runs")
            raise

    def get_stats(
        self, tenant_id: Optional[str] = None, project: Optional[str] = None
    ) -> dict[str, int]:
        stats: dict[str, int] = {}
        stats["sessions"] = self._count_sessions(tenant_id, project)
        stats["events"] = self._count_events(tenant_id, project)
        stats["observations"] = self._count_observations(tenant_id, project)
        stats["summaries"] = self._count_summaries(tenant_id, project)
        return stats

    def _fetch_session(
        self, query: str, params: Sequence[object]
    ) -> Optional[SessionRecord]:
        try:
            cursor = self.conn.execute(query, params)
            row = cast(Optional[sqlite3.Row], cursor.fetchone())
            return self._row_to_session(row) if row else None
        except sqlite3.Error:
            logger.exception("Failed to fetch session")
            raise

    def _row_to_session(self, row: sqlite3.Row) -> SessionRecord:
        data = cast(dict[str, object], dict(row))
        data["status"] = self._coerce_enum(SessionStatus, data.get("status"))
        return self._build_model(SessionRecord, data)

    def _row_to_event(self, row: sqlite3.Row) -> SessionEvent:
        data = cast(dict[str, object], dict(row))
        data["kind"] = self._coerce_enum(EventKind, data.get("kind"))
        data["redaction_level"] = self._coerce_enum(
            RedactionLevel, data.get("redaction_level")
        )
        return self._build_model(SessionEvent, data)

    def _row_to_observation(self, row: sqlite3.Row) -> CrossObservation:
        data = cast(dict[str, object], dict(row))
        data["type"] = self._coerce_enum(ObservationType, data.get("type"))
        return self._build_model(CrossObservation, data)

    def _row_to_summary(self, row: sqlite3.Row) -> SessionSummary:
        data = cast(dict[str, object], dict(row))
        return self._build_model(SessionSummary, data)

    def _row_to_link(self, row: sqlite3.Row) -> MemoryLink:
        data = cast(dict[str, object], dict(row))
        return self._build_model(MemoryLink, data)

    def _row_to_consolidation_run(self, row: sqlite3.Row) -> ConsolidationRun:
        data = cast(dict[str, object], dict(row))
        return self._build_model(ConsolidationRun, data)

    def _count_sessions(self, tenant_id: Optional[str], project: Optional[str]) -> int:
        where_clauses = []
        params: list[object] = []
        if tenant_id:
            where_clauses.append("tenant_id = ?")
            params.append(tenant_id)
        if project:
            where_clauses.append("project = ?")
            params.append(project)
        where_sql = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
        query = f"SELECT COUNT(*) FROM sessions {where_sql}"
        return self._fetch_count(query, params)

    def _count_events(self, tenant_id: Optional[str], project: Optional[str]) -> int:
        return self._count_joined(
            "session_events",
            "session_events.memory_session_id = sessions.memory_session_id",
            tenant_id,
            project,
        )

    def _count_observations(
        self, tenant_id: Optional[str], project: Optional[str]
    ) -> int:
        return self._count_joined(
            "observations",
            "observations.memory_session_id = sessions.memory_session_id",
            tenant_id,
            project,
        )

    def _count_summaries(self, tenant_id: Optional[str], project: Optional[str]) -> int:
        return self._count_joined(
            "session_summaries",
            "session_summaries.memory_session_id = sessions.memory_session_id",
            tenant_id,
            project,
        )

    def _count_joined(
        self,
        table: str,
        join_condition: str,
        tenant_id: Optional[str],
        project: Optional[str],
    ) -> int:
        where_clauses = []
        params: list[object] = []
        if tenant_id:
            where_clauses.append("sessions.tenant_id = ?")
            params.append(tenant_id)
        if project:
            where_clauses.append("sessions.project = ?")
            params.append(project)
        where_sql = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
        query = (
            f"SELECT COUNT(*) FROM {table} "
            f"JOIN sessions ON {join_condition} {where_sql}"
        )
        return self._fetch_count(query, params)

    def _fetch_count(self, query: str, params: Sequence[object]) -> int:
        try:
            cursor = self.conn.execute(query, params)
            row = cast(Optional[sqlite3.Row], cursor.fetchone())
            if row is None:
                return 0
            return int(cast(int, row[0]))
        except sqlite3.Error:
            logger.exception("Failed to fetch count")
            raise

    @staticmethod
    def _now_iso() -> str:
        return datetime.now(timezone.utc).isoformat()

    @staticmethod
    def _loads_json(payload: object) -> object:
        if payload is None:
            return None
        if not isinstance(payload, str):
            return payload
        try:
            return cast(object, json.loads(payload))
        except json.JSONDecodeError:
            logger.exception("Failed to decode JSON payload")
            return None

    @staticmethod
    def _build_model(model_cls, data: dict[str, object]):
        if hasattr(model_cls, "model_fields"):
            allowed = set(model_cls.model_fields.keys())
        elif hasattr(model_cls, "__fields__"):
            allowed = set(model_cls.__fields__.keys())
        elif hasattr(model_cls, "__dataclass_fields__"):
            allowed = set(model_cls.__dataclass_fields__.keys())
        elif hasattr(model_cls, "__annotations__"):
            allowed = set(model_cls.__annotations__.keys())
        else:
            return model_cls(**data)
        filtered = {key: value for key, value in data.items() if key in allowed}
        return model_cls(**filtered)

    @staticmethod
    def _coerce_enum(enum_cls, value: object) -> object:
        if value is None:
            return None
        if isinstance(value, enum_cls):
            return value
        if isinstance(value, str):
            try:
                return enum_cls(value)
            except Exception:
                return value
        return value

    @staticmethod
    def _enum_to_value(value: object, default: Optional[str] = None) -> Optional[str]:
        if value is None:
            return default
        value_attr = cast(object, getattr(value, "value", None))
        if value_attr is not None:
            return str(value_attr)
        return str(value)

    @staticmethod
    def _lastrowid(cursor: sqlite3.Cursor, error_message: str) -> int:
        lastrowid = cursor.lastrowid
        if lastrowid is None:
            raise RuntimeError(error_message)
        return int(lastrowid)