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

cinchdb/api/routers/projects.py

@@ -1,133 +0,0 @@
-"""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

@@ -1,156 +0,0 @@
-"""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

@@ -1,349 +0,0 @@
-"""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))