oxyde-postgres 0.1.0__py3-none-any.whl

oxyde/migrations/utils.py

@@ -0,0 +1,145 @@
+"""Shared utilities for the migration system."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+from oxyde._msgpack import msgpack
+
+
+def validate_dialect(dialect: str) -> None:
+    """Reject unsupported migration and SQL dialects."""
+    if dialect != "postgres":
+        raise ValueError("Only the postgres dialect is supported (PostgreSQL 18+).")
+
+
+def detect_dialect(url: str) -> str:
+    """Validate a PostgreSQL URL and return the PostgreSQL dialect."""
+    from oxyde.db.pool import _validate_url_scheme
+
+    _validate_url_scheme(url)
+    return "postgres"
+
+
+def load_migration_module(filepath: Path) -> Any | None:
+    """Load a migration module from file.
+
+    Args:
+        filepath: Path to migration .py file
+
+    Returns:
+        Loaded module, or None if loading failed
+    """
+    spec = importlib.util.spec_from_file_location(filepath.stem, filepath)
+    if spec is None or spec.loader is None:
+        return None
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[filepath.stem] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def parse_query_result(result_bytes: bytes) -> list[dict[str, Any]]:
+    """Parse MessagePack query result into list of dicts.
+
+    Args:
+        result_bytes: Raw MessagePack bytes from query
+
+    Returns:
+        List of row dicts with column names as keys
+    """
+    if not result_bytes:
+        return []
+
+    result = msgpack.unpackb(result_bytes, raw=False)
+
+    # Format: [columns, rows] where columns is list of names, rows is list of lists
+    if isinstance(result, list) and len(result) == 2:
+        columns, rows = result
+        if isinstance(columns, list) and isinstance(rows, list):
+            return [dict(zip(columns, row)) for row in rows]
+
+    # Fallback: already list of dicts
+    if isinstance(result, list) and all(isinstance(r, dict) for r in result):
+        return result
+
+    return []
+
+
+# ── Legacy field-format normalization ────────────────────────────────────
+
+
+def normalize_field_dict(field: dict) -> dict:
+    """Ensure a FieldDef dict carries ``column_type`` (ColumnTypeSpec).
+
+    Legacy migration files store ``python_type`` names; Rust requires
+    ``column_type``. Derivation uses the same single mapping module as live
+    models. Support for the legacy form is deprecated and will become an
+    error in 1.0 (run ``oxyde migrations squash`` to convert).
+    """
+    if "column_type" in field:
+        return field
+
+    from oxyde.core.column_types import compute_column_type, spec_from_legacy_name
+
+    db_type = field.get("db_type")
+    if not field.get("python_type") and not db_type:
+        raise ValueError(
+            f"Migration field {field.get('name', '?')!r} defines neither "
+            "'column_type' nor legacy 'python_type'/'db_type' — the column "
+            "type would silently degrade to TEXT. Use the current format "
+            "(column_type={'kind': ...}) or regenerate the migration with "
+            "'oxyde makemigrations'."
+        )
+    if db_type:
+        # An explicit db_type owns the column kind, same rule as live models
+        # (compute_column_type): a type name the mapping does not know is
+        # `unknown` — never a fallback to python_type, or legacy history and
+        # makemigrations would disagree on the same column.
+        spec = compute_column_type(None, db_type) or {"kind": "unknown"}
+    else:
+        spec = spec_from_legacy_name(
+            str(field.get("python_type", "")),
+            max_length=field.get("max_length"),
+            max_digits=field.get("max_digits"),
+            decimal_places=field.get("decimal_places"),
+        )
+    normalized = dict(field)
+    normalized["column_type"] = spec
+    return normalized
+
+
+def op_uses_legacy_fields(op: dict) -> bool:
+    """True if the operation carries any field dict in the legacy form."""
+    return any("column_type" not in f for f in _iter_field_dicts(op))
+
+
+def normalize_op_fields(op: dict) -> dict:
+    """Normalize every FieldDef dict inside a migration operation."""
+    op = dict(op)
+    table = op.get("table")
+    if isinstance(table, dict) and "fields" in table:
+        table = dict(table)
+        table["fields"] = [normalize_field_dict(f) for f in table["fields"]]
+        op["table"] = table
+    for key in ("field", "field_def", "old_field", "new_field"):
+        if isinstance(op.get(key), dict):
+            op[key] = normalize_field_dict(op[key])
+    if isinstance(op.get("table_fields"), list):
+        op["table_fields"] = [normalize_field_dict(f) for f in op["table_fields"]]
+    return op
+
+
+def _iter_field_dicts(op: dict) -> Iterator[dict]:
+    table = op.get("table")
+    if isinstance(table, dict):
+        yield from table.get("fields", [])
+    for key in ("field", "field_def", "old_field", "new_field"):
+        if isinstance(op.get(key), dict):
+            yield op[key]
+    yield from op.get("table_fields") or []

oxyde/models/__init__.py

@@ -0,0 +1,83 @@
+"""ORM model definitions and field configuration.
+
+This module provides the core model system built on Pydantic v2:
+
+Classes:
+    Model: Base class for all database models. Provides:
+        - Automatic table name generation from class name
+        - QueryManager via Model.objects for CRUD operations
+        - save(), delete(), refresh() instance methods
+        - Lifecycle hooks: pre_save, post_save, pre_delete, post_delete
+
+    Field: Enhanced field configuration function (wraps Pydantic Field):
+        - db_pk: Mark as primary key (auto-increment if int)
+        - db_index: Create single-column index
+        - db_unique: Add UNIQUE constraint
+        - db_default: Database-side DEFAULT value
+        - db_column: Override column name
+        - db_fk: Foreign key reference ("table.column")
+
+    Index: Composite index decorator for Meta.indexes.
+    Check: CHECK constraint decorator for Meta.constraints.
+
+Model Registry:
+    register_table(): Register model in global registry.
+    unregister_table(): Remove model from registry.
+    registered_tables(): Get dict of all registered models.
+    iter_tables(): Iterate over registered models.
+    clear_registry(): Remove all registered models.
+
+Example:
+    from oxyde import Model, Field, Index
+
+    @Index("name", "email", unique=True)
+    class User(Model):
+        id: int | None = Field(default=None, db_pk=True)
+        name: str = Field(db_index=True)
+        email: str = Field(db_unique=True)
+
+        class Meta:
+            is_table = True
+            table_name = "users"
+"""
+
+import warnings
+
+from .base import Model
+from .decorators import (  # Keep Index for Meta.indexes, Check for Meta.constraints
+    Check,
+    Index,
+)
+from .field import Field, OxydeFieldInfo
+from .registry import (
+    clear_registry,
+    iter_tables,
+    register_table,
+    registered_tables,
+    unregister_table,
+)
+
+
+def __getattr__(name: str) -> type:
+    if name == "OxydeModel":
+        warnings.warn(
+            "OxydeModel is deprecated, use Model instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return Model
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "Model",
+    "Field",
+    "OxydeFieldInfo",
+    "Index",
+    "Check",
+    "register_table",
+    "unregister_table",
+    "registered_tables",
+    "iter_tables",
+    "clear_registry",
+]