delete catalog

Author: jonhealy1

README.md

@@ -248,6 +248,7 @@ This implementation follows the [STAC API Catalogs Extension](https://github.com
 - **GET `/catalogs`**: Retrieve the root catalog and its child catalogs
 - **POST `/catalogs`**: Create a new catalog (requires appropriate permissions)
 - **GET `/catalogs/{catalog_id}`**: Retrieve a specific catalog and its children
+- **DELETE `/catalogs/{catalog_id}`**: Delete a catalog (optionally cascade delete all collections)
 - **GET `/catalogs/{catalog_id}/collections`**: Retrieve collections within a specific catalog
 - **POST `/catalogs/{catalog_id}/collections`**: Create a new collection within a specific catalog
 - **GET `/catalogs/{catalog_id}/collections/{collection_id}`**: Retrieve a specific collection within a catalog
@@ -290,8 +291,22 @@ curl "http://localhost:8081/catalogs/earth-observation/collections/sentinel-2/it
 
 # Get specific item within a catalog
 curl "http://localhost:8081/catalogs/earth-observation/collections/sentinel-2/items/S2A_20231015_123456"
+
+# Delete a catalog (collections remain intact)
+curl -X DELETE "http://localhost:8081/catalogs/earth-observation"
+
+# Delete a catalog and all its collections (cascade delete)
+curl -X DELETE "http://localhost:8081/catalogs/earth-observation?cascade=true"
 ```
 
+### Delete Catalog Parameters
+
+The DELETE endpoint supports the following query parameter:
+
+- **`cascade`** (boolean, default: `false`): 
+  - If `false`: Only deletes the catalog. Collections linked to the catalog remain in the database but lose their catalog link.
+  - If `true`: Deletes the catalog AND all collections linked to it. Use with caution as this is a destructive operation.
+
 ### Response Structure
 
 Catalog responses include:

stac_fastapi/core/stac_fastapi/core/extensions/catalogs.py

@@ -116,6 +116,18 @@ def register(self, app: FastAPI, settings=None) -> None:
             tags=["Catalogs"],
         )
 
+        # Add endpoint for deleting a catalog
+        self.router.add_api_route(
+            path="/catalogs/{catalog_id}",
+            endpoint=self.delete_catalog,
+            methods=["DELETE"],
+            response_class=self.response_class,
+            status_code=204,
+            summary="Delete Catalog",
+            description="Delete a catalog. Optionally cascade delete all collections in the catalog.",
+            tags=["Catalogs"],
+        )
+
         # Add endpoint for getting a specific collection in a catalog
         self.router.add_api_route(
             path="/catalogs/{catalog_id}/collections/{collection_id}",
@@ -266,6 +278,93 @@ async def get_catalog(self, catalog_id: str, request: Request) -> Catalog:
                 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.
+
+        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)
+
+        Raises:
+            HTTPException: If the catalog is not found.
+        """
+        try:
+            # Get the catalog to verify it exists and get its collections
+            db_catalog = await self.client.database.find_catalog(catalog_id)
+            catalog = self.client.catalog_serializer.db_to_stac(db_catalog, request)
+
+            # If cascade is true, delete all collections linked to this catalog
+            if cascade:
+                # Extract collection IDs from catalog links
+                collection_ids = []
+                if hasattr(catalog, "links") and catalog.links:
+                    for link in catalog.links:
+                        rel = (
+                            link.get("rel")
+                            if hasattr(link, "get")
+                            else getattr(link, "rel", None)
+                        )
+                        if rel == "child":
+                            href = (
+                                link.get("href", "")
+                                if hasattr(link, "get")
+                                else getattr(link, "href", "")
+                            )
+                            if href and "/collections/" in href:
+                                # Extract collection ID from href
+                                collection_id = href.split("/collections/")[-1].split(
+                                    "/"
+                                )[0]
+                                if collection_id:
+                                    collection_ids.append(collection_id)
+
+                # Delete each collection
+                for coll_id in collection_ids:
+                    try:
+                        await self.client.database.delete_collection(coll_id)
+                        logger.info(
+                            f"Deleted collection {coll_id} as part of cascade delete for catalog {catalog_id}"
+                        )
+                    except Exception as e:
+                        error_msg = str(e)
+                        if "not found" in error_msg.lower():
+                            logger.debug(
+                                f"Collection {coll_id} not found, skipping (may have been deleted elsewhere)"
+                            )
+                        else:
+                            logger.warning(
+                                f"Failed to delete collection {coll_id}: {e}"
+                            )
+
+            # Delete the catalog
+            await self.client.database.delete_catalog(catalog_id)
+            logger.info(f"Deleted catalog {catalog_id}")
+
+        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 deleting catalog {catalog_id}: {e}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to delete catalog: {str(e)}",
+            )
+
     async def get_catalog_collections(
         self, catalog_id: str, request: Request
     ) -> stac_types.Collections:

stac_fastapi/tests/extensions/test_catalogs.py

@@ -476,3 +476,110 @@ async def test_create_catalog_collection_nonexistent_catalog(
         "/catalogs/nonexistent-catalog/collections", json=test_collection
     )
     assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_catalog(catalogs_app_client, load_test_data):
+    """Test deleting a catalog without cascade."""
+    # Create a catalog
+    test_catalog = load_test_data("test_catalog.json")
+    test_catalog["id"] = f"test-catalog-{uuid.uuid4()}"
+    test_catalog["links"] = [
+        link for link in test_catalog.get("links", []) if link.get("rel") != "child"
+    ]
+
+    create_resp = await catalogs_app_client.post("/catalogs", json=test_catalog)
+    assert create_resp.status_code == 201
+    catalog_id = test_catalog["id"]
+
+    # Verify catalog exists
+    get_resp = await catalogs_app_client.get(f"/catalogs/{catalog_id}")
+    assert get_resp.status_code == 200
+
+    # Delete the catalog
+    delete_resp = await catalogs_app_client.delete(f"/catalogs/{catalog_id}")
+    assert delete_resp.status_code == 204
+
+    # Verify catalog is deleted
+    get_resp = await catalogs_app_client.get(f"/catalogs/{catalog_id}")
+    assert get_resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_catalog_cascade(catalogs_app_client, load_test_data):
+    """Test deleting a catalog with cascade delete of collections."""
+    # Create a catalog
+    test_catalog = load_test_data("test_catalog.json")
+    test_catalog["id"] = f"test-catalog-{uuid.uuid4()}"
+    test_catalog["links"] = [
+        link for link in test_catalog.get("links", []) if link.get("rel") != "child"
+    ]
+
+    create_resp = await catalogs_app_client.post("/catalogs", json=test_catalog)
+    assert create_resp.status_code == 201
+    catalog_id = test_catalog["id"]
+
+    # Create a collection in the catalog
+    test_collection = load_test_data("test_collection.json")
+    test_collection["id"] = f"test-collection-{uuid.uuid4()}"
+
+    coll_resp = await catalogs_app_client.post(
+        f"/catalogs/{catalog_id}/collections", json=test_collection
+    )
+    assert coll_resp.status_code == 201
+    collection_id = test_collection["id"]
+
+    # Verify collection exists
+    get_coll_resp = await catalogs_app_client.get(f"/collections/{collection_id}")
+    assert get_coll_resp.status_code == 200
+
+    # Delete the catalog with cascade=true
+    delete_resp = await catalogs_app_client.delete(
+        f"/catalogs/{catalog_id}?cascade=true"
+    )
+    assert delete_resp.status_code == 204
+
+    # Verify catalog is deleted
+    get_resp = await catalogs_app_client.get(f"/catalogs/{catalog_id}")
+    assert get_resp.status_code == 404
+
+    # Verify collection is also deleted (cascade delete)
+    get_coll_resp = await catalogs_app_client.get(f"/collections/{collection_id}")
+    assert get_coll_resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_catalog_no_cascade(catalogs_app_client, load_test_data):
+    """Test deleting a catalog without cascade (collections remain)."""
+    # Create a catalog
+    test_catalog = load_test_data("test_catalog.json")
+    test_catalog["id"] = f"test-catalog-{uuid.uuid4()}"
+    test_catalog["links"] = [
+        link for link in test_catalog.get("links", []) if link.get("rel") != "child"
+    ]
+
+    create_resp = await catalogs_app_client.post("/catalogs", json=test_catalog)
+    assert create_resp.status_code == 201
+    catalog_id = test_catalog["id"]
+
+    # Create a collection in the catalog
+    test_collection = load_test_data("test_collection.json")
+    test_collection["id"] = f"test-collection-{uuid.uuid4()}"
+
+    coll_resp = await catalogs_app_client.post(
+        f"/catalogs/{catalog_id}/collections", json=test_collection
+    )
+    assert coll_resp.status_code == 201
+    collection_id = test_collection["id"]
+
+    # Delete the catalog with cascade=false (default)
+    delete_resp = await catalogs_app_client.delete(f"/catalogs/{catalog_id}")
+    assert delete_resp.status_code == 204
+
+    # Verify catalog is deleted
+    get_resp = await catalogs_app_client.get(f"/catalogs/{catalog_id}")
+    assert get_resp.status_code == 404
+
+    # Verify collection still exists (no cascade delete)
+    get_coll_resp = await catalogs_app_client.get(f"/collections/{collection_id}")
+    assert get_coll_resp.status_code == 200