cinchdb 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

cinchdb/api/routers/codegen.py

@@ -1,164 +0,0 @@
-"""Code generation router for CinchDB API."""
-
-import tempfile
-from typing import List, Dict
-from pathlib import Path
-from fastapi import APIRouter, Depends, HTTPException, Query
-from pydantic import BaseModel
-
-from cinchdb.core.database import CinchDB
-from cinchdb.api.auth import AuthContext, require_read_permission
-
-
-router = APIRouter()
-
-
-class CodegenLanguage(BaseModel):
-    """Supported language for code generation."""
-
-    name: str
-    description: str
-
-
-class GenerateModelsRequest(BaseModel):
-    """Request to generate models."""
-
-    language: str
-    include_tables: bool = True
-    include_views: bool = True
-
-
-@router.get("/languages", response_model=List[CodegenLanguage])
-async def list_supported_languages():
-    """List supported code generation languages."""
-    # Using a temporary CinchDB to get supported languages
-    # This doesn't require specific database/branch so we use dummy values
-    temp_project = Path(tempfile.mkdtemp())
-    try:
-        db = CinchDB(
-            database="dummy", branch="dummy", tenant="dummy", project_dir=temp_project
-        )
-        languages = db.codegen.get_supported_languages()
-
-        # Map languages to descriptions
-        language_info = {
-            "python": "Python Pydantic models with full CRUD operations",
-            "typescript": "TypeScript interfaces and classes (planned)",
-        }
-
-        return [
-            CodegenLanguage(
-                name=lang, description=language_info.get(lang, f"{lang.title()} models")
-            )
-            for lang in languages
-        ]
-    finally:
-        # Clean up temp directory
-        import shutil
-
-        shutil.rmtree(temp_project, ignore_errors=True)
-
-
-@router.post("/generate/files", response_model=Dict[str, str])
-async def generate_model_files_content(
-    request: GenerateModelsRequest,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """Generate model files and return their content as JSON (alternative to ZIP download)."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_read_permission(auth, branch_name)
-
-    try:
-        # Create temporary directory for generation
-        temp_dir = Path(tempfile.mkdtemp())
-        output_dir = temp_dir / "generated_models"
-
-        # Initialize CinchDB and get codegen manager
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        codegen_mgr = db.codegen
-
-        # Generate models
-        results = codegen_mgr.generate_models(
-            language=request.language,
-            output_dir=output_dir,
-            include_tables=request.include_tables,
-            include_views=request.include_views,
-        )
-
-        # Read generated files and return their content
-        file_contents = {}
-
-        for file_name in results["files_generated"]:
-            file_path = output_dir / file_name
-            if file_path.exists():
-                with open(file_path, "r", encoding="utf-8") as f:
-                    file_contents[file_name] = f.read()
-
-        # Clean up temp directory
-        import shutil
-
-        shutil.rmtree(temp_dir, ignore_errors=True)
-
-        return file_contents
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Code generation failed: {str(e)}")
-
-
-@router.get("/info")
-async def get_codegen_info(
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """Get information about what can be generated for the current database/branch."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_read_permission(auth, branch_name)
-
-    try:
-        # Initialize CinchDB and get codegen manager
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        codegen_mgr = db.codegen
-
-        # Get available tables and views using CinchDB
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        tables = db.tables.list_tables()
-        views = db.views.list_views()
-
-        return {
-            "database": db_name,
-            "branch": branch_name,
-            "tenant": "main",
-            "supported_languages": codegen_mgr.get_supported_languages(),
-            "available_tables": [table.name for table in tables],
-            "available_views": [view.name for view in views],
-            "total_entities": len(tables) + len(views),
-        }
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))

cinchdb/api/routers/columns.py

