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

cinchdb/api/routers/auth.py

@@ -1,135 +0,0 @@
-"""Authentication router for CinchDB API."""
-
-from typing import List
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-
-from cinchdb.api.auth import (
-    APIKeyManager,
-    AuthContext,
-    verify_api_key,
-    get_current_project,
-)
-from pathlib import Path
-
-
-router = APIRouter()
-
-
-class CreateAPIKeyRequest(BaseModel):
-    """Request model for creating API key."""
-
-    name: str
-    permissions: str = "read"  # "read" or "write"
-    branches: List[str] = None
-
-
-class APIKeyResponse(BaseModel):
-    """Response model for API key."""
-
-    key: str
-    name: str
-    created_at: str
-    permissions: str
-    branches: List[str] = None
-    active: bool
-
-
-@router.post("/keys", response_model=APIKeyResponse)
-async def create_api_key(
-    request: CreateAPIKeyRequest,
-    project_dir: Path = Depends(get_current_project),
-    auth: AuthContext = Depends(verify_api_key),
-):
-    """Create a new API key (requires existing API key with write permission)."""
-    # Only write permission can create new keys
-    if auth.api_key.permissions != "write":
-        raise HTTPException(
-            status_code=403, detail="Write permission required to create API keys"
-        )
-
-    manager = APIKeyManager(project_dir)
-
-    # Validate permissions
-    if request.permissions not in ["read", "write"]:
-        raise HTTPException(
-            status_code=400, detail="Invalid permissions. Must be 'read' or 'write'"
-        )
-
-    api_key = manager.create_key(
-        name=request.name, permissions=request.permissions, branches=request.branches
-    )
-
-    return APIKeyResponse(
-        key=api_key.key,
-        name=api_key.name,
-        created_at=api_key.created_at.isoformat(),
-        permissions=api_key.permissions,
-        branches=api_key.branches,
-        active=api_key.active,
-    )
-
-
-@router.get("/keys", response_model=List[APIKeyResponse])
-async def list_api_keys(
-    project_dir: Path = Depends(get_current_project),
-    auth: AuthContext = Depends(verify_api_key),
-):
-    """List all API keys (requires write permission)."""
-    # Only write permission can list keys
-    if auth.api_key.permissions != "write":
-        raise HTTPException(
-            status_code=403, detail="Write permission required to list API keys"
-        )
-
-    manager = APIKeyManager(project_dir)
-    keys = manager.list_keys()
-
-    return [
-        APIKeyResponse(
-            key=k.key,
-            name=k.name,
-            created_at=k.created_at.isoformat(),
-            permissions=k.permissions,
-            branches=k.branches,
-            active=k.active,
-        )
-        for k in keys
-    ]
-
-
-@router.delete("/keys/{key}")
-async def revoke_api_key(
-    key: str,
-    project_dir: Path = Depends(get_current_project),
-    auth: AuthContext = Depends(verify_api_key),
-):
-    """Revoke an API key (requires write permission)."""
-    # Only write permission can revoke keys
-    if auth.api_key.permissions != "write":
-        raise HTTPException(
-            status_code=403, detail="Write permission required to revoke API keys"
-        )
-
-    # Cannot revoke your own key
-    if auth.api_key.key == key:
-        raise HTTPException(status_code=400, detail="Cannot revoke your own API key")
-
-    manager = APIKeyManager(project_dir)
-    if not manager.revoke_key(key):
-        raise HTTPException(status_code=404, detail="API key not found")
-
-    return {"message": "API key revoked"}
-
-
-@router.get("/me")
-async def get_current_key_info(auth: AuthContext = Depends(verify_api_key)):
-    """Get information about the current API key."""
-    return APIKeyResponse(
-        key=auth.api_key.key,
-        name=auth.api_key.name,
-        created_at=auth.api_key.created_at.isoformat(),
-        permissions=auth.api_key.permissions,
-        branches=auth.api_key.branches,
-        active=auth.api_key.active,
-    )

cinchdb/api/routers/branches.py

