cinchdb 0.1.0__py3-none-any.whl

cinchdb/api/routers/projects.py

@@ -0,0 +1,133 @@
+"""Projects router for CinchDB API."""
+
+from pathlib import Path
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from cinchdb.config import Config
+from cinchdb.api.auth import (
+    AuthContext,
+    require_write_permission,
+    require_read_permission,
+)
+
+
+router = APIRouter()
+
+
+class ProjectInfo(BaseModel):
+    """Project information response."""
+
+    path: str
+    active_database: str
+    active_branch: str
+    has_api_keys: bool
+
+
+class InitProjectRequest(BaseModel):
+    """Request to initialize a new project."""
+
+    path: str
+
+
+@router.post("/init")
+async def init_project(
+    request: InitProjectRequest, auth: AuthContext = Depends(require_write_permission)
+):
+    """Initialize a new CinchDB project."""
+    project_path = Path(request.path)
+
+    # Check if directory exists
+    if not project_path.exists():
+        try:
+            project_path.mkdir(parents=True)
+        except Exception as e:
+            raise HTTPException(
+                status_code=400, detail=f"Failed to create directory: {e}"
+            )
+
+    # Initialize project
+    try:
+        config = Config(project_path)
+        config.init_project()
+        return {"message": f"Initialized CinchDB project in {project_path}"}
+    except FileExistsError:
+        raise HTTPException(status_code=400, detail="Project already exists")
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to initialize project: {e}"
+        )
+
+
+@router.get("/info")
+async def get_project_info(
+    auth: AuthContext = Depends(require_read_permission),
+) -> ProjectInfo:
+    """Get information about the current project."""
+    config = Config(auth.project_dir)
+
+    try:
+        config_data = config.load()
+        has_keys = bool(config_data.api_keys)
+
+        return ProjectInfo(
+            path=str(auth.project_dir),
+            active_database=config_data.active_database,
+            active_branch=config_data.active_branch,
+            has_api_keys=has_keys,
+        )
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Project configuration not found")
+
+
+class SetActiveRequest(BaseModel):
+    """Request to set active database or branch."""
+
+    database: Optional[str] = None
+    branch: Optional[str] = None
+
+
+@router.put("/active")
+async def set_active(
+    request: SetActiveRequest, auth: AuthContext = Depends(require_write_permission)
+):
+    """Set the active database and/or branch."""
+    config = Config(auth.project_dir)
+
+    try:
+        config_data = config.load()
+
+        if request.database:
+            # Verify database exists
+            db_path = auth.project_dir / ".cinchdb" / "databases" / request.database
+            if not db_path.exists():
+                raise HTTPException(
+                    status_code=404, detail=f"Database '{request.database}' not found"
+                )
+            config_data.active_database = request.database
+
+        if request.branch:
+            # Verify branch exists in active database
+            branch_path = (
+                auth.project_dir
+                / ".cinchdb"
+                / "databases"
+                / config_data.active_database
+                / "branches"
+                / request.branch
+            )
+            if not branch_path.exists():
+                raise HTTPException(
+                    status_code=404, detail=f"Branch '{request.branch}' not found"
+                )
+            config_data.active_branch = request.branch
+
+        config.save(config_data)
+
+        return {
+            "active_database": config_data.active_database,
+            "active_branch": config_data.active_branch,
+        }
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Project configuration not found")

cinchdb/api/routers/query.py

