cinchdb 0.1.0__py3-none-any.whl

cinchdb/managers/view.py

@@ -0,0 +1,252 @@
+"""View/Model management for CinchDB."""
+
+from pathlib import Path
+from typing import List
+
+from cinchdb.models import View, Change, ChangeType
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.core.maintenance import check_maintenance_mode
+from cinchdb.managers.change_tracker import ChangeTracker
+
+
+class ViewModel:
+    """Manages SQL views (models) in the database."""
+
+    def __init__(
+        self, project_root: Path, database: str, branch: str, tenant: str = "main"
+    ):
+        """Initialize view manager.
+
+        Args:
+            project_root: Path to project root
+            database: Database name
+            branch: Branch name
+            tenant: Tenant name (default: main)
+        """
+        self.project_root = Path(project_root)
+        self.database = database
+        self.branch = branch
+        self.tenant = tenant
+        self.db_path = get_tenant_db_path(project_root, database, branch, tenant)
+        self.change_tracker = ChangeTracker(project_root, database, branch)
+
+    def list_views(self) -> List[View]:
+        """List all views in the database.
+
+        Returns:
+            List of View objects
+        """
+        views = []
+
+        with DatabaseConnection(self.db_path) as conn:
+            # Get all views
+            cursor = conn.execute(
+                """
+                SELECT name, sql FROM sqlite_master 
+                WHERE type='view' 
+                ORDER BY name
+                """
+            )
+
+            for row in cursor.fetchall():
+                view = View(
+                    name=row["name"],
+                    database=self.database,
+                    branch=self.branch,
+                    sql_statement=row["sql"],
+                )
+                views.append(view)
+
+        return views
+
+    def create_view(self, view_name: str, sql_statement: str) -> View:
+        """Create a new view.
+
+        Args:
+            view_name: Name of the view
+            sql_statement: SQL SELECT statement defining the view
+
+        Returns:
+            Created View object
+
+        Raises:
+            ValueError: If view already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Check if view already exists
+        if self._view_exists(view_name):
+            raise ValueError(f"View '{view_name}' already exists")
+
+        # Create the view
+        create_sql = f"CREATE VIEW {view_name} AS {sql_statement}"
+
+        # Track the change
+        change = Change(
+            type=ChangeType.CREATE_VIEW,
+            entity_type="view",
+            entity_name=view_name,
+            branch=self.branch,
+            details={"sql_statement": sql_statement},
+            sql=create_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+        # Return the created view
+        return View(
+            name=view_name,
+            database=self.database,
+            branch=self.branch,
+            sql_statement=sql_statement,
+        )
+
+    def update_view(self, view_name: str, sql_statement: str) -> View:
+        """Update an existing view's SQL.
+
+        Args:
+            view_name: Name of the view to update
+            sql_statement: New SQL SELECT statement
+
+        Returns:
+            Updated View object
+
+        Raises:
+            ValueError: If view doesn't exist
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Check if view exists
+        if not self._view_exists(view_name):
+            raise ValueError(f"View '{view_name}' does not exist")
+
+        # SQLite doesn't support CREATE OR REPLACE VIEW, so we need to drop and recreate
+        create_sql = f"CREATE VIEW {view_name} AS {sql_statement}"
+
+        # Track the change
+        change = Change(
+            type=ChangeType.UPDATE_VIEW,
+            entity_type="view",
+            entity_name=view_name,
+            branch=self.branch,
+            details={
+                "sql_statement": sql_statement,
+                "drop_sql": f"DROP VIEW {view_name}",
+            },
+            sql=create_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+        # Return the updated view
+        return View(
+            name=view_name,
+            database=self.database,
+            branch=self.branch,
+            sql_statement=sql_statement,
+        )
+
+    def delete_view(self, view_name: str) -> None:
+        """Delete a view.
+
+        Args:
+            view_name: Name of the view to delete
+
+        Raises:
+            ValueError: If view doesn't exist
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Check if view exists
+        if not self._view_exists(view_name):
+            raise ValueError(f"View '{view_name}' does not exist")
+
+        # Drop the view
+        drop_sql = f"DROP VIEW {view_name}"
+
+        # Track the change
+        change = Change(
+            type=ChangeType.DROP_VIEW,
+            entity_type="view",
+            entity_name=view_name,
+            branch=self.branch,
+            sql=drop_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+    def get_view(self, view_name: str) -> View:
+        """Get information about a specific view.
+
+        Args:
+            view_name: Name of the view
+
+        Returns:
+            View object
+
+        Raises:
+            ValueError: If view doesn't exist
+        """
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT sql FROM sqlite_master WHERE type='view' AND name=?",
+                (view_name,),
+            )
+            row = cursor.fetchone()
+
+            if not row:
+                raise ValueError(f"View '{view_name}' does not exist")
+
+            # Extract the SQL statement (remove CREATE VIEW ... AS prefix)
+            sql = row["sql"]
+            # Find the AS keyword and get everything after it
+            as_index = sql.upper().find(" AS ")
+            if as_index != -1:
+                sql_statement = sql[as_index + 4 :].strip()
+            else:
+                sql_statement = sql
+
+            return View(
+                name=view_name,
+                database=self.database,
+                branch=self.branch,
+                sql_statement=sql_statement,
+            )
+
+    def _view_exists(self, view_name: str) -> bool:
+        """Check if a view exists.
+
+        Args:
+            view_name: Name of the view
+
+        Returns:
+            True if view exists
+        """
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='view' AND name=?",
+                (view_name,),
+            )
+            return cursor.fetchone() is not None

cinchdb/models/__init__.py

@@ -0,0 +1,27 @@
+"""Core data models for CinchDB."""
+
+from .base import CinchDBBaseModel, CinchDBTableModel
+from .project import Project
+from .database import Database
+from .branch import Branch
+from .tenant import Tenant
+from .table import Table, Column, ColumnType, ForeignKeyRef, ForeignKeyAction
+from .view import View
+from .change import Change, ChangeType
+
+__all__ = [
+    "CinchDBBaseModel",
+    "CinchDBTableModel",
+    "Project",
+    "Database",
+    "Branch",
+    "Tenant",
+    "Table",
+    "Column",
+    "ColumnType",
+    "ForeignKeyRef",
+    "ForeignKeyAction",
+    "View",
+    "Change",
+    "ChangeType",
+]

cinchdb/models/base.py

@@ -0,0 +1,44 @@
+"""Base models for CinchDB."""
+
+from datetime import datetime, timezone
+from typing import Optional, Any
+import uuid
+from pydantic import BaseModel, Field, ConfigDict, field_serializer
+
+
+class CinchDBTableModel(BaseModel):
+    """Base model for entities that will be stored as database tables.
+
+    Includes automatic id, created_at, and updated_at fields.
+    """
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+    )
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()), description="Unique identifier"
+    )
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="Creation timestamp",
+    )
+    updated_at: Optional[datetime] = Field(
+        default=None, description="Last update timestamp"
+    )
+
+    @field_serializer("created_at", "updated_at")
+    def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]:
+        """Serialize datetime to ISO format."""
+        return dt.isoformat() if dt else None
+
+
+class CinchDBBaseModel(BaseModel):
+    """Base model for non-table entities (metadata, config, etc)."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        extra="forbid",  # Strict validation for metadata
+    )