@@ -1,368 +0,0 @@
-"""Branches router for CinchDB API."""
-
-from typing import List, Optional, Dict, Any
-from fastapi import APIRouter, Depends, HTTPException, Query
-from pydantic import BaseModel
-from datetime import datetime
-
-from cinchdb.config import Config
-from cinchdb.core.database import CinchDB
-from cinchdb.managers.merge_manager import MergeError
-from cinchdb.managers.change_comparator import ChangeComparator
-from cinchdb.models import Change
-from cinchdb.api.auth import (
-    AuthContext,
-    require_write_permission,
-    require_read_permission,
-)
-
-
-router = APIRouter()
-
-
-class BranchInfo(BaseModel):
-    """Branch information."""
-
-    name: str
-    parent: Optional[str]
-    created_at: datetime
-    is_active: bool
-    tenant_count: int
-
-
-class CreateBranchRequest(BaseModel):
-    """Request to create a branch."""
-
-    name: str
-    source: str = "main"
-
-
-class MergeBranchRequest(BaseModel):
-    """Request to merge branches."""
-
-    source: str
-    target: str
-    force: bool = False
-
-
-class BranchComparisonResult(BaseModel):
-    """Result of branch comparison."""
-
-    source_branch: str
-    target_branch: str
-    source_only_changes: int
-    target_only_changes: int
-    common_ancestor: Optional[str]
-    can_fast_forward: bool
-
-
-class MergeCheckResult(BaseModel):
-    """Result of merge feasibility check."""
-
-    can_merge: bool
-    reason: Optional[str] = None
-    merge_type: Optional[str] = None
-    changes_to_merge: Optional[int] = None
-    target_changes: Optional[int] = None
-    conflicts: Optional[List[Dict[str, Any]]] = None
-
-
-@router.get("/", response_model=List[BranchInfo])
-async def list_branches(
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """List all branches in a database."""
-    config = Config(auth.project_dir)
-    config_data = config.load()
-
-    db_name = database
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-        branches = db.branches.list_branches()
-
-        result = []
-        for branch in branches:
-            # Count tenants
-            tenants_dir = (
-                auth.project_dir
-                / ".cinchdb"
-                / "databases"
-                / db_name
-                / "branches"
-                / branch.name
-                / "tenants"
-            )
-            tenant_count = (
-                len(list(tenants_dir.glob("*.db"))) if tenants_dir.exists() else 0
-            )
-
-            result.append(
-                BranchInfo(
-                    name=branch.name,
-                    parent=branch.parent_branch,
-                    created_at=branch.metadata.get("created_at", "Unknown"),
-                    is_active=branch.name == config_data.active_branch
-                    and db_name == config_data.active_database,
-                    tenant_count=tenant_count,
-                )
-            )
-
-        return result
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.post("/")
-async def create_branch(
-    request: CreateBranchRequest,
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Create a new branch."""
-    db_name = database
-
-    # Check branch permissions
-    if auth.api_key.branches and request.source not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403,
-            detail=f"Access denied for source branch '{request.source}'",
-        )
-
-    if auth.api_key.branches and request.name not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403,
-            detail=f"Cannot create branch '{request.name}' - not in allowed branches",
-        )
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-        branch = db.branches.create_branch(request.name, request.source)
-
-        return {
-            "message": f"Created branch '{request.name}' from '{request.source}'",
-            "branch": {
-                "name": branch.name,
-                "parent": branch.parent_branch,
-                "created_at": branch.metadata.get("created_at","Unknown"),
-            },
-        }
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.delete("/{name}")
-async def delete_branch(
-    name: str,
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Delete a branch."""
-    if name == "main":
-        raise HTTPException(status_code=400, detail="Cannot delete the main branch")
-
-    config = Config(auth.project_dir)
-    config_data = config.load()
-
-    db_name = database
-
-    # Check branch permissions
-    if auth.api_key.branches and name not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{name}'"
-        )
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-        db.branches.delete_branch(name)
-
-        # If this was the active branch, switch to main
-        if config_data.active_branch == name and config_data.active_database == db_name:
-            config_data.active_branch = "main"
-            config.save(config_data)
-
-        return {"message": f"Deleted branch '{name}'"}
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-
-@router.get("/{source}/compare/{target}", response_model=BranchComparisonResult)
-async def compare_branches(
-    source: str,
-    target: str,
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """Compare two branches to see their differences."""
-    db_name = database
-
-    # Check branch permissions
-    await require_read_permission(auth, source)
-    await require_read_permission(auth, target)
-
-    try:
-        comparator = ChangeComparator(auth.project_dir, db_name)
-
-        # Get divergent changes
-        source_only, target_only = comparator.get_divergent_changes(source, target)
-
-        # Find common ancestor
-        common_ancestor = comparator.find_common_ancestor(source, target)
-
-        # Check if fast-forward merge is possible
-        can_fast_forward = comparator.can_fast_forward_merge(source, target)
-
-        return BranchComparisonResult(
-            source_branch=source,
-            target_branch=target,
-            source_only_changes=len(source_only),
-            target_only_changes=len(target_only),
-            common_ancestor=common_ancestor,
-            can_fast_forward=can_fast_forward,
-        )
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.get("/{source}/can-merge/{target}", response_model=MergeCheckResult)
-async def check_merge_feasibility(
-    source: str,
-    target: str,
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """Check if source branch can be merged into target branch."""
-    db_name = database
-
-    # Check branch permissions
-    await require_read_permission(auth, source)
-    await require_read_permission(auth, target)
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-        result = db.merge.can_merge(source, target)
-
-        return MergeCheckResult(**result)
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.post("/{source}/merge/{target}")
-async def merge_branches(
-    source: str,
-    target: str,
-    database: str = Query(..., description="Database name"),
-    force: bool = Query(False, description="Force merge even with conflicts"),
-    dry_run: bool = Query(False, description="Preview merge without executing"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Merge source branch into target branch."""
-    db_name = database
-
-    # Check branch permissions for both branches
-    await require_write_permission(auth, source)
-    await require_write_permission(auth, target)
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-
-        if target == "main":
-            # Use the merge_into_main method for main branch protection
-            result = db.merge.merge_into_main(source, force=force, dry_run=dry_run)
-        else:
-            # Use internal merge method for non-main branches
-            result = db.merge._merge_branches_internal(
-                source, target, force=force, dry_run=dry_run
-            )
-
-        return result
-
-    except MergeError as e:
-        raise HTTPException(status_code=409, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.post("/{source}/merge-into-main")
-async def merge_into_main_branch(
-    source: str,
-    database: str = Query(..., description="Database name"),
-    force: bool = Query(False, description="Force merge even with conflicts"),
-    dry_run: bool = Query(False, description="Preview merge without executing"),
-    auth: AuthContext = Depends(require_write_permission),
-):
-    """Merge source branch into the main branch with additional protections."""
-    db_name = database
-
-    # Check branch permissions
-    await require_write_permission(auth, source)
-    await require_write_permission(auth, "main")
-
-    try:
-        db = CinchDB(
-            database=db_name, branch="main", tenant="main", project_dir=auth.project_dir
-        )
-        result = db.merge.merge_into_main(source, force=force, dry_run=dry_run)
-
-        return result
-
-    except MergeError as e:
-        raise HTTPException(status_code=409, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-
-@router.get("/{branch}/changes", response_model=Dict[str, Any])
-async def list_branch_changes(
-    branch: str,
-    database: str = Query(..., description="Database name"),
-    auth: AuthContext = Depends(require_read_permission),
-):
-    """List all changes in a branch."""
-    db_name = database
-
-    # Check branch permissions
-    if auth.api_key.branches and branch not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{branch}'"
-        )
-
-    try:
-        from cinchdb.managers.change_tracker import ChangeTracker
-        
-        tracker = ChangeTracker(auth.project_dir, db_name, branch)
-        changes = tracker.get_changes()
-        
-        # Convert Change objects to dicts for JSON serialization
-        changes_data = []
-        for change in changes:
-            change_dict = change.model_dump()
-            # Convert datetime to string for JSON serialization
-            if change_dict.get("created_at") and hasattr(change_dict["created_at"], "isoformat"):
-                change_dict["created_at"] = change_dict["created_at"].isoformat()
-            if change_dict.get("updated_at") and hasattr(change_dict.get("updated_at"), "isoformat"):
-                change_dict["updated_at"] = change_dict["updated_at"].isoformat()
-            changes_data.append(change_dict)
-        
-        return {"changes": changes_data}
-
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))

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))