oxyde-postgres 0.1.0__py3-none-any.whl

oxyde/migrations/replay.py

@@ -0,0 +1,367 @@
+"""Replay migrations in memory to build schema state."""
+
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+from typing import Any
+
+from oxyde.migrations.context import MigrationContext
+from oxyde.migrations.utils import (
+    load_migration_module,
+    normalize_field_dict,
+    op_uses_legacy_fields,
+)
+
+
+def _add_enum_value_to_spec(
+    spec: dict[str, Any], name: str, value: str
+) -> dict[str, Any]:
+    if spec.get("kind") == "enum" and spec.get("name") == name:
+        updated = dict(spec)
+        values = list(updated.get("values", []))
+        if value not in values:
+            values.append(value)
+        updated["values"] = values
+        return updated
+    if spec.get("kind") == "array" and isinstance(spec.get("item"), dict):
+        updated = dict(spec)
+        updated["item"] = _add_enum_value_to_spec(spec["item"], name, value)
+        return updated
+    return spec
+
+
+def _replace_enum_values_in_spec(
+    spec: dict[str, Any],
+    name: str,
+    values: list[str],
+) -> dict[str, Any]:
+    if spec.get("kind") == "enum" and spec.get("name") == name:
+        updated = dict(spec)
+        updated["values"] = list(values)
+        return updated
+    if spec.get("kind") == "array" and isinstance(spec.get("item"), dict):
+        updated = dict(spec)
+        updated["item"] = _replace_enum_values_in_spec(spec["item"], name, values)
+        return updated
+    return spec
+
+
+class SchemaState:
+    """Represents database schema in memory.
+
+    This class applies migration operations to build a virtual schema
+    without touching the actual database.
+    """
+
+    def __init__(self) -> None:
+        self.tables: dict[str, dict[str, Any]] = {}
+
+    def apply_operation(self, op: dict[str, Any]) -> None:
+        """Apply a migration operation to the virtual schema.
+
+        Args:
+            op: Operation dictionary from MigrationContext.get_collected_operations()
+        """
+        op_type = op.get("type")
+
+        if op_type == "create_enum_type":
+            pass
+
+        elif op_type == "drop_enum_type":
+            pass
+
+        elif op_type == "add_enum_value":
+            enum_name = op["name"]
+            enum_value = op["value"]
+            for table in self.tables.values():
+                for field in table["fields"]:
+                    if column_type := field.get("column_type"):
+                        field["column_type"] = _add_enum_value_to_spec(
+                            column_type,
+                            enum_name,
+                            enum_value,
+                        )
+
+        elif op_type == "alter_enum_type":
+            enum_name = op["name"]
+            enum_values = op["new_values"]
+            for table in self.tables.values():
+                for field in table["fields"]:
+                    if column_type := field.get("column_type"):
+                        field["column_type"] = _replace_enum_values_in_spec(
+                            column_type,
+                            enum_name,
+                            enum_values,
+                        )
+
+        elif op_type == "create_table":
+            table = op["table"]
+            self.tables[table["name"]] = {
+                "name": table["name"],
+                "fields": list(table["fields"]),
+                "indexes": list(table.get("indexes", [])),
+                "foreign_keys": list(table.get("foreign_keys", [])),
+                "checks": list(table.get("checks", [])),
+                "comment": table.get("comment"),
+            }
+
+        elif op_type == "drop_table":
+            self.tables.pop(op["name"], None)
+
+        elif op_type == "rename_table":
+            old_name = op["old_name"]
+            new_name = op["new_name"]
+            if old_name in self.tables:
+                table = self.tables.pop(old_name)
+                table["name"] = new_name
+                self.tables[new_name] = table
+
+        elif op_type == "add_column":
+            table_name = op["table"]
+            if table_name in self.tables:
+                self.tables[table_name]["fields"].append(dict(op["field"]))
+
+        elif op_type == "drop_column":
+            table_name = op["table"]
+            field_name = op["field"]
+            if table_name in self.tables:
+                self.tables[table_name]["fields"] = [
+                    f
+                    for f in self.tables[table_name]["fields"]
+                    if f["name"] != field_name
+                ]
+
+        elif op_type == "rename_column":
+            table_name = op["table"]
+            old_name = op["old_name"]
+            new_name = op["new_name"]
+            if table_name in self.tables:
+                for field in self.tables[table_name]["fields"]:
+                    if field["name"] == old_name:
+                        field["name"] = new_name
+                        break
+
+        elif op_type == "alter_column":
+            table_name = op["table"]
+            column_name = op["column"]
+            changes = op.get("changes", {})
+            if table_name in self.tables:
+                for field in self.tables[table_name]["fields"]:
+                    if field["name"] == column_name:
+                        # Map changes keys to field keys
+                        if "column_type" in changes:
+                            field["column_type"] = changes["column_type"]
+                        # Legacy keys from old migration files
+                        if "type" in changes:
+                            field["python_type"] = changes["type"]
+                            field.pop("column_type", None)
+                        if "python_type" in changes:
+                            field["python_type"] = changes["python_type"]
+                            field.pop("column_type", None)
+                        if "db_type" in changes:
+                            field["db_type"] = changes["db_type"]
+                        if "nullable" in changes:
+                            field["nullable"] = changes["nullable"]
+                        if "default" in changes:
+                            field["default"] = changes["default"]
+                        if "unique" in changes:
+                            field["unique"] = changes["unique"]
+                        if "max_length" in changes:
+                            field["max_length"] = changes["max_length"]
+                        if "max_digits" in changes:
+                            field["max_digits"] = changes["max_digits"]
+                        if "decimal_places" in changes:
+                            field["decimal_places"] = changes["decimal_places"]
+                        break
+
+        elif op_type == "create_index":
+            table_name = op["table"]
+            if table_name in self.tables:
+                self.tables[table_name]["indexes"].append(dict(op["index"]))
+
+        elif op_type == "drop_index":
+            table_name = op["table"]
+            index_name = op["name"]
+            if table_name in self.tables:
+                self.tables[table_name]["indexes"] = [
+                    idx
+                    for idx in self.tables[table_name]["indexes"]
+                    if idx["name"] != index_name
+                ]
+
+        elif op_type == "add_foreign_key":
+            table_name = op["table"]
+            if table_name in self.tables:
+                if "foreign_keys" not in self.tables[table_name]:
+                    self.tables[table_name]["foreign_keys"] = []
+                self.tables[table_name]["foreign_keys"].append(dict(op["fk"]))
+
+        elif op_type == "drop_foreign_key":
+            table_name = op["table"]
+            fk_name = op["name"]
+            if table_name in self.tables and "foreign_keys" in self.tables[table_name]:
+                self.tables[table_name]["foreign_keys"] = [
+                    fk
+                    for fk in self.tables[table_name]["foreign_keys"]
+                    if fk["name"] != fk_name
+                ]
+
+        elif op_type == "add_check":
+            table_name = op["table"]
+            if table_name in self.tables:
+                if "checks" not in self.tables[table_name]:
+                    self.tables[table_name]["checks"] = []
+                self.tables[table_name]["checks"].append(dict(op["check"]))
+
+        elif op_type == "drop_check":
+            table_name = op["table"]
+            check_name = op["name"]
+            if table_name in self.tables and "checks" in self.tables[table_name]:
+                self.tables[table_name]["checks"] = [
+                    c
+                    for c in self.tables[table_name]["checks"]
+                    if c["name"] != check_name
+                ]
+
+        # Note: ctx.execute() and Python code are ignored - they don't affect schema
+
+    def to_snapshot(self) -> dict[str, Any]:
+        """Convert to Rust-compatible snapshot format.
+
+        Normalizes legacy field dicts (python_type form from old migration
+        files) into the ColumnTypeSpec form Rust requires. This is the single
+        legacy-reading point; it becomes a hard error in 1.0.
+
+        Returns:
+            Snapshot dictionary compatible with Rust Snapshot structure
+        """
+        tables: dict[str, Any] = {}
+        for name, table in self.tables.items():
+            table = dict(table)
+            table["fields"] = [normalize_field_dict(f) for f in table["fields"]]
+            # Copy mutable collections: a snapshot must not alias live state
+            for key in ("indexes", "foreign_keys", "checks"):
+                table[key] = [dict(item) for item in table.get(key, [])]
+            tables[name] = table
+        return {
+            "version": 1,
+            "tables": tables,
+        }
+
+
+def _get_migration_dependency(module: Any) -> str | None:
+    """Get the depends_on value from a migration module.
+
+    Args:
+        module: Loaded migration module
+
+    Returns:
+        Name of dependency migration or None
+    """
+    return getattr(module, "depends_on", None)
+
+
+def _topological_sort_migrations(
+    migration_files: list[Path],
+) -> list[Path]:
+    """Sort migrations in topological order based on depends_on.
+
+    Args:
+        migration_files: List of migration file paths
+
+    Returns:
+        Migrations sorted in dependency order
+
+    Raises:
+        ValueError: If circular dependency detected
+    """
+    # Build dependency graph
+    modules: dict[str, tuple[Path, Any]] = {}
+    for file in migration_files:
+        module = load_migration_module(file)
+        if module is not None:
+            modules[file.stem] = (file, module)
+
+    # Build adjacency list (name -> depends_on)
+    dependencies: dict[str, str | None] = {}
+    for name, (_, module) in modules.items():
+        dependencies[name] = _get_migration_dependency(module)
+
+    # Topological sort using Kahn's algorithm
+    # Count incoming edges
+    in_degree: dict[str, int] = {name: 0 for name in modules}
+    for name, dep in dependencies.items():
+        if dep is not None and dep in in_degree:
+            in_degree[name] = 1  # Has one dependency
+
+    # Start with nodes that have no dependencies
+    queue = [name for name, degree in in_degree.items() if degree == 0]
+    result: list[Path] = []
+
+    while queue:
+        # Sort queue to ensure deterministic order (by migration name)
+        queue.sort()
+        current = queue.pop(0)
+        result.append(modules[current][0])
+
+        # Find migrations that depend on current
+        for name, dep in dependencies.items():
+            if dep == current:
+                in_degree[name] -= 1
+                if in_degree[name] == 0:
+                    queue.append(name)
+
+    # Check for circular dependencies
+    if len(result) != len(modules):
+        applied = {f.stem for f in result}
+        remaining = set(modules.keys()) - applied
+        raise ValueError(f"Circular dependency detected in migrations: {remaining}")
+
+    return result
+
+
+def replay_migrations(migrations_dir: str = "migrations") -> dict[str, Any]:
+    """Replay all migrations and return final schema as snapshot.
+
+    Migrations are applied in topological order based on their depends_on field.
+
+    Args:
+        migrations_dir: Directory containing migration files
+
+    Returns:
+        Schema snapshot after replaying all migrations
+    """
+    state = SchemaState()
+    migration_files = sorted(Path(migrations_dir).glob("[0-9]*.py"))
+
+    # Sort migrations by dependencies
+    sorted_files = _topological_sort_migrations(migration_files)
+
+    for file in sorted_files:
+        module = load_migration_module(file)
+        if module is None:
+            continue
+
+        # Run upgrade() in "collect" mode
+        if hasattr(module, "upgrade"):
+            ctx = MigrationContext(mode="collect")
+            module.upgrade(ctx)
+
+            # Apply collected operations to virtual schema
+            operations = ctx.get_collected_operations()
+            if any(op_uses_legacy_fields(op) for op in operations):
+                warnings.warn(
+                    f"Migration file '{file.name}' uses the legacy field format "
+                    "(python_type). Support will be removed in oxyde 1.0 — "
+                    "run `oxyde migrations squash` to convert.",
+                    FutureWarning,
+                    stacklevel=2,
+                )
+            for op in operations:
+                state.apply_operation(op)
+
+    return state.to_snapshot()
+
+
+__all__ = ["SchemaState", "replay_migrations", "_topological_sort_migrations"]