cinchdb/models/branch.py

@@ -0,0 +1,26 @@
+"""Branch model for CinchDB."""
+
+from typing import List, Optional, Dict, Any
+from pydantic import Field
+from .base import CinchDBBaseModel
+
+
+class Branch(CinchDBBaseModel):
+    """Represents a branch within a database."""
+
+    name: str = Field(description="Branch name")
+    database: str = Field(description="Parent database name")
+    parent_branch: Optional[str] = Field(
+        default=None, description="Parent branch this was created from"
+    )
+    tenants: List[str] = Field(
+        default_factory=lambda: ["main"], description="List of tenant names"
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Branch metadata"
+    )
+    is_main: bool = Field(default=False, description="Whether this is the main branch")
+
+    def can_delete(self) -> bool:
+        """Check if this branch can be deleted."""
+        return self.name != "main" and not self.is_main

cinchdb/models/change.py

@@ -0,0 +1,47 @@
+"""Change tracking models for CinchDB."""
+
+from enum import Enum
+from typing import Dict, Any, Optional
+from pydantic import Field
+from .base import CinchDBTableModel
+
+
+class ChangeType(str, Enum):
+    """Types of schema changes."""
+
+    # Table changes
+    CREATE_TABLE = "create_table"
+    DROP_TABLE = "drop_table"
+    RENAME_TABLE = "rename_table"
+
+    # Column changes
+    ADD_COLUMN = "add_column"
+    DROP_COLUMN = "drop_column"
+    RENAME_COLUMN = "rename_column"
+    MODIFY_COLUMN = "modify_column"
+    ALTER_COLUMN_NULLABLE = "alter_column_nullable"
+
+    # View changes
+    CREATE_VIEW = "create_view"
+    DROP_VIEW = "drop_view"
+    UPDATE_VIEW = "update_view"
+
+    # Index changes
+    CREATE_INDEX = "create_index"
+    DROP_INDEX = "drop_index"
+
+
+class Change(CinchDBTableModel):
+    """Represents a schema change in the database."""
+
+    type: ChangeType = Field(description="Type of change")
+    entity_type: str = Field(description="Type of entity affected (table, view, index)")
+    entity_name: str = Field(description="Name of the affected entity")
+    details: Dict[str, Any] = Field(
+        default_factory=dict, description="Change-specific details"
+    )
+    sql: Optional[str] = Field(
+        default=None, description="SQL statement that implements the change"
+    )
+    branch: str = Field(description="Branch where change was made")
+    applied: bool = Field(default=False, description="Whether change has been applied")

