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

cinchdb/api/auth.py

@@ -1,290 +0,0 @@
-"""Authentication and API key management for CinchDB API."""
-
-import uuid
-from datetime import datetime, timezone
-from typing import Optional, List, Literal
-from pathlib import Path
-
-from fastapi import HTTPException, Security, Depends, Query
-from fastapi.security import APIKeyHeader
-from pydantic import BaseModel, Field
-
-from cinchdb.config import Config
-from cinchdb.core.path_utils import get_project_root
-
-
-# API Key header
-api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
-
-
-class APIKey(BaseModel):
-    """API key model."""
-
-    key: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    name: str
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    permissions: Literal["read", "write"] = "read"
-    branches: Optional[List[str]] = None  # None means all branches
-    active: bool = True
-
-
-class APIKeyManager:
-    """Manages API keys in the project configuration."""
-
-    def __init__(self, project_dir: Optional[Path] = None):
-        """Initialize API key manager.
-
-        Args:
-            project_dir: Project directory path
-        """
-        self.project_dir = project_dir or Path.cwd()
-        self.config = Config(self.project_dir)
-
-    def create_key(
-        self,
-        name: str,
-        permissions: Literal["read", "write"] = "read",
-        branches: Optional[List[str]] = None,
-    ) -> APIKey:
-        """Create a new API key.
-
-        Args:
-            name: Name for the API key
-            permissions: Permission level (read or write)
-            branches: List of allowed branches (None for all)
-
-        Returns:
-            Created API key
-        """
-        api_key = APIKey(name=name, permissions=permissions, branches=branches)
-
-        # Load config and add key
-        config_data = self.config.load()
-        if not config_data.api_keys:
-            config_data.api_keys = {}
-
-        config_data.api_keys[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,
-        }
-
-        self.config.save(config_data)
-        return api_key
-
-    def get_key(self, key: str) -> Optional[APIKey]:
-        """Get an API key by its value.
-
-        Args:
-            key: API key string
-
-        Returns:
-            API key if found and active, None otherwise
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return None
-
-        key_data = config_data.api_keys[key]
-        if not key_data.get("active", True):
-            return None
-
-        return APIKey(
-            key=key,
-            name=key_data["name"],
-            created_at=datetime.fromisoformat(key_data["created_at"]),
-            permissions=key_data.get("permissions", "read"),
-            branches=key_data.get("branches"),
-            active=key_data.get("active", True),
-        )
-
-    def list_keys(self) -> List[APIKey]:
-        """List all API keys.
-
-        Returns:
-            List of API keys
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys:
-            return []
-
-        keys = []
-        for key, key_data in config_data.api_keys.items():
-            keys.append(
-                APIKey(
-                    key=key,
-                    name=key_data["name"],
-                    created_at=datetime.fromisoformat(key_data["created_at"]),
-                    permissions=key_data.get("permissions", "read"),
-                    branches=key_data.get("branches"),
-                    active=key_data.get("active", True),
-                )
-            )
-
-        return keys
-
-    def revoke_key(self, key: str) -> bool:
-        """Revoke an API key.
-
-        Args:
-            key: API key to revoke
-
-        Returns:
-            True if revoked, False if not found
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return False
-
-        config_data.api_keys[key]["active"] = False
-        self.config.save(config_data)
-        return True
-
-    def delete_key(self, key: str) -> bool:
-        """Delete an API key.
-
-        Args:
-            key: API key to delete
-
-        Returns:
-            True if deleted, False if not found
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return False
-
-        del config_data.api_keys[key]
-        self.config.save(config_data)
-        return True
-
-
-class AuthContext(BaseModel):
-    """Authentication context for requests."""
-
-    api_key: APIKey
-    project_dir: Path
-
-
-async def get_current_project(project_dir: Optional[str] = None) -> Path:
-    """Get the current project directory.
-
-    Args:
-        project_dir: Optional project directory path
-
-    Returns:
-        Project directory path
-
-    Raises:
-        HTTPException: If project not found
-    """
-    if project_dir:
-        path = Path(project_dir)
-        if not path.exists() or not (path / ".cinchdb").exists():
-            raise HTTPException(status_code=404, detail="Project not found")
-        return path
-
-    # Try to find project from current directory
-    project_root = get_project_root(Path.cwd())
-    if not project_root:
-        raise HTTPException(
-            status_code=404,
-            detail="No CinchDB project found. Specify project_dir parameter.",
-        )
-
-    return project_root
-
-
-async def verify_api_key(
-    api_key_header: Optional[str] = Security(api_key_header),
-    api_key_query: Optional[str] = Query(None, alias="api_key"),
-    project_dir: Path = Depends(get_current_project),
-) -> AuthContext:
-    """Verify API key and return auth context.
-
-    Args:
-        api_key_header: API key from header
-        api_key_query: API key from query parameter
-        project_dir: Project directory
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If authentication fails
-    """
-    # Check header first, then query parameter
-    api_key = api_key_header or api_key_query
-    
-    if not api_key:
-        raise HTTPException(
-            status_code=401,
-            detail="API key required",
-            headers={"WWW-Authenticate": "ApiKey"},
-        )
-
-    manager = APIKeyManager(project_dir)
-    key_obj = manager.get_key(api_key)
-
-    if not key_obj:
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "ApiKey"},
-        )
-
-    return AuthContext(api_key=key_obj, project_dir=project_dir)
-
-
-async def require_write_permission(
-    auth: AuthContext = Depends(verify_api_key), branch: Optional[str] = None
-) -> AuthContext:
-    """Require write permission for the request.
-
-    Args:
-        auth: Authentication context
-        branch: Optional branch name to check
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If permission denied
-    """
-    if auth.api_key.permissions != "write":
-        raise HTTPException(status_code=403, detail="Write permission required")
-
-    # Check branch-specific permissions
-    if branch and auth.api_key.branches and branch not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{branch}'"
-        )
-
-    return auth
-
-
-async def require_read_permission(
-    auth: AuthContext = Depends(verify_api_key), branch: Optional[str] = None
-) -> AuthContext:
-    """Require read permission for the request.
-
-    Args:
-        auth: Authentication context
-        branch: Optional branch name to check
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If permission denied
-    """
-    # All valid API keys have at least read permission
-
-    # Check branch-specific permissions
-    if branch and auth.api_key.branches and branch not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{branch}'"
-        )
-
-    return auth

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