Breadbox releases api phase2 - release_versions CRUD, CRUD tests, and api (#660)

Author: alimourey

breadbox/breadbox/api/__init__.py

@@ -3,6 +3,8 @@
 
 from .uploads import router as uploads_router
 from .datasets import router as datasets_router
+from .release_versions import router as release_versions_router
+from .release_files import router as release_files_router
 from .dataset_uploads import router as dataset_uploads_router
 from .downloads import router as downloads_router
 from .groups import router as groups_router
@@ -19,6 +21,8 @@
 
 api_router = APIRouter(responses=ERROR_RESPONSES)  # type: ignore
 api_router.include_router(datasets_router)
+api_router.include_router(release_versions_router)
+api_router.include_router(release_files_router)
 api_router.include_router(dataset_uploads_router)
 api_router.include_router(uploads_router)
 api_router.include_router(downloads_router)

breadbox/breadbox/api/release_files.py

@@ -0,0 +1,54 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, Query
+
+from breadbox.schemas.release_version import ReleaseFileSearchResponse
+from ..crud import release_version as release_version_crud
+from breadbox.api.dependencies import get_db_with_user
+from breadbox.db.session import SessionWithUser
+
+# Separated from release-versions to reduce confusion about the level
+# of granularity of the full text search. Search returns release file
+# level data.
+router = APIRouter(prefix="/release-files", tags=["release-files"])
+
+
+@router.get(
+    "/search",
+    response_model=List[ReleaseFileSearchResponse],
+    operation_id="search_release_files",
+)
+def search_release_files(
+    q: str = Query(
+        ...,
+        min_length=1,
+        description="Search query as the user types in the global searchbar.",
+    ),
+    limit: int = Query(
+        50, ge=1, le=100, description="Number of results to return per page. Max 100.",
+    ),  # ge "greater than or equal to", le "less than or equal to"
+    offset: int = Query(
+        0,
+        ge=0,
+        description="Number of results to skip from the beginning (used for pagination).",
+    ),
+    db: SessionWithUser = Depends(get_db_with_user),
+):
+    """
+    Search for individual files across all releases using the FTS5 index.
+    Returns denormalized metadata for each matching file.
+    
+    If you have 150 results:
+
+    Page 1: limit=50, offset=0 (Gets results 1-50)
+
+    Page 2: limit=50, offset=50 (Gets results 51-100)
+
+    Page 3: limit=50, offset=100 (Gets results 101-150)
+    """
+    # This uses the SQLite FTS5 'MATCH' operator
+    results = release_version_crud.search_release_files(
+        db=db, q=q, limit=limit, offset=offset
+    )
+
+    return results

breadbox/breadbox/api/release_versions.py

@@ -0,0 +1,157 @@
+from datetime import date
+from typing import List, Optional, Annotated
+from logging import getLogger
+from fastapi import APIRouter, Depends, HTTPException, Request, Response, Body, Query
+
+from breadbox.api.dependencies import get_db_with_user
+from breadbox.db.session import SessionWithUser
+from breadbox.db.util import transaction
+from breadbox.schemas.custom_http_exception import UserError
+
+from ..crud import release_version as release_version_crud
+from ..models.release_version import ReleaseVersion
+from ..schemas.release_version import (
+    ReleaseVersionResponse,
+    CreateReleaseVersionParams,
+)
+
+router = APIRouter(prefix="/release-versions", tags=["release-versions"])
+log = getLogger(__name__)
+
+
+def _get_required_release_version(
+    db: SessionWithUser, release_version_id: str, include_files: bool = False
+) -> ReleaseVersion:
+    """Helper to fetch a release_version or raise 404"""
+    release_version = release_version_crud.get_release_version(
+        db=db, release_version_id=release_version_id, include_files=include_files
+    )
+    if release_version is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Release version with id {release_version_id} not found",
+        )
+    return release_version
+
+
+@router.get(
+    "/",
+    operation_id="get_release_versions",
+    response_model=List[ReleaseVersionResponse],
+)
+def get_release_versions(
+    release_name: Optional[str] = Query(
+        None, description="Filter by general release name (e.g. Depmap Public)"
+    ),
+    datatype: Optional[str] = Query(
+        None, description="Filter by file datatype (e.g. 'crispr')"
+    ),
+    start_date: Optional[date] = Query(
+        None, description="Filter releases published on or after this date (YYYY-MM-DD)"
+    ),
+    end_date: Optional[date] = Query(
+        None,
+        description="Filter releases published on or before this date (YYYY-MM-DD)",
+    ),
+    include_files: bool = Query(
+        False,
+        description="If true, includes the list of files for each release in the response.",
+    ),
+    db: SessionWithUser = Depends(get_db_with_user),
+):
+    """
+    Get a list of available release versions, filtered by metadata or date ranges.
+    """
+    return release_version_crud.get_release_versions(
+        db,
+        release_name=release_name,
+        datatype=datatype,
+        start_date=start_date,
+        end_date=end_date,
+        include_files=include_files,
+    )
+
+
+@router.get(
+    "/{release_version_id}",
+    operation_id="get_release_version",
+    response_model=ReleaseVersionResponse,
+)
+def get_release_version(
+    release_version_id: str,
+    response: Response,
+    request: Request,
+    include_files: bool = Query(
+        True,
+        description="If false, leaves off the list of files for each release in the response.",
+    ),
+    db: SessionWithUser = Depends(get_db_with_user),
+):
+    """
+    Get full metadata for a specific release version.
+    Includes ETag support via content_hash.
+    """
+    if_none_match = request.headers.get("If-None-Match")
+    release = _get_required_release_version(
+        db=db, release_version_id=release_version_id, include_files=include_files
+    )
+
+    # ETag / 304 logic
+    etag = f'"{release.content_hash}"'
+    if if_none_match == etag:
+        return Response(status_code=304)
+
+    response.headers["ETag"] = etag
+    return release
+
+
+@router.post(
+    "/", operation_id="create_release_version", response_model=ReleaseVersionResponse,
+)
+def create_release_version(
+    params: Annotated[CreateReleaseVersionParams, Body()],
+    db: SessionWithUser = Depends(get_db_with_user),
+):
+    """
+    Register a new release version and its associated files/pipelines.
+    This is typically called by the data loader.
+    """
+    # Check for existing version/release name combo - must be unique
+    existing = release_version_crud.get_release_version_by_release_name_and_version(
+        db, params.release_name, params.version_name
+    )
+    if existing:
+        raise HTTPException(
+            status_code=409,
+            detail=f"Release '{params.release_name}' version '{params.version_name}' already exists.",
+        )
+
+    try:
+        with transaction(db):
+            new_release_version = release_version_crud.create_release_version(
+                db, params
+            )
+            return new_release_version
+    except Exception as e:
+        raise UserError(f"Failed to create release version: {str(e)}")
+
+
+@router.delete(
+    "/{release_version_id}", operation_id="delete_release_version",
+)
+def delete_release_version(
+    release_version_id: str, db: SessionWithUser = Depends(get_db_with_user),
+):
+    """
+    Delete a release version. Associated files and pipelines will be 
+    deleted automatically via cascade.
+    """
+    release = _get_required_release_version(
+        db=db, release_version_id=release_version_id
+    )
+
+    with transaction(db):
+        release_version_crud.delete_release_version(db, release)
+        return {
+            "message": f"Release version {release_version_id} deleted successfully."
+        }