cinchdb/models/database.py

@@ -0,0 +1,20 @@
+"""Database model for CinchDB."""
+
+from typing import List, Optional
+from pydantic import Field
+from .base import CinchDBBaseModel
+
+
+class Database(CinchDBBaseModel):
+    """Represents a database within a CinchDB project."""
+
+    name: str = Field(description="Database name")
+    branches: List[str] = Field(
+        default_factory=lambda: ["main"], description="List of branch names"
+    )
+    active_branch: str = Field(default="main", description="Currently active branch")
+    description: Optional[str] = Field(default=None, description="Database description")
+
+    def can_delete(self) -> bool:
+        """Check if this database can be deleted."""
+        return self.name != "main"

cinchdb/models/project.py

@@ -0,0 +1,20 @@
+"""Project model for CinchDB."""
+
+from pathlib import Path
+from typing import List, Optional
+from pydantic import Field
+from .base import CinchDBBaseModel
+
+
+class Project(CinchDBBaseModel):
+    """Represents a CinchDB project."""
+
+    name: str = Field(description="Project name")
+    path: Path = Field(description="Path to project directory")
+    databases: List[str] = Field(
+        default_factory=list, description="List of database names"
+    )
+    active_database: str = Field(
+        default="main", description="Currently active database"
+    )
+    description: Optional[str] = Field(default=None, description="Project description")

cinchdb/models/table.py

