stac-fastapi-core 6.8.0__tar.gz → 6.9.0__tar.gz

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.8.0
+Version: 6.9.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.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/core.py

@@ -315,7 +315,7 @@ class CoreClient(AsyncBaseCoreClient):
 
         body_limit = None
         try:
-            if request.method == "POST" and request.body():
+            if request.method == "POST" and await request.body():
                 body_data = await request.json()
                 body_limit = body_data.get("limit")
         except Exception:

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/extensions/catalogs.py

@@ -56,6 +56,7 @@ class CatalogsExtension(ApiExtension):
             settings: extension settings (unused for now).
         """
         self.settings = settings or {}
+        self.router = APIRouter()
 
         self.router.add_api_route(
             path="/catalogs",
@@ -126,7 +127,7 @@ class CatalogsExtension(ApiExtension):
             response_class=self.response_class,
             status_code=204,
             summary="Delete Catalog",
-            description="Delete a catalog. Optionally cascade delete all collections in the catalog.",
+            description="Delete a catalog. All linked collections are unlinked and adopted by root if orphaned.",
             tags=["Catalogs"],
         )
 
@@ -337,22 +338,21 @@ class CatalogsExtension(ApiExtension):
                 status_code=404, detail=f"Catalog {catalog_id} not found"
             )
 
-    async def delete_catalog(
-        self,
-        catalog_id: str,
-        request: Request,
-        cascade: bool = Query(
-            False,
-            description="If true, delete all collections linked to this catalog. If false, only delete the catalog.",
-        ),
-    ) -> None:
-        """Delete a catalog.
+    async def delete_catalog(self, catalog_id: str, request: Request) -> None:
+        """Delete a catalog (The Container).
+
+        Deletes the Catalog document itself. All linked Collections are unlinked
+        and adopted by Root if they become orphans. Collection data is NEVER deleted.
+
+        Logic:
+        1. Finds all Collections linked to this Catalog.
+        2. Unlinks them (removes catalog_id from their parent_ids).
+        3. If a Collection becomes an orphan, it is adopted by Root.
+        4. PERMANENTLY DELETES the Catalog document itself.
 
         Args:
             catalog_id: The ID of the catalog to delete.
             request: Request object.
-            cascade: If true, delete all collections linked to this catalog.
-                    If false, only delete the catalog.
 
         Returns:
             None (204 No Content)
@@ -361,58 +361,42 @@ class CatalogsExtension(ApiExtension):
             HTTPException: If the catalog is not found.
         """
         try:
-            # Get the catalog to verify it exists
+            # Verify the catalog exists
             await self.client.database.find_catalog(catalog_id)
 
