stac-fastapi-core 6.9.0__py3-none-any.whl → 6.10.0__py3-none-any.whl

stac_fastapi/core/core.py

@@ -546,18 +546,20 @@ class CoreClient(AsyncBaseCoreClient):
         return await self.all_collections(
             limit=search_request.limit if hasattr(search_request, "limit") else None,
             bbox=search_request.bbox if hasattr(search_request, "bbox") else None,
-            datetime=search_request.datetime
-            if hasattr(search_request, "datetime")
-            else None,
+            datetime=(
+                search_request.datetime if hasattr(search_request, "datetime") else None
+            ),
             token=search_request.token if hasattr(search_request, "token") else None,
             fields=fields,
             sortby=sortby,
-            filter_expr=search_request.filter
-            if hasattr(search_request, "filter")
-            else None,
-            filter_lang=search_request.filter_lang
-            if hasattr(search_request, "filter_lang")
-            else None,
+            filter_expr=(
+                search_request.filter if hasattr(search_request, "filter") else None
+            ),
+            filter_lang=(
+                search_request.filter_lang
+                if hasattr(search_request, "filter_lang")
+                else None
+            ),
             query=search_request.query if hasattr(search_request, "query") else None,
             q=search_request.q if hasattr(search_request, "q") else None,
             request=request,

stac_fastapi/core/extensions/catalogs.py

@@ -12,9 +12,15 @@ from starlette.responses import Response
 from typing_extensions import TypedDict
 
 from stac_fastapi.core.models import Catalog
-from stac_fastapi.sfeos_helpers.mappings import COLLECTIONS_INDEX
+from stac_fastapi.sfeos_helpers.database import (
+    search_children_with_pagination_shared,
+    search_collections_by_parent_id_shared,
+    search_sub_catalogs_with_pagination_shared,
+    update_catalog_in_index_shared,
+)
 from stac_fastapi.types import stac as stac_types
 from stac_fastapi.types.core import BaseCoreClient
+from stac_fastapi.types.errors import NotFoundError
 from stac_fastapi.types.extension import ApiExtension
 
 logger = logging.getLogger(__name__)
@@ -106,6 +112,31 @@ class CatalogsExtension(ApiExtension):
             tags=["Catalogs"],
         )
 
+        # Add endpoint for getting sub-catalogs of a catalog
+        self.router.add_api_route(
+            path="/catalogs/{catalog_id}/catalogs",
+            endpoint=self.get_catalog_catalogs,
+            methods=["GET"],
+            response_model=Catalogs,
+            response_class=self.response_class,
+            summary="Get Catalog Sub-Catalogs",
+            description="Get sub-catalogs linked from a specific catalog.",
+            tags=["Catalogs"],
+        )
+
+        # Add endpoint for creating sub-catalogs in a catalog
+        self.router.add_api_route(
+            path="/catalogs/{catalog_id}/catalogs",
+            endpoint=self.create_catalog_catalog,
+            methods=["POST"],
+            response_model=Catalog,
+            response_class=self.response_class,
+            status_code=201,
+            summary="Create Catalog Sub-Catalog",
+            description="Create a new catalog and link it as a sub-catalog of a specific catalog.",
+            tags=["Catalogs"],
+        )
+
         # Add endpoint for creating collections in a catalog
         self.router.add_api_route(
             path="/catalogs/{catalog_id}/collections",
@@ -119,6 +150,18 @@ class CatalogsExtension(ApiExtension):
             tags=["Catalogs"],
         )
 