@@ -0,0 +1,86 @@
+"""Table and Column models for CinchDB."""
+
+from typing import List, Optional, Literal
+from pydantic import BaseModel, Field, ConfigDict
+from .base import CinchDBBaseModel
+
+
+# SQLite column types
+ColumnType = Literal["TEXT", "INTEGER", "REAL", "BLOB", "NUMERIC"]
+
+# Foreign key actions
+ForeignKeyAction = Literal["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"]
+
+
+class ForeignKeyRef(BaseModel):
+    """Foreign key reference specification."""
+    
+    model_config = ConfigDict(extra="forbid")
+    
+    table: str = Field(description="Referenced table name")
+    column: str = Field(default="id", description="Referenced column name")
+    on_delete: ForeignKeyAction = Field(
+        default="RESTRICT", 
+        description="Action on delete of referenced row"
+    )
+    on_update: ForeignKeyAction = Field(
+        default="RESTRICT",
+        description="Action on update of referenced row"
+    )
+
+
+class Column(BaseModel):
+    """Represents a column in a table."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = Field(description="Column name")
+    type: ColumnType = Field(description="SQLite column type")
+    nullable: bool = Field(
+        default=True, description="Whether column allows NULL values"
+    )
+    default: Optional[str] = Field(
+        default=None, description="Default value SQL expression"
+    )
+    primary_key: bool = Field(
+        default=False, description="Whether this is a primary key"
+    )
+    unique: bool = Field(default=False, description="Whether values must be unique")
+    foreign_key: Optional[ForeignKeyRef] = Field(
+        default=None, 
+        description="Foreign key constraint specification"
+    )
+
+
+class Table(CinchDBBaseModel):
+    """Represents a table in the database."""
+
+    name: str = Field(description="Table name")
+    database: str = Field(description="Database name")
+    branch: str = Field(description="Branch name")
+    columns: List[Column] = Field(default_factory=list, description="Table columns")
+
+    def __init__(self, **data):
+        """Initialize table with default columns."""
+        super().__init__(**data)
+
+        # Add default columns if not present
+        column_names = {col.name for col in self.columns}
+
+        if "id" not in column_names:
+            self.columns.insert(
+                0,
+                Column(
+                    name="id",
+                    type="TEXT",
+                    nullable=False,
+                    primary_key=True,
+                    unique=True,
+                ),
+            )
+
+        if "created_at" not in column_names:
+            self.columns.append(Column(name="created_at", type="TEXT", nullable=False))
+
+        if "updated_at" not in column_names:
+            self.columns.append(Column(name="updated_at", type="TEXT", nullable=True))

cinchdb/models/tenant.py

@@ -0,0 +1,19 @@
+"""Tenant model for CinchDB."""
+
+from typing import Optional
+from pydantic import Field
+from .base import CinchDBBaseModel
+
+
+class Tenant(CinchDBBaseModel):
+    """Represents a tenant within a branch."""
+
+    name: str = Field(description="Tenant name")
+    branch: str = Field(description="Parent branch name")
+    database: str = Field(description="Parent database name")
+    description: Optional[str] = Field(default=None, description="Tenant description")
+    is_main: bool = Field(default=False, description="Whether this is the main tenant")
+
+    def can_delete(self) -> bool:
+        """Check if this tenant can be deleted."""
+        return self.name != "main" and not self.is_main

cinchdb/models/view.py

@@ -0,0 +1,15 @@
+"""View model for CinchDB."""
+
+from typing import Optional
+from pydantic import Field
+from .base import CinchDBBaseModel
+
+
+class View(CinchDBBaseModel):
+    """Represents a SQL view in the database."""
+
+    name: str = Field(description="View name")
+    database: str = Field(description="Database name")
+    branch: str = Field(description="Branch name")
+    sql_statement: str = Field(description="SQL SELECT statement that defines the view")
+    description: Optional[str] = Field(default=None, description="View description")

cinchdb/utils/__init__.py

@@ -0,0 +1,15 @@
+"""Utility modules for CinchDB."""
+
+from cinchdb.utils.sql_validator import (
+    validate_sql_query,
+    validate_query_safe,
+    SQLValidationError,
+    SQLOperation
+)
+
+__all__ = [
+    "validate_sql_query",
+    "validate_query_safe",
+    "SQLValidationError",
+    "SQLOperation"
+]