oxyde/migrations/squash.py

@@ -0,0 +1,109 @@
+"""Squash migration history into a single initial migration.
+
+Replays all migration files in memory, computes the final schema, and
+replaces the whole history with one ``0001_<name>.py`` written in the
+current (ColumnTypeSpec) format. This is the conversion path the legacy
+format FutureWarning points to; legacy-format support is removed in 1.0.
+
+Manual operations (``ctx.execute()`` with raw SQL) are schema-neutral and
+are NOT carried over — affected files are reported so the user can move
+that logic manually.
+
+Old files are deleted after the new file is generated successfully
+(version control is the backup). The new file is rendered into a temporary
+directory first, so a generation failure cannot lose existing history.
+
+For already-deployed databases the new initial migration must be recorded
+without executing: ``oxyde migrate --fake``. Orphaned tracker records of
+the old migration names are harmless (pending = files − applied).
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from oxyde.core import migration_compute_diff
+from oxyde.migrations.context import MigrationContext
+from oxyde.migrations.generator import generate_migration_file
+from oxyde.migrations.replay import SchemaState, _topological_sort_migrations
+from oxyde.migrations.utils import load_migration_module, op_uses_legacy_fields
+
+
+@dataclass
+class SquashResult:
+    """Outcome of a squash run."""
+
+    new_file: Path | None
+    deleted_files: list[str] = field(default_factory=list)
+    raw_sql_files: list[str] = field(default_factory=list)
+    legacy_files: list[str] = field(default_factory=list)
+    table_count: int = 0
+
+
+def squash_migrations(
+    migrations_dir: str | Path,
+    name: str = "squashed",
+) -> SquashResult:
+    """Squash all migrations in ``migrations_dir`` into one initial file.
+
+    Returns a SquashResult; ``new_file is None`` means there was nothing
+    to squash (no migration files found).
+    """
+    migrations_path = Path(migrations_dir)
+    files = sorted(migrations_path.glob("[0-9]*.py"))
+    if not files:
+        return SquashResult(new_file=None)
+
+    # Replay history per file, tracking raw-SQL and legacy-format usage
+    state = SchemaState()
+    raw_sql_files: list[str] = []
+    legacy_files: list[str] = []
+
+    for file in _topological_sort_migrations(files):
+        module = load_migration_module(file)
+        if module is None or not hasattr(module, "upgrade"):
+            continue
+        ctx = MigrationContext(mode="collect")
+        module.upgrade(ctx)
+        if ctx.has_raw_sql:
+            raw_sql_files.append(file.name)
+        operations = ctx.get_collected_operations()
+        if any(op_uses_legacy_fields(op) for op in operations):
+            legacy_files.append(file.name)
+        for op in operations:
+            state.apply_operation(op)
+
+    # Final schema → create ops via the Rust diff (empty → state):
+    # CreateTable operations come out topologically sorted by FK deps.
+    snapshot = state.to_snapshot()
+    empty = {"version": 1, "tables": {}}
+    ops_json = migration_compute_diff(json.dumps(empty), json.dumps(snapshot))
+    ops = json.loads(ops_json)
+
+    # Render into a temp dir first: numbering restarts at 0001 and a
+    # generation failure cannot lose the existing history.
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_file = generate_migration_file(ops, migrations_dir=tmp, name=name)
+        content = tmp_file.read_text()
+        new_name = tmp_file.name
+
+    deleted = [f.name for f in files]
+    for f in files:
+        f.unlink()
+
+    new_file = migrations_path / new_name
+    new_file.write_text(content)
+
+    return SquashResult(
+        new_file=new_file,
+        deleted_files=deleted,
+        raw_sql_files=raw_sql_files,
+        legacy_files=legacy_files,
+        table_count=len(snapshot["tables"]),
+    )
+
+
+__all__ = ["SquashResult", "squash_migrations"]

oxyde/migrations/tracker.py

@@ -0,0 +1,162 @@
+"""Migration history tracking."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from oxyde.core.ir import build_raw_sql_ir
+from oxyde.db.registry import get_connection as _get_connection_async
+from oxyde.migrations.replay import _topological_sort_migrations
+from oxyde.migrations.utils import detect_dialect, parse_query_result
+
+MIGRATIONS_TABLE = "oxyde_migrations"
+
+
+async def ensure_migrations_table(db_alias: str = "default") -> None:
+    """Create migrations tracking table if it doesn't exist.
+
+    Args:
+        db_alias: Database connection alias
+    """
+    db_conn = await _get_connection_async(db_alias)
+
+    detect_dialect(db_conn.url)
+
+    # Generate dialect-specific SQL
+    create_sql = f"""
+    CREATE TABLE IF NOT EXISTS {MIGRATIONS_TABLE} (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        applied_at TIMESTAMP NOT NULL
+    )
+    """
+
+    # Execute using IR
+    create_ir = build_raw_sql_ir(sql=create_sql)
+    await db_conn.execute(create_ir)
+
+
+async def get_applied_migrations(db_alias: str = "default") -> list[str]:
+    """Get list of applied migration names.
+
+    Args:
+        db_alias: Database connection alias
+
+    Returns:
+        List of applied migration names (sorted by applied_at)
+    """
+    await ensure_migrations_table(db_alias)
+
+    db_conn = await _get_connection_async(db_alias)
+
+    # Query applied migrations
+    query_sql = f"""
+    SELECT name FROM {MIGRATIONS_TABLE}
+    ORDER BY id ASC
+    """
+
+    query_ir = build_raw_sql_ir(sql=query_sql)
+    result_bytes = await db_conn.execute(query_ir)
+    rows = parse_query_result(result_bytes)
+    return [row["name"] for row in rows if "name" in row]
+
+
+async def record_migration(name: str, db_alias: str = "default") -> None:
+    """Record that a migration has been applied.
+
+    Args:
+        name: Migration name (e.g., "0001_initial")
+        db_alias: Database connection alias
+    """
+    await ensure_migrations_table(db_alias)
+
+    db_conn = await _get_connection_async(db_alias)
+
+    detect_dialect(db_conn.url)
+
+    # Insert migration record with dialect-specific SQL
+    insert_sql = f"""
+    INSERT INTO {MIGRATIONS_TABLE} (name, applied_at)
+    VALUES ($1, NOW())
+    """
+    params = [name]
+
+    insert_ir = build_raw_sql_ir(
+        sql=insert_sql,
+        params=params,
+    )
+    await db_conn.execute(insert_ir)
+
+
+async def remove_migration(name: str, db_alias: str = "default") -> None:
+    """Remove a migration record (for rollback).
+
+    Args:
+        name: Migration name to remove
+        db_alias: Database connection alias
+    """
+    db_conn = await _get_connection_async(db_alias)
+
+    detect_dialect(db_conn.url)
+
+    delete_sql = f"""
+    DELETE FROM {MIGRATIONS_TABLE}
+    WHERE name = $1
+    """
+
+    delete_ir = build_raw_sql_ir(sql=delete_sql, params=[name])
+    await db_conn.execute(delete_ir)
+
+
+def get_migration_files(migrations_dir: str = "migrations") -> list[Path]:
+    """Get list of migration files sorted by number.
+
+    Args:
+        migrations_dir: Path to migrations directory
+
+    Returns:
+        List of migration file paths
+    """
+    migrations_path = Path(migrations_dir)
+    if not migrations_path.exists():
+        return []
+
+    # Find all migration files (0001_*.py, 0002_*.py, etc.)
+    migration_files = sorted(migrations_path.glob("[0-9]*.py"))
+    return _topological_sort_migrations(migration_files)
+
+
+def get_pending_migrations(
+    migrations_dir: str = "migrations",
+    applied: list[str] | None = None,
+) -> list[Path]:
+    """Get list of pending (unapplied) migrations.
+
+    Args:
+        migrations_dir: Path to migrations directory
+        applied: List of applied migration names (if None, will query database)
+
+    Returns:
+        List of pending migration file paths
+    """
+    all_migrations = get_migration_files(migrations_dir)
+    applied_set = set(applied or [])
+
+    pending = []
+    for filepath in all_migrations:
+        # Extract migration name (0001_initial.py -> 0001_initial)
+        name = filepath.stem
+        if name not in applied_set:
+            pending.append(filepath)
+
+    return pending
+
+
+__all__ = [
+    "ensure_migrations_table",
+    "get_applied_migrations",
+    "record_migration",
+    "remove_migration",
+    "get_migration_files",
+    "get_pending_migrations",
+]