stac-fastapi-core 6.8.1__tar.gz → 6.10.0__tar.gz

{stac_fastapi_core-6.8.1 → stac_fastapi_core-6.10.0}/.gitignore

@@ -141,3 +141,14 @@ venv
 /docs/src/api/*
 
 .DS_Store
+
+# Helm
+*.tgz
+charts/*/charts/
+charts/*/requirements.lock
+charts/*/Chart.lock
+helm-chart/stac-fastapi/charts/
+helm-chart/stac-fastapi/Chart.lock
+helm-chart/stac-fastapi/*.tgz
+helm-chart/test-results/
+helm-chart/tmp/

{stac_fastapi_core-6.8.1 → stac_fastapi_core-6.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.8.1
+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.8.1 → stac_fastapi_core-6.10.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:
@@ -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-6.8.1 → stac_fastapi_core-6.10.0}/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__)
@@ -56,6 +62,7 @@ class CatalogsExtension(ApiExtension):
             settings: extension settings (unused for now).
         """
         self.settings = settings or {}
+        self.router = APIRouter()
 
         self.router.add_api_route(
             path="/catalogs",
@@ -105,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",
@@ -118,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}",
@@ -280,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.
 
@@ -364,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}}}
-            search_result = await self.client.database.client.search(
-                index=COLLECTIONS_INDEX, body=query_body, size=10000
+            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
@@ -439,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 = []
@@ -523,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:
@@ -791,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
@@ -855,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,
@@ -876,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-6.8.1 → stac_fastapi_core-6.10.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.1 → stac_fastapi_core-6.10.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.1 → stac_fastapi_core-6.10.0}/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-6.8.1 → stac_fastapi_core-6.10.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.1 → stac_fastapi_core-6.10.0}/stac_fastapi/core/version.py

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