Stabilize the stubbed workspace APIs

api/core/config.py

@@ -26,9 +26,12 @@ class Settings(BaseSettings):
     DEBUG: bool = False
 
     # used for validation
-    WS_LONGFORM_SCHEMA_URL: str = (
+    LONGFORM_SCHEMA_URL: str = (
         "https://raw.githubusercontent.com/TaskarCenterAtUW/asr-quests/refs/heads/main/schema/schema.json"
     )
+    IMAGERY_SCHEMA_URL: str = (
+        "https://raw.githubusercontent.com/TaskarCenterAtUW/asr-imagery-list/refs/heads/main/schema/schema.json"
+    )
 
     # proxy destination--"osm-web" is a virtual docker network endpoint
     WS_OSM_HOST: str = "http://osm-web"

api/core/json_schema.py

@@ -0,0 +1,124 @@
+import asyncio
+import json
+from typing import Any
+
+import httpx
+import jsonschema
+from fastapi import HTTPException, status
+
+from api.core.config import settings
+
+# Shared HTTP client. Initialized by main.py lifespan.
+_http_client: httpx.AsyncClient | None = None
+
+_longform_schema: dict | None = None
+_longform_schema_lock = asyncio.Lock()
+
+_imagery_schema: dict | None = None
+_imagery_schema_lock = asyncio.Lock()
+
+
+def init_json_schema_client() -> None:
+    global _http_client
+    _http_client = httpx.AsyncClient(
+        timeout=httpx.Timeout(connect=10, read=30, write=30, pool=10),
+    )
+
+
+def get_http_client() -> httpx.AsyncClient | None:
+    return _http_client
+
+
+async def close_json_schema_client() -> None:
+    global _http_client
+    if _http_client is not None:
+        await _http_client.aclose()
+        _http_client = None
+
+
+async def _fetch_longform_schema() -> dict:
+    global _longform_schema
+    if _longform_schema is None:
+        async with _longform_schema_lock:
+            if _longform_schema is None:
+                response = await _http_client.get(settings.LONGFORM_SCHEMA_URL)
+                response.raise_for_status()
+                _longform_schema = response.json()
+    return _longform_schema
+
+
+async def _fetch_imagery_schema() -> dict:
+    global _imagery_schema
+    if _imagery_schema is None:
+        async with _imagery_schema_lock:
+            if _imagery_schema is None:
+                response = await _http_client.get(settings.IMAGERY_SCHEMA_URL)
+                response.raise_for_status()
+                _imagery_schema = response.json()
+    return _imagery_schema
+
+
+def _raise_for_fetch_error(e: Exception, label: str) -> None:
+    if isinstance(e, httpx.TimeoutException):
+        raise HTTPException(
+            status_code=status.HTTP_504_GATEWAY_TIMEOUT,
+            detail=f"Timed out fetching {label} schema",
+        )
+    raise HTTPException(
+        status_code=status.HTTP_502_BAD_GATEWAY,
+        detail=f"Failed to fetch {label} schema: {e}",
+    )
+
+
+async def validate_quest_definition_schema(definition: str) -> None:
+    """
+    Parse, type-check, and validate a quest definition string against the long-
+    form quest JSON schema.
+    """
+    try:
+        parsed = json.loads(definition)
+    except json.JSONDecodeError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"'definition' must be valid JSON: {e}",
+        )
+    if not parsed or not isinstance(parsed, dict):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="'definition' must be a JSON object.",
+        )
+
+    try:
+        schema = await _fetch_longform_schema()
+    except HTTPException:
+        raise
+    except Exception as e:
+        _raise_for_fetch_error(e, "quest")
+
+    try:
+        jsonschema.validate(instance=parsed, schema=schema)
+    except jsonschema.ValidationError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"{e.message} at {list(e.path)}",
+        )
+
+
+async def validate_imagery_definition_schema(definition: list[Any]) -> None:
+    """
+    Validate the provided definition against the imagery list schema.
+    """
+    try:
+        schema = await _fetch_imagery_schema()
+    except HTTPException:
+        raise
+    except Exception as e:
+        _raise_for_fetch_error(e, "imagery")
+
+    try:
+        jsonschema.validate(instance=definition, schema=schema)
+    except jsonschema.ValidationError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"{e.message} at {list(e.path)}",
+        )

api/main.py

@@ -14,6 +14,7 @@
 from api.core import config
 from api.core.config import settings
 from api.core.database import get_task_session
+from api.core.json_schema import close_json_schema_client, init_json_schema_client
 from api.core.logging import get_logger, setup_logging
 from api.core.security import (
     UserInfo,
@@ -59,13 +60,15 @@ async def lifespan(_app: FastAPI):
         timeout=httpx.Timeout(connect=10, read=7200, write=7200, pool=10),
     )
     init_tdei_client()
+    init_json_schema_client()
 
     yield  # App runs
 
     # Run after app cleanup:
     await _osm_client.aclose()
     _osm_client = None
     await close_tdei_client()
+    await close_json_schema_client()
 
 
 app = FastAPI(
@@ -141,8 +144,10 @@ def get_workspace_repository(
 AUTH_WHITELIST_PATTERNS = [
     re.compile(p)
     for p in [
-        r"^/api/0\.6/user/.*$",  # used during authentication
-        r"^/api/0\.6/workspaces/[0-9]+/bbox\.json$",  # used to get workspace bbox without workspace header, to be removed
+        # Creating/deleting workspaces and JOSM path rewriting:
+        r"^/api/0\.6/workspaces.*$",
+        # Provisioning users during authentication:
+        r"^/api/0\.6/user/.*$",
     ]
 ]