feat: add checksummed database migrations

2026-07-12 23:53:26 +03:00
parent 355bb23d5e
commit 882ae97fcf
10 changed files with 374 additions and 1 deletions
@@ -0,0 +1,16 @@
+"""Apply configured database migrations."""
+
+import asyncio
+
+from app.config import get_settings
+from app.db.migrations import migrate_url
+
+
+async def run() -> None:
+    settings = get_settings()
+    count = await migrate_url(settings.database_url.get_secret_value())
+    print(f"applied {count} migration(s)")
+
+
+if __name__ == "__main__":
+    asyncio.run(run())
@@ -0,0 +1,70 @@
+"""Checksummed asynchronous PostgreSQL migration runner."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+import asyncpg  # type: ignore[import-untyped]
+from asyncpg import Connection
+
+
+class MigrationError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class Migration:
+    version: int
+    name: str
+    sql: str
+    checksum: str
+
+
+def load_migrations(root: Path | None = None) -> tuple[Migration, ...]:
+    directory = root or Path(__file__).with_name("migrations")
+    migrations = []
+    for path in sorted(directory.glob("[0-9][0-9][0-9]_*.sql")):
+        version = int(path.name.split("_", 1)[0])
+        sql = path.read_text()
+        migrations.append(
+            Migration(version, path.stem, sql, hashlib.sha256(sql.encode()).hexdigest())
+        )
+    return tuple(migrations)
+
+
+async def migrate(connection: Connection, migrations: tuple[Migration, ...] | None = None) -> int:
+    await connection.execute(
+        """CREATE TABLE IF NOT EXISTS schema_migrations (
+        version integer PRIMARY KEY, name text NOT NULL, checksum text NOT NULL,
+        applied_at timestamptz NOT NULL DEFAULT now())"""
+    )
+    applied = {
+        int(row["version"]): str(row["checksum"])
+        for row in await connection.fetch("SELECT version, checksum FROM schema_migrations")
+    }
+    count = 0
+    for migration in migrations or load_migrations():
+        if migration.version in applied:
+            if applied[migration.version] != migration.checksum:
+                raise MigrationError(f"migration {migration.version} checksum mismatch")
+            continue
+        async with connection.transaction():
+            await connection.execute(migration.sql)
+            await connection.execute(
+                "INSERT INTO schema_migrations(version, name, checksum) VALUES($1, $2, $3)",
+                migration.version,
+                migration.name,
+                migration.checksum,
+            )
+        count += 1
+    return count
+
+
+async def migrate_url(database_url: str) -> int:
+    connection = await asyncpg.connect(database_url)
+    try:
+        return await migrate(connection)
+    finally:
+        await connection.close()
@@ -0,0 +1,60 @@
+CREATE TABLE contract_snapshots (
+    checksum text PRIMARY KEY,
+    source_version text NOT NULL,
+    document jsonb NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE TABLE nodes (
+    id uuid PRIMARY KEY,
+    name text NOT NULL UNIQUE,
+    status text NOT NULL CHECK (status IN ('online', 'offline'))
+);
+CREATE TABLE resources (
+    id uuid PRIMARY KEY,
+    node_id uuid NOT NULL REFERENCES nodes(id) ON DELETE RESTRICT,
+    kind text NOT NULL,
+    external_id text NOT NULL,
+    state jsonb NOT NULL DEFAULT '{}'::jsonb,
+    UNIQUE (kind, external_id)
+);
+CREATE INDEX resources_node_id_idx ON resources(node_id);
+CREATE TABLE principals (
+    id uuid PRIMARY KEY,
+    name text NOT NULL UNIQUE,
+    password_hash text
+);
+CREATE TABLE roles (
+    name text PRIMARY KEY,
+    privileges text[] NOT NULL DEFAULT '{}'
+);
+CREATE TABLE acl_entries (
+    principal_id uuid NOT NULL REFERENCES principals(id) ON DELETE CASCADE,
+    role_name text NOT NULL REFERENCES roles(name) ON DELETE RESTRICT,
+    path text NOT NULL,
+    propagate boolean NOT NULL DEFAULT true,
+    PRIMARY KEY (principal_id, role_name, path)
+);
+CREATE TABLE tasks (
+    id uuid PRIMARY KEY,
+    upid text NOT NULL UNIQUE,
+    status text NOT NULL,
+    payload jsonb NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX tasks_status_created_idx ON tasks(status, created_at);
+CREATE TABLE scenarios (
+    id uuid PRIMARY KEY,
+    name text NOT NULL UNIQUE,
+    definition jsonb NOT NULL,
+    enabled boolean NOT NULL DEFAULT true
+);
+CREATE TABLE audit_events (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    occurred_at timestamptz NOT NULL DEFAULT now(),
+    principal text,
+    action text NOT NULL,
+    target text,
+    details jsonb NOT NULL DEFAULT '{}'::jsonb
+);
+CREATE INDEX audit_events_occurred_idx ON audit_events(occurred_at);
@@ -0,0 +1,94 @@
+"""Typed transactional helpers and stable database error mapping."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+
+import asyncpg  # type: ignore[import-untyped]
+from asyncpg import Connection, Pool
+
+
+class DatabaseOperationError(RuntimeError):
+    """Safe base error for repository operations."""
+
+
+class ConflictError(DatabaseOperationError):
+    pass
+
+
+class ReferenceError(DatabaseOperationError):
+    pass
+
+
+class TransientDatabaseError(DatabaseOperationError):
+    pass
+
+
+def map_database_error(error: asyncpg.PostgresError) -> DatabaseOperationError:
+    if isinstance(error, asyncpg.UniqueViolationError):
+        return ConflictError("database uniqueness constraint failed")
+    if isinstance(error, asyncpg.ForeignKeyViolationError):
+        return ReferenceError("database reference constraint failed")
+    if isinstance(
+        error,
+        asyncpg.SerializationError
+        | asyncpg.DeadlockDetectedError
+        | asyncpg.TooManyConnectionsError,
+    ):
+        return TransientDatabaseError("transient database failure")
+    return DatabaseOperationError("database operation failed")
+
+
+@asynccontextmanager
+async def transaction(pool: Pool) -> AsyncIterator[Connection]:
+    async with pool.acquire() as connection:
+        try:
+            async with connection.transaction():
+                yield connection
+        except asyncpg.PostgresError as error:
+            raise map_database_error(error) from error
+
+
+@asynccontextmanager
+async def savepoint(connection: Connection) -> AsyncIterator[Connection]:
+    try:
+        async with connection.transaction():
+            yield connection
+    except asyncpg.PostgresError as error:
+        raise map_database_error(error) from error
+
+
+def require_affected(status: str, expected: int = 1) -> None:
+    try:
+        affected = int(status.rsplit(" ", 1)[1])
+    except (IndexError, ValueError) as error:
+        raise DatabaseOperationError(f"unrecognized command status: {status}") from error
+    if affected != expected:
+        raise DatabaseOperationError(f"expected {expected} affected row(s), got {affected}")
+
+
+@dataclass(frozen=True, slots=True)
+class RetryPolicy:
+    attempts: int = 3
+    base_delay_seconds: float = 0.02
+
+
+DEFAULT_RETRY_POLICY = RetryPolicy()
+
+
+async def retry_transient[T](
+    operation: Callable[[], Awaitable[T]], policy: RetryPolicy = DEFAULT_RETRY_POLICY
+) -> T:
+    if policy.attempts < 1:
+        raise ValueError("retry attempts must be positive")
+    for attempt in range(policy.attempts):
+        try:
+            return await operation()
+        except TransientDatabaseError:
+            if attempt + 1 == policy.attempts:
+                raise
+            await asyncio.sleep(policy.base_delay_seconds * (2**attempt))
+    raise RuntimeError("unreachable retry state")