-            # Use reverse lookup query to find all collections with this catalog in parent_ids.
-            # This is more reliable than parsing links, as it captures all collections
-            # regardless of pagination or link truncation.
-            query_body = {"query": {"term": {"parent_ids": 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, size=10000
+                index=COLLECTIONS_INDEX, body=query_body
             )
             children = [hit["_source"] for hit in search_result["hits"]["hits"]]
 
-            # Process each child collection
+            # Safe Unlink: Remove catalog from all children's parent_ids
+            # If a child becomes an orphan, adopt it to root
+            root_id = self.settings.get("STAC_FASTAPI_LANDING_PAGE_ID", "stac-fastapi")
+
             for child in children:
                 child_id = child.get("id")
                 try:
-                    if cascade:
-                        # DANGER ZONE: User explicitly requested cascade delete.
-                        # Delete the collection entirely, regardless of other parents.
-                        await self.client.database.delete_collection(child_id)
-                        logger.info(
-                            f"Deleted collection {child_id} as part of cascade delete for catalog {catalog_id}"
-                        )
-                    else:
-                        # SAFE ZONE: Smart Unlink - Remove only this catalog from parent_ids.
-                        # The collection survives and becomes a root-level collection if it has no other parents.
-                        parent_ids = child.get("parent_ids", [])
-                        if catalog_id in parent_ids:
-                            parent_ids.remove(catalog_id)
-                            child["parent_ids"] = parent_ids
-
-                            # Update the collection in the database
-                            # Note: Catalog links are now dynamically generated, so no need to remove them
-                            await self.client.database.update_collection(
-                                collection_id=child_id,
-                                collection=child,
-                                refresh=False,
+                    parent_ids = child.get("parent_ids", [])
+                    if catalog_id in parent_ids:
+                        parent_ids.remove(catalog_id)
+
+                        # If orphan, move to root
+                        if len(parent_ids) == 0:
+                            parent_ids.append(root_id)
+                            logger.info(
+                                f"Collection {child_id} adopted by root after catalog deletion."
                             )
-
-                            # Log the result
-                            if len(parent_ids) == 0:
-                                logger.info(
-                                    f"Collection {child_id} is now a root-level orphan (no parent catalogs)"
-                                )
-                            else:
-                                logger.info(
-                                    f"Removed catalog {catalog_id} from collection {child_id}; still belongs to {len(parent_ids)} other catalog(s)"
-                                )
                         else:
-                            logger.debug(
-                                f"Catalog {catalog_id} not in parent_ids for collection {child_id}"
+                            logger.info(
+                                f"Removed catalog {catalog_id} from collection {child_id}; still belongs to {len(parent_ids)} other catalog(s)"
                             )
+
+                        child["parent_ids"] = parent_ids
+                        await self.client.database.update_collection(
+                            collection_id=child_id, collection=child, refresh=False
+                        )
                 except Exception as e:
                     error_msg = str(e)
                     if "not found" in error_msg.lower():
@@ -929,11 +913,11 @@ class CatalogsExtension(ApiExtension):
     async def delete_catalog_collection(
         self, catalog_id: str, collection_id: str, request: Request
     ) -> None:
-        """Delete a collection from a catalog.
+        """Delete a collection from a catalog (Unlink only).
 
-        If the collection has multiple parent catalogs, only removes this catalog
-        from the parent_ids. If this is the only parent catalog, deletes the
-        collection entirely.
+        Removes the catalog from the collection's parent_ids.
+        If the collection becomes an orphan (no parents), it is adopted by the Root.
+        It NEVER deletes the collection data.
 
         Args:
             catalog_id: The ID of the catalog.
@@ -959,37 +943,39 @@ class CatalogsExtension(ApiExtension):
                     detail=f"Collection {collection_id} does not belong to catalog {catalog_id}",
                 )
 
-            # If the collection has multiple parents, just remove this catalog from parent_ids
-            if len(parent_ids) > 1:
-                parent_ids.remove(catalog_id)
-                collection_db["parent_ids"] = parent_ids
+            # SAFE UNLINK LOGIC
+            parent_ids.remove(catalog_id)
 
-                # Update the collection in the database
-                # Note: Catalog links are now dynamically generated, so no need to remove them
-                await self.client.database.update_collection(
-                    collection_id=collection_id, collection=collection_db, refresh=True
+            # Check if it is now an orphan (empty list)
+            if len(parent_ids) == 0:
+                # Fallback to Root / Landing Page
+                # You can hardcode 'root' or fetch the ID from settings
+                root_id = self.settings.get(
+                    "STAC_FASTAPI_LANDING_PAGE_ID", "stac-fastapi"
                 )
-
+                parent_ids.append(root_id)
                 logger.info(
-                    f"Removed catalog {catalog_id} from collection {collection_id} parent_ids"
+                    f"Collection {collection_id} unlinked from {catalog_id}. Orphaned, so adopted by root ({root_id})."
                 )
             else:
-                # If this is the only parent, delete the collection entirely
-                await self.client.database.delete_collection(
-                    collection_id, refresh=True
-                )
                 logger.info(
-                    f"Deleted collection {collection_id} (only parent was catalog {catalog_id})"
+                    f"Removed catalog {catalog_id} from collection {collection_id}; still belongs to {len(parent_ids)} other catalog(s)"
                 )
 
+            # Update the collection in the database
+            collection_db["parent_ids"] = parent_ids
+            await self.client.database.update_collection(
+                collection_id=collection_id, collection=collection_db, refresh=True
+            )
+
         except HTTPException:
             raise
         except Exception as e:
             logger.error(
-                f"Error deleting collection {collection_id} from catalog {catalog_id}: {e}",
+                f"Error removing collection {collection_id} from catalog {catalog_id}: {e}",
                 exc_info=True,
             )
             raise HTTPException(
                 status_code=500,
-                detail=f"Failed to delete collection from catalog: {str(e)}",
+                detail=f"Failed to remove collection from catalog: {str(e)}",
             )

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/extensions/collections_search.py

@@ -38,7 +38,7 @@ def build_get_collections_search_doc(original_endpoint):
         query: Optional[str] = Query(
             None,
             description="Additional filtering expressed as a string (legacy support)",
-            example="platform=landsat AND collection_category=level2",
+            examples=["platform=landsat AND collection_category=level2"],
         ),
         limit: int = Query(
             10,
@@ -83,14 +83,16 @@ def build_get_collections_search_doc(original_endpoint):
             description=(
                 "Structured filter expression in CQL2 JSON or CQL2-text format"
             ),
-            example='{"op": "=", "args": [{"property": "properties.category"}, "level2"]}',
+            examples=[
+                '{"op": "=", "args": [{"property": "properties.category"}, "level2"]}'
+            ],
         ),
         filter_lang: Optional[str] = Query(
             None,
             description=(
                 "Filter language. Must be 'cql2-json' or 'cql2-text' if specified"
             ),
-            example="cql2-json",
+            examples=["cql2-json"],
         ),
     ):
         # Delegate to original endpoint with parameters
@@ -160,24 +162,26 @@ def build_post_collections_search_doc(original_post_endpoint):
                 "- `sortby`: List of sort criteria objects with 'field' and 'direction' (asc/desc)\n"
                 "- `fields`: Object with 'include' and 'exclude' arrays for field selection"
             ),
-            example={
-                "q": "landsat",
-                "query": "platform=landsat AND collection_category=level2",
-                "filter": {
-                    "op": "=",
-                    "args": [{"property": "properties.category"}, "level2"],
-                },
-                "filter_lang": "cql2-json",
-                "limit": 10,
-                "token": "next-page-token",
-                "bbox": [-180, -90, 180, 90],
-                "datetime": "2020-01-01T00:00:00Z/2021-01-01T12:31:12Z",
-                "sortby": [{"field": "id", "direction": "asc"}],
-                "fields": {
-                    "include": ["id", "title", "description"],
-                    "exclude": ["properties"],
-                },
-            },
+            examples=[
+                {
+                    "q": "landsat",
+                    "query": "platform=landsat AND collection_category=level2",
+                    "filter": {
+                        "op": "=",
+                        "args": [{"property": "properties.category"}, "level2"],
+                    },
+                    "filter_lang": "cql2-json",
+                    "limit": 10,
+                    "token": "next-page-token",
+                    "bbox": [-180, -90, 180, 90],
+                    "datetime": "2020-01-01T00:00:00Z/2021-01-01T12:31:12Z",
+                    "sortby": [{"field": "id", "direction": "asc"}],
+                    "fields": {
+                        "include": ["id", "title", "description"],
+                        "exclude": ["properties"],
+                    },
+                }
+            ],
         ),
     ) -> Union[Collections, Response]:
         return await original_post_endpoint(request, body)

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/redis_utils.py

