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

cinchdb/api/main.py

@@ -1,137 +0,0 @@
-"""Main entry point for CinchDB API server."""
-
-import uvicorn
-from pathlib import Path
-from typing import Optional
-
-import typer
-from rich.console import Console
-
-from cinchdb.api.auth import APIKeyManager
-from cinchdb.core.path_utils import get_project_root
-
-
-cli = typer.Typer(
-    name="cinch-server",
-    help="CinchDB API server",
-    add_completion=False,
-)
-console = Console()
-
-
-@cli.command()
-def serve(
-    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to"),
-    port: int = typer.Option(8000, "--port", "-p", help="Port to bind to"),
-    reload: bool = typer.Option(False, "--reload", "-r", help="Enable auto-reload"),
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-    create_key: bool = typer.Option(
-        False, "--create-key", help="Create an API key on startup"
-    ),
-):
-    """Start the CinchDB API server."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        console.print("[yellow]Run 'cinch init' to create a project[/yellow]")
-        raise typer.Exit(1)
-
-    console.print("[green]Starting CinchDB API server[/green]")
-    console.print(f"Project: {project_path}")
-    console.print(f"Host: {host}:{port}")
-
-    # Create API key if requested
-    if create_key:
-        manager = APIKeyManager(project_path)
-        api_key = manager.create_key("Initial API Key", permissions="write")
-        console.print("\n[bold green]Created API key:[/bold green]")
-        console.print(f"[yellow]Key: {api_key.key}[/yellow]")
-        console.print(f"[yellow]Permissions: {api_key.permissions}[/yellow]")
-        console.print("\n[bold]Save this key - it won't be shown again![/bold]\n")
-
-    # Start server
-    uvicorn.run(
-        "cinchdb.api.app:app", host=host, port=port, reload=reload, log_level="info"
-    )
-
-
-@cli.command()
-def create_key(
-    name: str = typer.Argument(..., help="Name for the API key"),
-    permissions: str = typer.Option(
-        "read", "--permissions", "-p", help="Permissions (read/write)"
-    ),
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-):
-    """Create a new API key."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        raise typer.Exit(1)
-
-    if permissions not in ["read", "write"]:
-        console.print("[red]❌ Invalid permissions. Must be 'read' or 'write'[/red]")
-        raise typer.Exit(1)
-
-    manager = APIKeyManager(project_path)
-    api_key = manager.create_key(name, permissions=permissions)
-
-    console.print(f"[green]✅ Created API key '{name}'[/green]")
-    console.print(f"[yellow]Key: {api_key.key}[/yellow]")
-    console.print(f"[yellow]Permissions: {api_key.permissions}[/yellow]")
-    console.print("\n[bold]Save this key - it won't be shown again![/bold]")
-
-
-@cli.command()
-def list_keys(
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-):
-    """List all API keys."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        raise typer.Exit(1)
-
-    manager = APIKeyManager(project_path)
-    keys = manager.list_keys()
-
-    if not keys:
-        console.print("[yellow]No API keys found[/yellow]")
-        return
-
-    console.print("\n[bold]API Keys:[/bold]")
-    for key in keys:
-        status = "[green]Active[/green]" if key.active else "[red]Revoked[/red]"
-        branches = (
-            f"Branches: {', '.join(key.branches)}" if key.branches else "All branches"
-        )
-        console.print(f"\n{key.name} - {status}")
-        console.print(f"  Key: {key.key}")
-        console.print(f"  Permissions: {key.permissions}")
-        console.print(f"  {branches}")
-        console.print(f"  Created: {key.created_at}")
-
-
-if __name__ == "__main__":
-    cli()

cinchdb/api/routers/__init__.py

@@ -1,25 +0,0 @@
-"""API routers package."""
-
-from cinchdb.api.routers import (
-    auth,
-    projects,
-    databases,
-    branches,
-    tenants,
-    tables,
-    columns,
-    views,
-    query,
-)
-
-__all__ = [
-    "auth",
-    "projects",
-    "databases",
-    "branches",
-    "tenants",
-    "tables",
-    "columns",
-    "views",
-    "query",
-]

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