@@ -0,0 +1,156 @@
+"""Query router for CinchDB API."""
+
+from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam
+from pydantic import BaseModel
+
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.api.auth import (
+    AuthContext,
+    require_read_permission,
+    require_write_permission,
+)
+from cinchdb.utils import validate_sql_query, SQLValidationError, SQLOperation
+
+
+router = APIRouter()
+
+
+class QueryRequest(BaseModel):
+    """Request to execute a query."""
+
+    sql: str
+    limit: Optional[int] = None
+
+
+class QueryResult(BaseModel):
+    """Query execution result."""
+
+    columns: List[str]
+    rows: List[List[Any]]
+    row_count: int
+    affected_rows: Optional[int] = None
+
+
+@router.post("/execute")
+async def execute_query(
+    request: QueryRequest,
+    database: str = QueryParam(..., description="Database name"),
+    branch: str = QueryParam(..., description="Branch name"),
+    tenant: str = QueryParam(..., description="Tenant name"),
+    auth: AuthContext = Depends(require_read_permission),
+) -> QueryResult:
+    """Execute a SQL query.
+
+    SELECT queries require read permission.
+    INSERT/UPDATE/DELETE queries require write permission.
+    """
+    db_name = database
+    branch_name = branch
+
+    # Validate the SQL query first
+    try:
+        is_valid, error_msg, operation = validate_sql_query(request.sql)
+        if not is_valid:
+            raise HTTPException(status_code=400, detail=error_msg)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    
+    # Check if this is a write operation based on validated operation
+    sql_upper = request.sql.strip().upper()
+    is_write = operation in (SQLOperation.INSERT, SQLOperation.UPDATE, SQLOperation.DELETE)
+
+    if is_write:
+        # Require write permission for write operations
+        await require_write_permission(auth, branch_name)
+    else:
+        # Check branch permissions for read
+        await require_read_permission(auth, branch_name)
+
+    # Add LIMIT if specified and not already present
+    query_sql = request.sql
+    if request.limit and "LIMIT" not in sql_upper:
+        query_sql = f"{request.sql} LIMIT {request.limit}"
+
+    # Get database path
+    db_path = get_tenant_db_path(auth.project_dir, db_name, branch_name, tenant)
+
+    try:
+        with DatabaseConnection(db_path) as conn:
+            cursor = conn.execute(query_sql)
+
+            # Check if this is a SELECT query
+            is_select = sql_upper.startswith("SELECT")
+
+            if is_select:
+                rows = cursor.fetchall()
+
+                # Get column names
+                columns = (
+                    [desc[0] for desc in cursor.description]
+                    if cursor.description
+                    else []
+                )
+
+                # Convert rows to lists (from sqlite3.Row objects)
+                row_data = []
+                for row in rows:
+                    row_data.append(list(row))
+
+                return QueryResult(
+                    columns=columns,
+                    rows=row_data,
+                    row_count=len(rows),
+                    affected_rows=None,
+                )
+            else:
+                # For INSERT/UPDATE/DELETE, commit and return affected rows
+                conn.commit()
+                affected = cursor.rowcount
+
+                return QueryResult(
+                    columns=[], rows=[], row_count=0, affected_rows=affected
+                )
+
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {str(e)}")
+
+
+@router.get("/tables/{table}/data")
+async def get_table_data(
+    table: str,
+    database: str = QueryParam(..., description="Database name"),
+    branch: str = QueryParam(..., description="Branch name"),
+    tenant: str = QueryParam(..., description="Tenant name"),
+    limit: int = QueryParam(100, description="Maximum rows to return"),
+    offset: int = QueryParam(0, description="Number of rows to skip"),
+    auth: AuthContext = Depends(require_read_permission),
+) -> QueryResult:
+    """Get data from a specific table with pagination."""
+    # Build query
+    query = QueryRequest(
+        sql=f"SELECT * FROM {table} LIMIT {limit} OFFSET {offset}",
+        limit=None,  # Already included in SQL
+    )
+
+    return await execute_query(query, database, branch, tenant, auth)
+
+
+@router.get("/tables/{table}/count")
+async def get_table_count(
+    table: str,
+    database: str = QueryParam(..., description="Database name"),
+    branch: str = QueryParam(..., description="Branch name"),
+    tenant: str = QueryParam(..., description="Tenant name"),
+    auth: AuthContext = Depends(require_read_permission),
+) -> Dict[str, int]:
+    """Get the row count for a table."""
+    # Build query
+    query = QueryRequest(sql=f"SELECT COUNT(*) as count FROM {table}", limit=None)
+
+    result = await execute_query(query, database, branch, tenant, auth)
+
+    if result.rows and result.rows[0]:
+        return {"count": result.rows[0][0]}
+    return {"count": 0}

cinchdb/api/routers/tables.py