@@ -1,290 +0,0 @@
-"""Columns router for CinchDB API."""
-
-from typing import List, Optional, Any
-from fastapi import APIRouter, Depends, HTTPException, Query
-from pydantic import BaseModel
-
-from cinchdb.core.database import CinchDB
-from cinchdb.managers.change_applier import ChangeApplier
-from cinchdb.models import Column
-from cinchdb.api.auth import (
-    AuthContext,
-    require_write_permission,
-    require_read_permission,
-)
-
-
-router = APIRouter()
-
-
-class ColumnInfo(BaseModel):
-    """Column information."""
-
-    name: str
-    type: str
-    nullable: bool
-    default: Optional[str]
-    primary_key: bool
-    unique: bool
-
-
-class AddColumnRequest(BaseModel):
-    """Request to add a column."""
-
-    name: str
-    type: str
-    nullable: bool = True
-    default: Optional[str] = None
-
-
-class RenameColumnRequest(BaseModel):
-    """Request to rename a column."""
-
-    old_name: str
-    new_name: str
-
-
-class AlterNullableRequest(BaseModel):
-    """Request to alter column nullable constraint."""
-
-    nullable: bool
-    fill_value: Optional[Any] = None
-
-
-@router.get("/{table}/columns", response_model=List[ColumnInfo])
-async def list_columns(
-    table: str,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """List all columns in a table."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_read_permission(auth, branch_name)
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        columns = db.columns.list_columns(table)
-
-        result = []
-        for col in columns:
-            result.append(
-                ColumnInfo(
-                    name=col.name,
-                    type=col.type,
-                    nullable=col.nullable,
-                    default=col.default,
-                    primary_key=col.primary_key,
-                    unique=col.unique,
-                )
-            )
-
-        return result
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.post("/{table}/columns")
-async def add_column(
-    table: str,
-    request: AddColumnRequest,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    apply: bool = Query(True, description="Apply changes to all tenants"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Add a new column to a table."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_write_permission(auth, branch_name)
-
-    # Validate type
-    if request.type.upper() not in ["TEXT", "INTEGER", "REAL", "BLOB", "NUMERIC"]:
-        raise HTTPException(
-            status_code=400, detail=f"Invalid column type: {request.type}"
-        )
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        column = Column(
-            name=request.name,
-            type=request.type.upper(),
-            nullable=request.nullable,
-            default=request.default,
-        )
-        db.columns.add_column(table, column)
-
-        # Apply to all tenants if requested
-        if apply:
-            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
-            applier.apply_all_unapplied()
-
-        return {"message": f"Added column '{request.name}' to table '{table}'"}
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.delete("/{table}/columns/{column}")
-async def drop_column(
-    table: str,
-    column: str,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    apply: bool = Query(True, description="Apply changes to all tenants"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Drop a column from a table."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_write_permission(auth, branch_name)
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        db.columns.drop_column(table, column)
-
-        # Apply to all tenants if requested
-        if apply:
-            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
-            applier.apply_all_unapplied()
-
-        return {"message": f"Dropped column '{column}' from table '{table}'"}
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.put("/{table}/columns/rename")
-async def rename_column(
-    table: str,
-    request: RenameColumnRequest,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    apply: bool = Query(True, description="Apply changes to all tenants"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Rename a column in a table."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_write_permission(auth, branch_name)
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        db.columns.rename_column(table, request.old_name, request.new_name)
-
-        # Apply to all tenants if requested
-        if apply:
-            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
-            applier.apply_all_unapplied()
-
-        return {
-            "message": f"Renamed column '{request.old_name}' to '{request.new_name}' in table '{table}'"
-        }
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.get("/{table}/columns/{column}")
-async def get_column_info(
-    table: str,
-    column: str,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    auth: AuthContext = Depends(require_read_permission),
-) -> ColumnInfo:
-    """Get information about a specific column."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_read_permission(auth, branch_name)
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        col = db.columns.get_column_info(table, column)
-
-        return ColumnInfo(
-            name=col.name,
-            type=col.type,
-            nullable=col.nullable,
-            default=col.default,
-            primary_key=col.primary_key,
-            unique=col.unique,
-        )
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.put("/{table}/columns/{column}/nullable")
-async def alter_column_nullable(
-    table: str,
-    column: str,
-    request: AlterNullableRequest,
-    database: str = Query(..., description="Database name"),
-    branch: str = Query(..., description="Branch name"),
-    apply: bool = Query(True, description="Apply changes to all tenants"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Change the nullable constraint on a column."""
-    db_name = database
-    branch_name = branch
-
-    # Check branch permissions
-    await require_write_permission(auth, branch_name)
-
-    try:
-        db = CinchDB(
-            database=db_name,
-            branch=branch_name,
-            tenant="main",
-            project_dir=auth.project_dir,
-        )
-        db.columns.alter_column_nullable(table, column, request.nullable, request.fill_value)
-
-        # Apply to all tenants if requested
-        if apply:
-            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
-            applier.apply_all_unapplied()
-
-        action = "nullable" if request.nullable else "NOT NULL"
-        return {"message": f"Made column '{column}' {action} in table '{table}'"}
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))