feat: use hub-core capability request reads

api/routers/capability_requests.py

@@ -2,7 +2,7 @@ import re
 import uuid
 from datetime import datetime, timezone
 
-from fastapi import Depends, HTTPException, Query, status
+from fastapi import Depends, HTTPException, status
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -23,7 +23,10 @@ from api.schemas.capability_request import (
     CapabilityRequestReroute,
     CapabilityRequestStatusPatch,
 )
-from hub_core.routers.capabilities import create_capability_catalog_router
+from hub_core.routers.capabilities import (
+    create_capability_catalog_router,
+    create_capability_request_read_router,
+)
 
 
 router = create_capability_catalog_router(
@@ -32,6 +35,14 @@ router = create_capability_catalog_router(
     repo_model=ManagedRepo,
     catalog_model=CapabilityCatalog,
 )
+router.include_router(
+    create_capability_request_read_router(
+        get_session,
+        domain_model=Domain,
+        request_model=CapabilityRequest,
+        request_read_schema=CapabilityRequestRead,
+    )
+)
 
 
 # ---------------------------------------------------------------------------
@@ -92,36 +103,6 @@ async def create_request(
     return req
 
 
-@router.get("/capability-requests/", response_model=list[CapabilityRequestRead])
-async def list_requests(
-    domain: str | None = Query(None, description="Filter by requesting OR fulfilling domain slug"),
-    status_filter: str | None = Query(None, alias="status"),
-    capability_type: str | None = Query(None),
-    session: AsyncSession = Depends(get_session),
-) -> list[CapabilityRequest]:
-    q = select(CapabilityRequest).order_by(CapabilityRequest.created_at.desc())
-    if domain:
-        d = await _resolve_domain(domain, session)
-        q = q.where(
-            (CapabilityRequest.requesting_domain_id == d.id)
-            | (CapabilityRequest.fulfilling_domain_id == d.id)
-        )
-    if status_filter:
-        q = q.where(CapabilityRequest.status == status_filter)
-    if capability_type:
-        q = q.where(CapabilityRequest.capability_type == capability_type)
-    result = await session.execute(q)
-    return list(result.scalars().all())
-
-
-@router.get("/capability-requests/{request_id}", response_model=CapabilityRequestRead)
-async def get_request(
-    request_id: uuid.UUID,
-    session: AsyncSession = Depends(get_session),
-) -> CapabilityRequest:
-    return await _get_request_or_404(request_id, session)
-
-
 @router.post("/capability-requests/{request_id}/accept", response_model=CapabilityRequestRead)
 async def accept_request(
     request_id: uuid.UUID,