@@ -292,4 +292,4 @@ async def redis_pagination_links(
     except Exception as e:
         logger.warning(f"Redis pagination operation failed: {e}")
     finally:
-        await redis.close()
+        await redis.aclose()  # type: ignore

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/utilities.py

@@ -6,6 +6,7 @@ such as converting bounding boxes to polygon representations.
 
 import logging
 import os
+import re
 from typing import Any, Dict, List, Optional, Set, Union
 
 from stac_fastapi.types.stac import Item
@@ -70,8 +71,6 @@ def bbox2polygon(b0: float, b1: float, b2: float, b3: float) -> List[List[List[f
     return [[[b0, b1], [b2, b1], [b2, b3], [b0, b3], [b0, b1]]]
 
 
-# copied from stac-fastapi-pgstac
-# https://github.com/stac-utils/stac-fastapi-pgstac/blob/26f6d918eb933a90833f30e69e21ba3b4e8a7151/stac_fastapi/pgstac/utils.py#L10-L116
 def filter_fields(  # noqa: C901
     item: Union[Item, Dict[str, Any]],
     include: Optional[Set[str]] = None,
@@ -87,15 +86,60 @@ def filter_fields(  # noqa: C901
     if not include and not exclude:
         return item
 
-    # Build a shallow copy of included fields on an item, or a sub-tree of an item
+    def match_pattern(pattern: str, key: str) -> bool:
+        """Check if a key matches a wildcard pattern."""
+        regex_pattern = "^" + re.escape(pattern).replace(r"\*", ".*") + "$"
+        return bool(re.match(regex_pattern, key))
+
+    def get_matching_keys(source: Dict[str, Any], pattern: str) -> List[str]:
+        """Get all keys that match the pattern."""
+        if not isinstance(source, dict):
+            return []
+        return [key for key in source.keys() if match_pattern(pattern, key)]
+
     def include_fields(
         source: Dict[str, Any], fields: Optional[Set[str]]
     ) -> Dict[str, Any]:
+        """Include only the specified fields from the source dictionary."""
         if not fields:
             return source
 
+        def recursive_include(
+            source: Dict[str, Any], path_parts: List[str]
+        ) -> Dict[str, Any]:
+            """Recursively include fields matching the pattern path."""
+            if not path_parts:
+                return source
+
+            if not isinstance(source, dict):
+                return {}
+
+            current_pattern = path_parts[0]
+            remaining_parts = path_parts[1:]
+
+            matching_keys = get_matching_keys(source, current_pattern)
+
+            if not matching_keys:
+                return {}
+
+            result: Dict[str, Any] = {}
+            for key in matching_keys:
+                if remaining_parts:
+                    if isinstance(source[key], dict):
+                        value = recursive_include(source[key], remaining_parts)
+                        if value:
+                            result[key] = value
+                else:
+                    result[key] = source[key]
+
+            return result
+
         clean_item: Dict[str, Any] = {}
         for key_path in fields or []:
+            if "*" in key_path:
+                value = recursive_include(source, key_path.split("."))
+                dict_deep_update(clean_item, value)
+                continue
             key_path_parts = key_path.split(".")
             key_root = key_path_parts[0]
             if key_root in source:
@@ -125,12 +169,46 @@ def filter_fields(  # noqa: C901
                 # The key, or root key of a multi-part key, is not present in the item,
                 # so it is ignored
                 pass
+
         return clean_item
 
-    # For an item built up for included fields, remove excluded fields. This
-    # modifies `source` in place.
-    def exclude_fields(source: Dict[str, Any], fields: Optional[Set[str]]) -> None:
+    def exclude_fields(
+        source: Dict[str, Any],
+        fields: Optional[Set[str]],
+    ) -> None:
+        """Exclude fields from source."""
+
+        def recursive_exclude(
+            source: Dict[str, Any], path_parts: List[str], current_path: str = ""
+        ) -> None:
+            """Recursively exclude fields matching the pattern path."""
+            if not path_parts or not isinstance(source, dict):
+                return
+
+            current_pattern = path_parts[0]
+            remaining_parts = path_parts[1:]
+
+            matching_keys = get_matching_keys(source, current_pattern)
+
+            for key in list(matching_keys):
+                if key not in source:
+                    continue
+
+                # Build the full path for this key
+                full_path = f"{current_path}.{key}" if current_path else key
+
+                if remaining_parts:
+                    if isinstance(source[key], dict):
+                        recursive_exclude(source[key], remaining_parts, full_path)
+                        if not source[key]:
+                            del source[key]
+                else:
+                    source.pop(key, None)
+
         for key_path in fields or []:
+            if "*" in key_path:
+                recursive_exclude(source, key_path.split("."))
+                continue
             key_path_part = key_path.split(".")
             key_root = key_path_part[0]
             if key_root in source:

{stac_fastapi_core-6.8.0 → stac_fastapi_core-6.9.0}/stac_fastapi/core/version.py

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