WIP: adding CMS support to breadbox

Author: pgm

breadbox/breadbox/api/dependencies.py

@@ -64,3 +64,9 @@ def get_dataset(
         raise DatasetNotFoundError(f"Dataset '{dataset_id}' not found")
 
     return dataset
+
+
+def get_cms_client(settings=Depends(get_settings),):
+    from ..service import cms
+
+    return cms.PayloadClient(settings.payload_url, settings.payload_api_key)

breadbox/breadbox/api/temp/cms.py

@@ -0,0 +1,52 @@
+from typing import Dict, Any, List
+import re
+
+from sqlalchemy.sql.annotation import Annotated
+
+from .router import router
+from ...service import cms
+from fastapi import Request, Depends
+from ..dependencies import get_cms_client
+
+# this endpoint exists to decouple the front end from payload by preventing any direct access. This
+# has a few advantages:
+#
+# 1. The front end doesn't need to worry about access to payload, just access to breadbox. From the perspective
+#    of the front end, there's only breadbox.
+# 2. We can add a caching layer inside breadbox to avoid every page requesting content from payload. This
+#    will allow us to freely restart payload/taking it offline for periods of time without impacting
+#    any running portals. As a design principal, we want every portal to only rely on the services running
+#    on the deployed server as much as possible to isolate ourselves from other services' outages.
+
+
+@router.get("/cms/{collection_type}", operation_id="get_cms_documents")
+async def get_cms_documents(
+    collection_type: str,
+    request: Request,
+    payload_client: Annotated[cms.PayloadClient, Depends(get_cms_client)],
+) -> List[Dict[str, Any]]:
+    """
+    Retrieve documents from Payload CMS with filtering.
+
+    Query parameters format: prop.<property_name>.eq=<value>
+
+    Example:
+        GET /cms/posts?prop.status.eq=published&prop.author.eq=john
+    """
+
+    # Parse query parameters
+    filters = {}
+    query_params = dict(request.query_params)
+
+    for key, value in query_params.items():
+        # Parse prop.<property_name>.eq format
+        m = re.match("prop\\.([^.]+)\\.eq")
+        if m:
+            # Extract property name
+            prop_name = m.group(1)
+            filters[prop_name] = value
+
+    # Fetch documents from Payload CMS
+    result = await payload_client.fetch(collection_type, filters)
+
+    return result

breadbox/breadbox/config.py

@@ -31,6 +31,10 @@ class Settings(BaseSettings):
 
     LEGACY_CAS_BUCKET: Optional[str] = os.environ.get("LEGACY_CAS_BUCKET")
 
+    # the url for the Payload CMS which is used by the "cms" endpoints
+    payload_url: str = ""
+    payload_api_key: str = ""
+
     model_config = SettingsConfigDict(
         env_file=os.environ.get("BREADBOX_SETTINGS_PATH", ".env"),
     )

breadbox/breadbox/service/cms.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass, replace
+from typing import Any, Dict, Protocol, List
+import httpx
+from fastapi import HTTPException
+
+
+class ContentClient(Protocol):
+    async def fetch(
+        self, collection_type: str, filters: Dict[str, str]
+    ) -> List[Dict[str, Any]]:
+        ...
+
+
+class PayloadClient:
+    url: str
+    api_key: str
+
+    def __init__(self, url: str, api_key: str):
+        self.url = url
+        self.api_key = api_key
+
+    async def fetch(
+        self, collection_type: str, filters: Dict[str, str]
+    ) -> List[Dict[str, Any]]:
+        """
+        Fetch documents from Payload CMS with optional filtering.
+
+        Args:
+            collection_type: The Payload collection name
+            filters: Dictionary of property filters
+
+        Returns:
+            Response from Payload CMS API
+        """
+        url = f"{self.url}/api/{collection_type}"
+
+        # Build query parameters for Payload's where clause
+        where_conditions = {}
+        for prop, value in filters.items():
+            where_conditions[prop] = {"equals": value}
+
+        params = {}
+        if where_conditions:
+            # Payload uses a 'where' parameter with JSON
+            import json
+
+            params["where"] = json.dumps(where_conditions)
+
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    url, params=params, headers=headers, timeout=30.0
+                )
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPError as e:
+                raise HTTPException(
+                    status_code=500, detail=f"Error fetching from Payload CMS: {str(e)}"
+                )
+
+
+class CacheClient:
+    cache_dir: str
+
+    def __init__(self, cache_dir: str):
+        self.cache_dir = cache_dir
+
+    async def fetch(
+        self, collection_type: str, filters: Dict[str, str]
+    ) -> List[Dict[str, Any]]:
+        raise NotImplementedError()
+
+    def update(
+        self,
+        collection_type: str,
+        documents: List[Dict[str, Any]],
+        replace_all: bool = False,
+    ):
+        # used for populating the cache
+        raise NotImplementedError()
+
+
+# Turns out none of this is needed. Will delete...
+# class WrongNumberOfMatches(Exception):
+#     pass
+#
+# class TooManyMatches(WrongNumberOfMatches):
+#     pass
+#
+# class NoMatches(WrongNumberOfMatches):
+#     pass
+#
+# @dataclass(frozen=True)
+# class Query:
+#     client : ContentClient
+#     content_type: str
+#     filters : Dict[str, str]
+#
+#     def filter_by(self, **filters):
+#         new_filters = dict(self.filters, **filters)
+#         return replace(self, filters=new_filters)
+#
+#     async def one(self):
+#         result = await self.client.fetch(self.content_type, self.filters)
+#         if len(result) == 1:
+#             return result[0]
+#         elif len(result) == 0:
+#             raise NoMatches()
+#         else:
+#             raise TooManyMatches()
+#
+#     async def all(self):
+#         return await self.client.fetch(self.content_type, self.filters)
+#
+#     async def one_or_none(self):
+#         result = await self.client.fetch(self.content_type, self.filters)
+#         if len(result) == 1:
+#             return result[0]
+#         elif len(result) == 0:
+#             return None
+#         else:
+#             raise TooManyMatches()
+#
+# class CMS:
+#     """
+#     A slim wrapper around a client which provides some sqlalchemy api-like query behavior where we can
+#     """
+#
+#     client : ContentClient
+#     def __init__(self,client : ContentClient):
+#         self.client = client
+#
+#     def query(self, content_type: str):
+#         return