+        # Add endpoint for updating a catalog
+        self.router.add_api_route(
+            path="/catalogs/{catalog_id}",
+            endpoint=self.update_catalog,
+            methods=["PUT"],
+            response_model=Catalog,
+            response_class=self.response_class,
+            summary="Update Catalog",
+            description="Update an existing STAC catalog.",
+            tags=["Catalogs"],
+        )
+
         # Add endpoint for deleting a catalog
         self.router.add_api_route(
             path="/catalogs/{catalog_id}",
@@ -281,6 +324,55 @@ class CatalogsExtension(ApiExtension):
         # Return the created catalog
         return catalog
 
+    async def update_catalog(
+        self, catalog_id: str, catalog: Catalog, request: Request
+    ) -> Catalog:
+        """Update an existing catalog.
+
+        Args:
+            catalog_id: The ID of the catalog to update.
+            catalog: The updated catalog data.
+            request: Request object.
+
+        Returns:
+            The updated catalog.
+
+        Raises:
+            HTTPException: If the catalog is not found.
+        """
+        try:
+            # Verify the catalog exists
+            existing_catalog_db = await self.client.database.find_catalog(catalog_id)
+
+            # Convert STAC catalog to database format
+            db_catalog = self.client.catalog_serializer.stac_to_db(catalog, request)
+            db_catalog_dict = db_catalog.model_dump()
+            db_catalog_dict["type"] = "Catalog"
+
+            # Preserve parent_ids and other internal fields from the existing catalog
+            if "parent_ids" in existing_catalog_db:
+                db_catalog_dict["parent_ids"] = existing_catalog_db["parent_ids"]
+
+            # Update the catalog in the database (upsert via create_catalog)
+            await self.client.database.create_catalog(db_catalog_dict, refresh=True)
+
+            # Return the updated catalog
+            return catalog
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            error_msg = str(e)
+            if "not found" in error_msg.lower():
+                raise HTTPException(
+                    status_code=404, detail=f"Catalog {catalog_id} not found"
+                )
+            logger.error(f"Error updating catalog {catalog_id}: {e}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to update catalog: {str(e)}",
+            )
+
     async def get_catalog(self, catalog_id: str, request: Request) -> Catalog:
         """Get a specific catalog by ID.
 
@@ -365,11 +457,9 @@ class CatalogsExtension(ApiExtension):
             await self.client.database.find_catalog(catalog_id)
 
             # Find all collections with this catalog in parent_ids
-            query_body = {"query": {"term": {"parent_ids": catalog_id}}, "size": 10000}
-            search_result = await self.client.database.client.search(
-                index=COLLECTIONS_INDEX, body=query_body
+            children = await search_collections_by_parent_id_shared(
+                self.client.database.client, catalog_id
             )
-            children = [hit["_source"] for hit in search_result["hits"]["hits"]]
 
             # Safe Unlink: Remove catalog from all children's parent_ids
             # If a child becomes an orphan, adopt it to root
@@ -440,27 +530,15 @@ class CatalogsExtension(ApiExtension):
             # Verify the catalog exists
             await self.client.database.find_catalog(catalog_id)
 
-            # Query collections by parent_ids field using Elasticsearch directly
+            # Query collections by parent_ids field
             # This uses the parent_ids field in the collection mapping to find all
             # collections that have this catalog as a parent
-            query_body = {"query": {"term": {"parent_ids": catalog_id}}}
-
-            # Execute the search to get collection IDs
-            try:
-                search_result = await self.client.database.client.search(
-                    index=COLLECTIONS_INDEX, body=query_body
-                )
-            except Exception as e:
-                logger.error(
-                    f"Error searching for collections with parent {catalog_id}: {e}"
-                )
-                search_result = {"hits": {"hits": []}}
+            collections_data = await search_collections_by_parent_id_shared(
+                self.client.database.client, catalog_id
+            )
 
-            # Extract collection IDs from search results
-            collection_ids = []
-            hits = search_result.get("hits", {}).get("hits", [])
-            for hit in hits:
-                collection_ids.append(hit.get("_id"))
+            # Extract collection IDs from results
+            collection_ids = [coll.get("id") for coll in collections_data]
 
             # Fetch the collections
             collections = []
@@ -524,6 +602,194 @@ class CatalogsExtension(ApiExtension):
                 status_code=404, detail=f"Catalog {catalog_id} not found"
             )
 
+    async def get_catalog_catalogs(
+        self,
+        catalog_id: str,
+        request: Request,
+        limit: int = Query(10, ge=1, le=100),
+        token: Optional[str] = Query(None),
+    ) -> Catalogs:
+        """Get all sub-catalogs of a specific catalog with pagination.
+
+        Args:
+            catalog_id: The ID of the parent catalog.
+            request: Request object.
+            limit: Maximum number of results to return (default: 10, max: 100).
+            token: Pagination token for cursor-based pagination.
+
+        Returns:
+            A Catalogs response containing sub-catalogs with pagination links.
+
+        Raises:
+            HTTPException: If the catalog is not found.
+        """
+        try:
+            # Verify the catalog exists
+            await self.client.database.find_catalog(catalog_id)
+
+            # Search for sub-catalogs with pagination
+            (
+                catalogs_data,
+                total_hits,
+                next_token,
+            ) = await search_sub_catalogs_with_pagination_shared(
+                self.client.database.client, catalog_id, limit, token
+            )
+
+            # Serialize to STAC format
+            catalogs = []
+            for catalog_data in catalogs_data:
+                try:
+                    catalog = self.client.catalog_serializer.db_to_stac(
+                        catalog_data,
+                        request,
+                        extensions=[
+                            type(ext).__name__
+                            for ext in self.client.database.extensions
+                        ],
+                    )
+                    catalogs.append(catalog)
+                except Exception as e:
+                    logger.error(
+                        f"Error serializing catalog {catalog_data.get('id')}: {e}"
+                    )
+                    continue
+
+            # Generate pagination links
+            base_url = str(request.base_url)
+            links = [
+                {"rel": "root", "type": "application/json", "href": base_url},
+                {
+                    "rel": "parent",
+                    "type": "application/json",
+                    "href": f"{base_url}catalogs/{catalog_id}",
+                },
+                {
+                    "rel": "self",
+                    "type": "application/json",
+                    "href": str(request.url),
+                },
+            ]
+
+            # Add next link if more results exist
+            if next_token:
+                query_params = {"limit": limit, "token": next_token}
+                links.append(
+                    {
+                        "rel": "next",
+                        "href": f"{base_url}catalogs/{catalog_id}/catalogs?{urlencode(query_params)}",
+                        "type": "application/json",
+                        "title": "Next page",
+                    }
+                )
+
+            return {
+                "catalogs": catalogs,
+                "links": links,
+                "numberReturned": len(catalogs),
+                "numberMatched": total_hits,
+            }
+
+        except HTTPException:
+            # Re-raise HTTP exceptions as-is
+            raise
+        except Exception as e:
+            logger.error(
+                f"Error retrieving catalogs for catalog {catalog_id}: {e}",
+                exc_info=True,
+            )
+            raise HTTPException(
+                status_code=404, detail=f"Catalog {catalog_id} not found"
+            )
+
+    async def create_catalog_catalog(
+        self, catalog_id: str, catalog: Catalog, request: Request
+    ) -> Catalog:
+        """Create a new catalog or link an existing catalog as a sub-catalog.
+
+        Logic:
+        1. Verifies the parent catalog exists.
+        2. If the sub-catalog already exists: Appends the parent ID to its parent_ids
+           (enabling poly-hierarchy - a catalog can have multiple parents).
+        3. If the sub-catalog is new: Creates it with parent_ids initialized to [catalog_id].
+
+        Args:
+            catalog_id: The ID of the parent catalog.
+            catalog: The catalog to create or link.
+            request: Request object.
+
+        Returns:
+            The created or linked catalog.
+
+        Raises:
+            HTTPException: If the parent catalog is not found or operation fails.
+        """
+        try:
+            # 1. Verify the parent catalog exists
+            await self.client.database.find_catalog(catalog_id)
+
+            # 2. Check if the sub-catalog already exists
+            try:
+                existing_catalog = await self.client.database.find_catalog(catalog.id)
+
+                # --- UPDATE PATH (Existing Catalog) ---
+                # We are linking an existing catalog to a new parent (poly-hierarchy)
+
+                # Ensure parent_ids list exists
+                if "parent_ids" not in existing_catalog:
+                    existing_catalog["parent_ids"] = []
+
+                # Append if not already present
+                if catalog_id not in existing_catalog["parent_ids"]:
+                    existing_catalog["parent_ids"].append(catalog_id)
+
+                    # Persist the update
+                    await update_catalog_in_index_shared(
+                        self.client.database.client, catalog.id, existing_catalog
+                    )
+                    logger.info(
+                        f"Linked existing catalog {catalog.id} to parent {catalog_id}"
+                    )
+
+                # Return the STAC object
+                return self.client.catalog_serializer.db_to_stac(
+                    existing_catalog, request
+                )
+
+            except NotFoundError:
+                # --- CREATE PATH (New Catalog) ---
+                # Catalog does not exist, so we create it
+
+                # Convert STAC catalog to database format
+                db_catalog = self.client.catalog_serializer.stac_to_db(catalog, request)
+
+                # Convert to dict
+                db_catalog_dict = db_catalog.model_dump()
+                db_catalog_dict["type"] = "Catalog"
+
+                # Initialize parent_ids
+                db_catalog_dict["parent_ids"] = [catalog_id]
+
+                # Create in DB
+                await self.client.database.create_catalog(db_catalog_dict, refresh=True)
+                logger.info(
+                    f"Created new catalog {catalog.id} with parent {catalog_id}"
+                )
+
+                return catalog
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(
+                f"Error processing sub-catalog {catalog.id} in parent {catalog_id}: {e}",
+                exc_info=True,
+            )
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to process sub-catalog: {str(e)}",
+            )
+
     async def create_catalog_collection(
         self, catalog_id: str, collection: Collection, request: Request
     ) -> stac_types.Collection:
@@ -792,57 +1058,14 @@ class CatalogsExtension(ApiExtension):
         # 1. Verify the parent catalog exists
         await self.client.database.find_catalog(catalog_id)
 
-        # 2. Build the Search Query
-        # We search the COLLECTIONS_INDEX because it holds both Catalogs and Collections
-
-        # Base filter: Parent match
-        # This finds anything where 'parent_ids' contains this catalog_id
-        filter_queries = [{"term": {"parent_ids": catalog_id}}]
-
-        # Optional filter: Type
-        if type:
-            # If user asks for ?type=Catalog, we only return Catalogs
-            filter_queries.append({"term": {"type": type}})
-
-        # 3. Calculate Pagination (Search After)
-        body = {
-            "query": {"bool": {"filter": filter_queries}},
-            "sort": [{"id": {"order": "asc"}}],  # Stable sort for pagination
-            "size": limit,
-        }
-
-        # Handle search_after token - split by '|' to get all sort values
-        search_after: Optional[List[str]] = None
-        if token:
-            try:
-                # The token should be a pipe-separated string of sort values
-                # e.g., "collection-1"
-                from typing import cast
-
-                search_after_parts = cast(List[str], token.split("|"))
-                # If the number of sort fields doesn't match token parts, ignore the token
-                if len(search_after_parts) != len(body["sort"]):  # type: ignore
-                    search_after = None
-                else:
-                    search_after = search_after_parts
-            except Exception:
-                search_after = None
-
-            if search_after is not None:
-                body["search_after"] = search_after
-
-        # 4. Execute Search
-        search_result = await self.client.database.client.search(
-            index=COLLECTIONS_INDEX, body=body
+        # 2. Search for children with pagination
+        children_data, total, next_token = await search_children_with_pagination_shared(
+            self.client.database.client, catalog_id, limit, token, type
         )
 
-        # 5. Process Results
-        hits = search_result.get("hits", {}).get("hits", [])
-        total = search_result.get("hits", {}).get("total", {}).get("value", 0)
-
+        # 3. Serialize children based on type
         children = []
-        for hit in hits:
-            doc = hit["_source"]
+        for doc in children_data:
             resource_type = doc.get(
                 "type", "Collection"
             )  # Default to Collection if missing
@@ -856,7 +1079,7 @@ class CatalogsExtension(ApiExtension):
 
             children.append(child)
 
-        # 6. Format Response
+        # 4. Format Response
         # The Children extension uses a specific response format
         response = {
             "children": children,
@@ -877,14 +1100,7 @@ class CatalogsExtension(ApiExtension):
             "numberMatched": total,
         }
 
-        # 7. Generate Next Link
-        next_token = None
-        if len(hits) == limit:
-            next_token_values = hits[-1].get("sort")
-            if next_token_values:
-                # Join all sort values with '|' to create the token
-                next_token = "|".join(str(val) for val in next_token_values)
-
+        # 5. Generate Next Link
         if next_token:
             # Get existing query params
             parsed_url = urlparse(str(request.url))

stac_fastapi/core/serializers.py

@@ -355,6 +355,9 @@ class CatalogSerializer(Serializer):
         # Avoid modifying the input dict in-place
         catalog = deepcopy(catalog)
 
+        # Remove internal fields (not part of STAC spec)
+        catalog.pop("parent_ids", None)
+
         # Set defaults
         catalog.setdefault("type", "Catalog")
         catalog.setdefault("stac_extensions", [])

stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "6.9.0"
+__version__ = "6.10.0"

{stac_fastapi_core-6.9.0.dist-info → stac_fastapi_core-6.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.9.0
+Version: 6.10.0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT

{stac_fastapi_core-6.9.0.dist-info → stac_fastapi_core-6.10.0.dist-info}/RECORD

@@ -2,19 +2,19 @@ stac_fastapi/core/__init__.py,sha256=8izV3IWRGdXmDOK1hIPQAanbWs9EI04PJCGgqG1ZGIs
 stac_fastapi/core/base_database_logic.py,sha256=JL7DRcDdqeaLbSPPGcIUMs7q6I3Gm_E5XCOwFG458Io,6053
 stac_fastapi/core/base_settings.py,sha256=R3_Sx7n5XpGMs3zAwFJD7y008WvGU_uI2xkaabm82Kg,239
 stac_fastapi/core/basic_auth.py,sha256=RhFv3RVSHF6OaqnaaU2DO4ncJ_S5nB1q8UNpnVJJsrk,2155
-stac_fastapi/core/core.py,sha256=LTUF1253Bq-E9G9oaK3cPgou7Mk4iemHkS7hDVgwSow,52244
+stac_fastapi/core/core.py,sha256=OKgezb8kEaB10aeNpov4xxHabM7_5ABl3wD6VaVdChE,52300
 stac_fastapi/core/datetime_utils.py,sha256=QygF2mJFfI_zqCwmSIec3HYqrsVsn3nUcaRQx3CD7Zw,4683
 stac_fastapi/core/queryables.py,sha256=0gKdxlmCVaIj3ODpmyIfzLChEB1nNKXPZhA3K9ApfL0,3755
 stac_fastapi/core/rate_limit.py,sha256=Gu8dAaJReGsj1L91U6m2tflU6RahpXDRs2-AYSKoybA,1318
 stac_fastapi/core/redis_utils.py,sha256=xqZfXwrZ0Wei6EDereOygW_Aq6DBDykhQYD86Ws9P28,9706
 stac_fastapi/core/route_dependencies.py,sha256=hdtuMkv-zY1vg0YxiCz1aKP0SbBcORqDGEKDGgEazW8,5482
-stac_fastapi/core/serializers.py,sha256=l5EWZvlGjlfsZ3S4wHjWKD8sJBf83zd2dkursu18fV4,13345
+stac_fastapi/core/serializers.py,sha256=r9BhjoAWH5Kg6ypEugPZcJ7tPaFx8vWaMJkfoPW5Fdw,13443
 stac_fastapi/core/session.py,sha256=aXqu4LXfVbAAsChMVXd9gAhczA2bZPne6HqPeklAwMY,474
 stac_fastapi/core/utilities.py,sha256=B-tLc_H_v92q8ZNpzk-9nKQMKe-bVHUk64HpybGqYX0,10398
-stac_fastapi/core/version.py,sha256=Zec8murh7xqMR7l6fB74XJcq2QdyNqRgOdhLMwBYPAI,45
+stac_fastapi/core/version.py,sha256=bQiD_D-FuZl4YJZxrz9LK-THtzxnF7e-QdjJAiGBoSY,46
 stac_fastapi/core/extensions/__init__.py,sha256=oaK-UJDQSEISdQ8VtM0ESxpsv7Hx1HbAdmMnh6MTFD4,356
 stac_fastapi/core/extensions/aggregation.py,sha256=v1hUHqlYuMqfQ554g3cTp16pUyRYucQxPERbHPAFtf8,1878
-stac_fastapi/core/extensions/catalogs.py,sha256=iOMmPdY0vhGx9QkIMEaLbEaCLvGY2iyg6U07Gdpjejc,38000
+stac_fastapi/core/extensions/catalogs.py,sha256=JR9ireabml5zCcWVM1FPIWZjb87Ffnk81MQm8cnUi6I,45668
 stac_fastapi/core/extensions/collections_search.py,sha256=ZxCRQ5jyhrg6zDs037qLDzCz0T3tq3a9_lXfYQ9GweQ,14546
 stac_fastapi/core/extensions/fields.py,sha256=NCT5XHvfaf297eDPNaIFsIzvJnbbUTpScqF0otdx0NA,1066
 stac_fastapi/core/extensions/filter.py,sha256=-NQGME7rR_ereuDx-LAa1M5JhEXFaKiTtkH2asraYHE,2998
@@ -22,6 +22,6 @@ stac_fastapi/core/extensions/query.py,sha256=Xmo8pfZEZKPudZEjjozv3R0wLOP0ayjC9E6
 stac_fastapi/core/models/__init__.py,sha256=sUsEB7umGZVYXjT4EHqLwm8p2wevtRBdig2Ioj2ZdVQ,631
 stac_fastapi/core/models/links.py,sha256=5KEZKisFN34U4UuOzSQnDy0QdsUOT2VRuuY36vs-FGw,7074
 stac_fastapi/core/models/search.py,sha256=7SgAUyzHGXBXSqB4G6cwq9FMwoAS00momb7jvBkjyow,27
-stac_fastapi_core-6.9.0.dist-info/METADATA,sha256=4ot6ylGlLz67tpQZ5VPxAbw2kOC1O_VCAzGXZ2dQ39U,3480
-stac_fastapi_core-6.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-stac_fastapi_core-6.9.0.dist-info/RECORD,,
+stac_fastapi_core-6.10.0.dist-info/METADATA,sha256=DQkAL0txwG2gljAhY5jwcijSO-PIFXprbmD_SkwIVLU,3481
+stac_fastapi_core-6.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+stac_fastapi_core-6.10.0.dist-info/RECORD,,