fraiseql-confiture 0.1.0__cp311-cp311-manylinux_2_34_x86_64.whl

confiture/config/environment.py

@@ -0,0 +1,190 @@
+"""Environment configuration management
+
+Handles loading and validation of environment-specific configuration from YAML files.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+from confiture.exceptions import ConfigurationError
+
+
+class DatabaseConfig(BaseModel):
+    """Database connection configuration.
+
+    Can be initialized from a connection URL or individual parameters.
+    """
+
+    host: str = "localhost"
+    port: int = 5432
+    database: str = "postgres"
+    user: str = "postgres"
+    password: str = ""
+
+    @classmethod
+    def from_url(cls, url: str) -> "DatabaseConfig":
+        """Parse database configuration from PostgreSQL URL.
+
+        Args:
+            url: PostgreSQL connection URL (postgresql://user:pass@host:port/dbname)
+
+        Returns:
+            DatabaseConfig instance
+
+        Example:
+            >>> config = DatabaseConfig.from_url("postgresql://user:pass@localhost:5432/mydb")
+            >>> config.host
+            'localhost'
+        """
+        import re
+
+        # Parse URL: postgresql://user:pass@host:port/dbname
+        pattern = r"(?:postgresql|postgres)://(?:([^:]+):([^@]+)@)?([^:/]+)(?::(\d+))?/(.+)"
+        match = re.match(pattern, url)
+
+        if not match:
+            raise ValueError(f"Invalid PostgreSQL URL: {url}")
+
+        user, password, host, port, database = match.groups()
+
+        return cls(
+            host=host or "localhost",
+            port=int(port) if port else 5432,
+            database=database,
+            user=user or "postgres",
+            password=password or "",
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for use with create_connection."""
+        return {
+            "database": {
+                "host": self.host,
+                "port": self.port,
+                "database": self.database,
+                "user": self.user,
+                "password": self.password,
+            }
+        }
+
+
+class Environment(BaseModel):
+    """Environment configuration
+
+    Loaded from db/environments/{env_name}.yaml files.
+
+    Attributes:
+        name: Environment name (e.g., "local", "production")
+        database_url: PostgreSQL connection URL
+        include_dirs: Directories to include when building schema
+        exclude_dirs: Directories to exclude from schema build
+        migration_table: Table name for tracking migrations
+        auto_backup: Whether to automatically backup before migrations
+        require_confirmation: Whether to require user confirmation for risky operations
+    """
+
+    name: str
+    database_url: str
+    include_dirs: list[str]
+    exclude_dirs: list[str] = Field(default_factory=list)
+    migration_table: str = "confiture_migrations"
+    auto_backup: bool = True
+    require_confirmation: bool = True
+
+    @property
+    def database(self) -> DatabaseConfig:
+        """Get database configuration from database_url.
+
+        Returns:
+            DatabaseConfig instance
+        """
+        return DatabaseConfig.from_url(self.database_url)
+
+    @field_validator("database_url")
+    @classmethod
+    def validate_database_url(cls, v: str) -> str:
+        """Validate PostgreSQL connection URL format"""
+        if not v.startswith(("postgresql://", "postgres://")):
+            raise ValueError(
+                f"Invalid database_url: must start with postgresql:// or postgres://, got: {v}"
+            )
+        return v
+
+    @classmethod
+    def load(cls, env_name: str, project_dir: Path | None = None) -> "Environment":
+        """Load environment configuration from YAML file
+
+        Args:
+            env_name: Environment name (e.g., "local", "production")
+            project_dir: Project root directory. If None, uses current directory.
+
+        Returns:
+            Environment configuration object
+
+        Raises:
+            ConfigurationError: If config file not found, invalid, or missing required fields
+
+        Example:
+            >>> env = Environment.load("local")
+            >>> print(env.database_url)
+            postgresql://localhost/myapp_local
+        """
+        if project_dir is None:
+            project_dir = Path.cwd()
+
+        # Find config file
+        config_path = project_dir / "db" / "environments" / f"{env_name}.yaml"
+
+        if not config_path.exists():
+            raise ConfigurationError(
+                f"Environment config not found: {config_path}\n"
+                f"Expected: db/environments/{env_name}.yaml"
+            )
+
+        # Load YAML
+        try:
+            with open(config_path) as f:
+                data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ConfigurationError(f"Invalid YAML in {config_path}: {e}") from e
+
+        if not isinstance(data, dict):
+            raise ConfigurationError(
+                f"Invalid config format in {config_path}: expected dictionary, got {type(data)}"
+            )
+
+        # Validate required fields
+        if "database_url" not in data:
+            raise ConfigurationError(f"Missing required field 'database_url' in {config_path}")
+
+        if "include_dirs" not in data:
+            raise ConfigurationError(f"Missing required field 'include_dirs' in {config_path}")
+
+        # Resolve paths to absolute
+        include_dirs = []
+        for dir_path in data["include_dirs"]:
+            abs_path = (project_dir / dir_path).resolve()
+            if not abs_path.exists():
+                raise ConfigurationError(
+                    f"Include directory does not exist: {abs_path}\nSpecified in {config_path}"
+                )
+            include_dirs.append(str(abs_path))
+
+        data["include_dirs"] = include_dirs
+
+        # Resolve exclude_dirs if present
+        if "exclude_dirs" in data:
+            exclude_dirs = []
+            for dir_path in data["exclude_dirs"]:
+                abs_path = (project_dir / dir_path).resolve()
+                exclude_dirs.append(str(abs_path))
+            data["exclude_dirs"] = exclude_dirs
+
+        # Create Environment instance
+        try:
+            return cls(**data)
+        except Exception as e:
+            raise ConfigurationError(f"Invalid configuration in {config_path}: {e}") from e

confiture/core/builder.py

@@ -0,0 +1,336 @@
+"""Schema builder - builds PostgreSQL schemas from DDL files
+
+The SchemaBuilder concatenates SQL files from db/schema/ in deterministic order
+to create a complete schema file. This implements "Medium 1: Build from Source DDL".
+
+Performance: Uses Rust extension (_core) when available for 10-50x speedup.
+"""
+
+import hashlib
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from confiture.config.environment import Environment
+from confiture.exceptions import SchemaError
+
+# Try to import Rust extension for 10-50x performance boost
+_core: Any = None
+HAS_RUST = False
+
+if not TYPE_CHECKING:
+    try:
+        from confiture import _core  # type: ignore
+
+        HAS_RUST = True
+    except ImportError:
+        pass
+
+
+class SchemaBuilder:
+    """Build PostgreSQL schema from DDL source files
+
+    The SchemaBuilder discovers SQL files in the schema directory, concatenates
+    them in deterministic order, and generates a complete schema file.
+
+    Attributes:
+        env_config: Environment configuration
+        schema_dir: Base directory for schema files
+
+    Example:
+        >>> builder = SchemaBuilder(env="local")
+        >>> schema = builder.build()
+        >>> print(len(schema))
+        15234
+    """
+
+    def __init__(self, env: str, project_dir: Path | None = None):
+        """Initialize SchemaBuilder
+
+        Args:
+            env: Environment name (e.g., "local", "production")
+            project_dir: Project root directory. If None, uses current directory.
+        """
+        self.env_config = Environment.load(env, project_dir=project_dir)
+
+        # Validate include_dirs
+        if not self.env_config.include_dirs:
+            raise SchemaError("No include_dirs specified in environment config")
+
+        # Store include dirs for file discovery
+        self.include_dirs = [Path(d) for d in self.env_config.include_dirs]
+
+        # Base directory for relative path calculation
+        # Find the common parent of all include directories
+        self.base_dir = self._find_common_parent(self.include_dirs)
+
+    def _find_common_parent(self, paths: list[Path]) -> Path:
+        """Find common parent directory of all paths.
+
+        Args:
+            paths: List of paths to find common parent
+
+        Returns:
+            Common parent directory
+
+        Example:
+            >>> paths = [Path("db/schema/00_common"), Path("db/seeds/common")]
+            >>> _find_common_parent(paths)
+            Path("db")
+        """
+        if len(paths) == 1:
+            return paths[0]
+
+        # Convert to absolute paths for comparison
+        abs_paths = [p.resolve() for p in paths]
+
+        # Get all parent parts for each path (including the path itself)
+        all_parts = [p.parts for p in abs_paths]
+
+        # Find common prefix
+        common_parts = []
+        for parts_at_level in zip(*all_parts, strict=False):
+            if len(set(parts_at_level)) == 1:
+                common_parts.append(parts_at_level[0])
+            else:
+                break
+
+        if not common_parts:
+            # No common parent, use current directory
+            return Path(".")
+
+        # Reconstruct path from common parts
+        return Path(*common_parts)
+
+    def find_sql_files(self) -> list[Path]:
+        """Discover SQL files in all include directories
+
+        Files are returned in deterministic alphabetical order. Use numbered
+        directories (00_common/, 10_tables/, 20_views/) to control ordering.
+
+        Returns:
+            Sorted list of SQL file paths
+
+        Raises:
+            SchemaError: If include directories don't exist or no SQL files found
+
+        Example:
+            >>> builder = SchemaBuilder(env="local")
+            >>> files = builder.find_sql_files()
+            >>> print(files[0])
+            /path/to/db/schema/00_common/extensions.sql
+        """
+        all_sql_files = []
+
+        # Collect SQL files from all include directories
+        for include_dir in self.include_dirs:
+            if not include_dir.exists():
+                raise SchemaError(f"Include directory does not exist: {include_dir}")
+
+            # Find all SQL files recursively in this directory
+            sql_files = list(include_dir.rglob("*.sql"))
+            all_sql_files.extend(sql_files)
+
+        # Filter out excluded directories
+        filtered_files = []
+        exclude_paths = [Path(d) for d in self.env_config.exclude_dirs]
+
+        for file in all_sql_files:
+            # Check if file is in any excluded directory
+            is_excluded = any(file.is_relative_to(exclude_dir) for exclude_dir in exclude_paths)
+            if not is_excluded:
+                filtered_files.append(file)
+
+        if not filtered_files:
+            include_dirs_str = ", ".join(str(d) for d in self.include_dirs)
+            raise SchemaError(
+                f"No SQL files found in include directories: {include_dirs_str}\n"
+                f"Expected files in subdirectories like 00_common/, 10_tables/, etc."
+            )
+
+        # Sort alphabetically for deterministic order
+        return sorted(filtered_files)
+
+    def build(self, output_path: Path | None = None) -> str:
+        """Build schema by concatenating DDL files
+
+        Generates a complete schema file by concatenating all SQL files in
+        deterministic order, with headers and file separators.
+
+        Performance: Uses Rust extension when available for 10-50x speedup.
+        Falls back gracefully to Python implementation if Rust unavailable.
+
+        Args:
+            output_path: Optional path to write schema file. If None, only returns content.
+
+        Returns:
+            Generated schema content as string
+
+        Raises:
+            SchemaError: If schema build fails
+
+        Example:
+            >>> builder = SchemaBuilder(env="local")
+            >>> schema = builder.build(output_path=Path("schema.sql"))
+            >>> print(f"Generated {len(schema)} bytes")
+        """
+        files = self.find_sql_files()
+
+        # Generate header
+        header = self._generate_header(len(files))
+
+        # Use Rust extension if available (10-50x faster)
+        if HAS_RUST:
+            try:
+                # Build file content using Rust
+                file_paths = [str(f) for f in files]
+                content: str = _core.build_schema(file_paths)
+
+                # Add headers and separators (Python side for flexibility)
+                schema = self._add_headers_and_separators(header, files, content)
+            except Exception:
+                # Fallback to Python if Rust fails
+                schema = self._build_python(header, files)
+        else:
+            # Pure Python implementation (fallback)
+            schema = self._build_python(header, files)
+
+        # Write to file if requested
+        if output_path:
+            try:
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                output_path.write_text(schema, encoding="utf-8")
+            except Exception as e:
+                raise SchemaError(f"Error writing schema to {output_path}: {e}") from e
+
+        return schema
+
+    def _build_python(self, header: str, files: list[Path]) -> str:
+        """Pure Python implementation of schema building (fallback)
+
+        Args:
+            header: Schema header
+            files: List of SQL files to concatenate
+
+        Returns:
+            Complete schema content
+        """
+        parts = [header]
+
+        # Concatenate all files
+        for file in files:
+            try:
+                # Relative path for header
+                rel_path = file.relative_to(self.base_dir)
+
+                # Add file separator
+                parts.append("\n-- ============================================\n")
+                parts.append(f"-- File: {rel_path}\n")
+                parts.append("-- ============================================\n\n")
+
+                # Add file content
+                content = file.read_text(encoding="utf-8")
+                parts.append(content)
+
+                # Ensure newline at end
+                if not content.endswith("\n"):
+                    parts.append("\n")
+
+            except Exception as e:
+                raise SchemaError(f"Error reading {file}: {e}") from e
+
+        return "".join(parts)
+
+    def _add_headers_and_separators(self, header: str, _files: list[Path], content: str) -> str:
+        """Add main header to Rust-built content
+
+        The Rust layer now includes file separators, so this function
+        only needs to prepend the main schema header.
+
+        Args:
+            header: Schema header
+            _files: List of SQL files (unused, kept for API compatibility)
+            content: Concatenated content from Rust (includes file separators)
+
+        Returns:
+            Content with main header
+        """
+        # Rust layer now includes file separators, just prepend main header
+        return header + content
+
+    def compute_hash(self) -> str:
+        """Compute deterministic SHA256 hash of schema
+
+        The hash includes both file paths and content, ensuring that any change
+        to the schema (content or structure) is detected.
+
+        Performance: Uses Rust extension when available for 30-60x speedup.
+
+        Returns:
+            SHA256 hexadecimal digest
+
+        Example:
+            >>> builder = SchemaBuilder(env="local")
+            >>> hash1 = builder.compute_hash()
+            >>> # Modify a file...
+            >>> hash2 = builder.compute_hash()
+            >>> assert hash1 != hash2  # Change detected
+        """
+        files = self.find_sql_files()
+
+        # Use Rust extension if available (30-60x faster)
+        if HAS_RUST:
+            try:
+                file_paths = [str(f) for f in files]
+                hash_result: str = _core.hash_files(file_paths)
+                return hash_result
+            except Exception:
+                # Fallback to Python if Rust fails
+                pass
+
+        # Pure Python implementation (fallback)
+        hasher = hashlib.sha256()
+
+        for file in files:
+            # Include relative path in hash (detects file renames)
+            rel_path = file.relative_to(self.base_dir)
+            hasher.update(str(rel_path).encode("utf-8"))
+            hasher.update(b"\x00")  # Separator
+
+            # Include file content
+            try:
+                content = file.read_bytes()
+                hasher.update(content)
+                hasher.update(b"\x00")  # Separator
+            except Exception as e:
+                raise SchemaError(f"Error reading {file} for hash: {e}") from e
+
+        return hasher.hexdigest()
+
+    def _generate_header(self, file_count: int) -> str:
+        """Generate schema file header
+
+        Args:
+            file_count: Number of SQL files included
+
+        Returns:
+            Header string
+        """
+        timestamp = datetime.now().isoformat()
+        schema_hash = self.compute_hash()
+
+        return f"""-- ============================================
+-- PostgreSQL Schema for Confiture
+-- ============================================
+--
+-- Environment: {self.env_config.name}
+-- Generated: {timestamp}
+-- Schema Hash: {schema_hash}
+-- Files Included: {file_count}
+--
+-- This file was generated by Confiture (confiture build)
+-- DO NOT EDIT MANUALLY - Edit source files in db/schema/
+--
+-- ============================================
+
+"""

confiture/core/connection.py

@@ -0,0 +1,120 @@
+"""Database connection management for CLI commands."""
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import psycopg
+import yaml
+
+from confiture.exceptions import MigrationError
+
+
+def load_config(config_file: Path) -> dict[str, Any]:
+    """Load configuration from YAML file.
+
+    Args:
+        config_file: Path to configuration file
+
+    Returns:
+        Configuration dictionary
+
+    Raises:
+        MigrationError: If config file is invalid
+    """
+    if not config_file.exists():
+        raise MigrationError(f"Configuration file not found: {config_file}")
+
+    try:
+        with open(config_file) as f:
+            config: dict[str, Any] = yaml.safe_load(f)
+        return config
+    except yaml.YAMLError as e:
+        raise MigrationError(f"Invalid YAML configuration: {e}") from e
+
+
+def create_connection(config: dict[str, Any] | Any) -> psycopg.Connection:
+    """Create database connection from configuration.
+
+    Args:
+        config: Configuration dictionary with 'database' section or DatabaseConfig instance
+
+    Returns:
+        PostgreSQL connection
+
+    Raises:
+        MigrationError: If connection fails
+    """
+    from confiture.config.environment import DatabaseConfig
+
+    # Handle DatabaseConfig instance
+    if isinstance(config, DatabaseConfig):
+        config_dict = config.to_dict()
+        db_config = config_dict.get("database", {})
+    else:
+        db_config = config.get("database", {})
+
+    try:
+        conn = psycopg.connect(
+            host=db_config.get("host", "localhost"),
+            port=db_config.get("port", 5432),
+            dbname=db_config.get("database", "postgres"),
+            user=db_config.get("user", "postgres"),
+            password=db_config.get("password", ""),
+        )
+        return conn
+    except psycopg.Error as e:
+        raise MigrationError(f"Failed to connect to database: {e}") from e
+
+
+def load_migration_module(migration_file: Path) -> ModuleType:
+    """Dynamically load a migration Python module.
+
+    Args:
+        migration_file: Path to migration .py file
+
+    Returns:
+        Loaded module
+
+    Raises:
+        MigrationError: If module cannot be loaded
+    """
+    try:
+        # Create module spec
+        spec = importlib.util.spec_from_file_location(migration_file.stem, migration_file)
+        if spec is None or spec.loader is None:
+            raise MigrationError(f"Cannot load migration: {migration_file}")
+
+        # Load module
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[migration_file.stem] = module
+        spec.loader.exec_module(module)
+
+        return module
+    except Exception as e:
+        raise MigrationError(f"Failed to load migration {migration_file}: {e}") from e
+
+
+def get_migration_class(module: ModuleType) -> type:
+    """Extract Migration subclass from loaded module.
+
+    Args:
+        module: Loaded Python module
+
+    Returns:
+        Migration class
+
+    Raises:
+        MigrationError: If no Migration class found
+    """
+    from confiture.models.migration import Migration
+
+    # Find Migration subclass in module
+    for attr_name in dir(module):
+        attr = getattr(module, attr_name)
+        if isinstance(attr, type) and issubclass(attr, Migration) and attr is not Migration:
+            return attr
+
+    raise MigrationError(f"No Migration subclass found in {module}")