@@ -0,0 +1,349 @@
+"""Tables router for CinchDB API."""
+
+from typing import List, Optional
+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, ForeignKeyRef
+from cinchdb.api.auth import (
+    AuthContext,
+    require_write_permission,
+    require_read_permission,
+)
+
+
+router = APIRouter()
+
+
+class ForeignKeySchema(BaseModel):
+    """Foreign key schema for requests."""
+    
+    table: str
+    column: str = "id"
+    on_delete: str = "RESTRICT"
+    on_update: str = "RESTRICT"
+
+
+class ColumnSchema(BaseModel):
+    """Column schema for requests."""
+
+    name: str
+    type: str
+    nullable: bool = False
+    default: Optional[str] = None
+    primary_key: bool = False
+    unique: bool = False
+    foreign_key: Optional[ForeignKeySchema] = None
+
+
+class TableInfo(BaseModel):
+    """Table information."""
+
+    name: str
+    column_count: int
+    columns: List[ColumnSchema]
+
+
+class CreateTableRequest(BaseModel):
+    """Request to create a table."""
+
+    name: str
+    columns: List[ColumnSchema]
+
+
+class CopyTableRequest(BaseModel):
+    """Request to copy a table."""
+
+    source: str
+    target: str
+    copy_data: bool = True
+
+
+@router.get("/", response_model=List[TableInfo])
+async def list_tables(
+    database: str = Query(..., description="Database name"),
+    branch: str = Query(..., description="Branch name"),
+    auth: AuthContext = Depends(require_read_permission),
+):
+    """List all tables in a branch."""
+    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,
+        )
+        tables = db.tables.list_tables()
+
+        result = []
+        for table in tables:
+            # Convert columns
+            columns = []
+            for col in table.columns:
+                # Convert foreign key if present
+                fk_schema = None
+                if col.foreign_key:
+                    fk_schema = ForeignKeySchema(
+                        table=col.foreign_key.table,
+                        column=col.foreign_key.column,
+                        on_delete=col.foreign_key.on_delete,
+                        on_update=col.foreign_key.on_update,
+                    )
+                
+                columns.append(
+                    ColumnSchema(
+                        name=col.name,
+                        type=col.type,
+                        nullable=col.nullable,
+                        default=col.default,
+                        primary_key=col.primary_key,
+                        unique=col.unique,
+                        foreign_key=fk_schema,
+                    )
+                )
+
+            # Count user-defined columns
+            user_columns = [
+                c
+                for c in table.columns
+                if c.name not in ["id", "created_at", "updated_at"]
+            ]
+
+            result.append(
+                TableInfo(
+                    name=table.name, column_count=len(user_columns), columns=columns
+                )
+            )
+
+        return result
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/")
+async def create_table(
+    request: CreateTableRequest,
+    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),
+):
+    """Create a new table."""
+    db_name = database
+    branch_name = branch
+
+    # Check branch permissions
+    await require_write_permission(auth, branch_name)
+
+    # Convert columns
+    columns = []
+    for col_schema in request.columns:
+        # Validate type
+        if col_schema.type.upper() not in [
+            "TEXT",
+            "INTEGER",
+            "REAL",
+            "BLOB",
+            "NUMERIC",
+        ]:
+            raise HTTPException(
+                status_code=400, detail=f"Invalid column type: {col_schema.type}"
+            )
+
+        # Convert foreign key if present
+        fk_ref = None
+        if col_schema.foreign_key:
+            # Validate FK action
+            if col_schema.foreign_key.on_delete not in ["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"]:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid on_delete action: {col_schema.foreign_key.on_delete}"
+                )
+            if col_schema.foreign_key.on_update not in ["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"]:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid on_update action: {col_schema.foreign_key.on_update}"
+                )
+            
+            fk_ref = ForeignKeyRef(
+                table=col_schema.foreign_key.table,
+                column=col_schema.foreign_key.column,
+                on_delete=col_schema.foreign_key.on_delete,
+                on_update=col_schema.foreign_key.on_update,
+            )
+        
+        columns.append(
+            Column(
+                name=col_schema.name,
+                type=col_schema.type.upper(),
+                nullable=col_schema.nullable,
+                default=col_schema.default,
+                primary_key=col_schema.primary_key,
+                unique=col_schema.unique,
+                foreign_key=fk_ref,
+            )
+        )
+
+    try:
+        db = CinchDB(
+            database=db_name,
+            branch=branch_name,
+            tenant="main",
+            project_dir=auth.project_dir,
+        )
+        db.tables.create_table(request.name, columns)
+
+        # Apply to all tenants if requested
+        if apply:
+            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
+            applier.apply_all_unapplied()
+
+        return {
+            "message": f"Created table '{request.name}' with {len(columns)} columns"
+        }
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{name}")
+async def delete_table(
+    name: 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),
+):
+    """Delete 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.tables.delete_table(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"Deleted table '{name}'"}
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/copy")
+async def copy_table(
+    request: CopyTableRequest,
+    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),
+):
+    """Copy a table to a new 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.tables.copy_table(request.source, request.target, request.copy_data)
+
+        # Apply to all tenants if requested
+        if apply:
+            applier = ChangeApplier(auth.project_dir, db_name, branch_name)
+            applier.apply_all_unapplied()
+
+        data_msg = "with data" if request.copy_data else "without data"
+        return {
+            "message": f"Copied table '{request.source}' to '{request.target}' {data_msg}"
+        }
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{name}")
+async def get_table_info(
+    name: str,
+    database: str = Query(..., description="Database name"),
+    branch: str = Query(..., description="Branch name"),
+    auth: AuthContext = Depends(require_read_permission),
+) -> TableInfo:
+    """Get information about a specific 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,
+        )
+        table = db.tables.get_table(name)
+
+        # Convert columns
+        columns = []
+        for col in table.columns:
+            # Convert foreign key if present
+            fk_schema = None
+            if col.foreign_key:
+                fk_schema = ForeignKeySchema(
+                    table=col.foreign_key.table,
+                    column=col.foreign_key.column,
+                    on_delete=col.foreign_key.on_delete,
+                    on_update=col.foreign_key.on_update,
+                )
+            
+            columns.append(
+                ColumnSchema(
+                    name=col.name,
+                    type=col.type,
+                    nullable=col.nullable,
+                    default=col.default,
+                    primary_key=col.primary_key,
+                    unique=col.unique,
+                    foreign_key=fk_schema,
+                )
+            )
+
+        # Count user-defined columns
+        user_columns = [
+            c for c in table.columns if c.name not in ["id", "created_at", "updated_at"]
+        ]
+
+        return TableInfo(
+            name=table.name, column_count=len(user_columns), columns=columns
+        )
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))