collection search get sort

Author: jonhealy1

stac_fastapi/core/stac_fastapi/core/core.py

@@ -224,7 +224,9 @@ async def landing_page(self, **kwargs) -> stac_types.LandingPage:
 
         return landing_page
 
-    async def all_collections(self, **kwargs) -> stac_types.Collections:
+    async def all_collections(
+        self, sortby: Optional[str] = None, **kwargs
+    ) -> stac_types.Collections:
         """Read all collections from the database.
 
         Args:
@@ -238,8 +240,23 @@ async def all_collections(self, **kwargs) -> stac_types.Collections:
         limit = int(request.query_params.get("limit", os.getenv("STAC_ITEM_LIMIT", 10)))
         token = request.query_params.get("token")
 
+        sort = None
+        if sortby:
+            parsed_sort = []
+            for raw in sortby:
+                if not isinstance(raw, str):
+                    continue
+                s = raw.strip()
+                if not s:
+                    continue
+                direction = "desc" if s[0] == "-" else "asc"
+                field = s[1:] if s and s[0] in "+-" else s
+                parsed_sort.append({"field": field, "direction": direction})
+            if parsed_sort:
+                sort = parsed_sort
+
         collections, next_token = await self.database.get_all_collections(
-            token=token, limit=limit, request=request
+            token=token, limit=limit, request=request, sort=sort
         )
 
         links = [

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/database_logic.py

@@ -170,13 +170,19 @@ def __attrs_post_init__(self):
     """CORE LOGIC"""
 
     async def get_all_collections(
-        self, token: Optional[str], limit: int, request: Request
+        self,
+        token: Optional[str],
+        limit: int,
+        request: Request,
+        sort: Optional[List[Dict[str, Any]]] = None,
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
-        """Retrieve a list of all collections from Elasticsearch, supporting pagination.
+        """Retrieve a list of collections from Elasticsearch, supporting pagination.
 
         Args:
             token (Optional[str]): The pagination token.
             limit (int): The number of results to return.
+            request (Request): The FastAPI request object.
+            sort (Optional[List[Dict[str, Any]]]): Optional sort parameter from the request.
 
         Returns:
             A tuple of (collections, next pagination token if any).
@@ -185,10 +191,21 @@ async def get_all_collections(
         if token:
             search_after = [token]
 
+        formatted_sort = None
+        if sort:
+            formatted_sort = {}
+            for item in sort:
+                field = item.get("field")
+                direction = item.get("direction", "asc")
+                if field:
+                    formatted_sort[field] = {"order": direction}
+            # Always include id as a secondary sort to ensure consistent pagination
+            formatted_sort.setdefault("id", {"order": "asc"})
+
         response = await self.client.search(
             index=COLLECTIONS_INDEX,
             body={
-                "sort": [{"id": {"order": "asc"}}],
+                "sort": formatted_sort or DEFAULT_SORT,
                 "size": limit,
                 **({"search_after": search_after} if search_after is not None else {}),
             },

stac_fastapi/opensearch/stac_fastapi/opensearch/database_logic.py

@@ -153,20 +153,39 @@ def __attrs_post_init__(self):
     """CORE LOGIC"""
 
     async def get_all_collections(
-        self, token: Optional[str], limit: int, request: Request
+        self,
+        token: Optional[str],
+        limit: int,
+        request: Request,
+        sort: Optional[List[Dict[str, Any]]] = None,
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
         """
-        Retrieve a list of all collections from Opensearch, supporting pagination.
+        Retrieve a list of collections from Opensearch, supporting pagination.
 
         Args:
             token (Optional[str]): The pagination token.
             limit (int): The number of results to return.
+            request (Request): The FastAPI request object.
+            sort (Optional[List[Dict[str, Any]]]): Optional sort parameter from the request.
 
         Returns:
             A tuple of (collections, next pagination token if any).
         """
+        formatted_sort = []
+        if sort:
+            for item in sort:
+                field = item.get("field")
+                direction = item.get("direction", "asc")
+                if field:
+                    formatted_sort.append({field: {"order": direction}})
+            # Always include id as a secondary sort to ensure consistent pagination
+            if not any("id" in item for item in formatted_sort):
+                formatted_sort.append({"id": {"order": "asc"}})
+        else:
+            formatted_sort = [{"id": {"order": "asc"}}]
+
         search_body = {
-            "sort": [{"id": {"order": "asc"}}],
+            "sort": formatted_sort,
             "size": limit,
         }
 

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/mappings.py

@@ -160,6 +160,17 @@ class Geometry(Protocol):  # noqa
     "dynamic_templates": ES_MAPPINGS_DYNAMIC_TEMPLATES,
     "properties": {
         "id": {"type": "keyword"},
+        # "bbox_shape": {"type": "geo_shape"},  # Only this is used for spatial queries
+        # "extent": {
+        #     "properties": {"temporal": {"properties": {"interval": {"type": "date"}}}}
+        # },
+        # "properties": {
+        #     "properties": {
+        #         "datetime": {"type": "date"},
+        #         "start_datetime": {"type": "date"},
+        #         "end_datetime": {"type": "date"},
+        #     }
+        # },
         "extent.spatial.bbox": {"type": "long"},
         "extent.temporal.interval": {"type": "date"},
         "providers": {"type": "object", "enabled": False},