FEAT: add script that deletes a specified support from the DB (#108)

Co-authored-by: Yoom Lam <yoom@navapbc.com>

Author: michelle-hadfield-nava

app/Makefile

@@ -241,13 +241,15 @@ add-crawl-jobs:
 	make manage-crawl-job ACTION="upsert" PROMPT_NAME="crawl_indeed" DOMAIN="indeed.com" INTERVAL=6
 	make manage-crawl-job ACTION="upsert" PROMPT_NAME="crawl_gcta" DOMAIN="gctatraining.org" INTERVAL=6
 
+# Usage: make delete-support NAME="Support or SupportListing Name"
+delete-support:
+	$(PY_RUN_CMD) delete-support "$(NAME)"
+
 process-crawl-jobs:
 	$(PY_RUN_CMD) process-crawl-jobs
 
 copy-prompts:
 	$(PY_RUN_CMD) copy-prompts
 
-
-
 run-experiment:
 	$(PY_RUN_CMD) run-experiment "$(DATASET)" "$(PIPELINE)" "$(ACTION)" $(if $(PROMPT_VERSION),--prompt_version "$(PROMPT_VERSION)")

app/pyproject.toml

@@ -72,6 +72,7 @@ copy-prompts= "src.common.phoenix_utils:copy_deployed_prompts"
 run-experiment= "src.experiments:main"
 manage-crawl-job= "src.db.manage_crawl_job:main"
 process-crawl-jobs= "src.ingestion.process_crawl_jobs:main"
+delete-support= "src.db.delete_support:main"
 
 [tool.black]
 line-length = 100

app/src/db/delete_support.py

@@ -0,0 +1,87 @@
+"""Delete Support entries and their related SupportListing from the database."""
+
+import argparse
+import logging
+import sys
+
+from sqlalchemy.orm import Session
+
+from src.app_config import config
+from src.db.models.support_listing import Support
+
+logger = logging.getLogger(__name__)
+
+
+def delete_support_by_name(db_session: Session, support_name: str) -> bool:
+    """Delete a Support entry by name and its related SupportListing if no other supports remain.
+
+    Args:
+        db_session: Database session
+        support_name: Name of the support to delete
+
+    Returns:
+        True if the support was found and deleted, False otherwise
+    """
+    # Find the support by name
+    support = db_session.query(Support).where(Support.name == support_name).one_or_none()
+
+    if not support:
+        logger.error("Support with name '%s' not found", support_name)
+        return False
+
+    # Get the associated SupportListing before deleting the support
+    support_listing = support.support_listing
+
+    logger.info("Found Support (id=%s, name='%s')", support.id, support.name)
+    logger.info(
+        "Associated with SupportListing (id=%s, name='%s')",
+        support_listing.id,
+        support_listing.name,
+    )
+
+    # Delete the support
+    db_session.delete(support)
+    db_session.flush()
+    logger.info("Deleted Support '%s'", support_name)
+
+    # Check if the SupportListing has any remaining supports
+    remaining_supports_count = (
+        db_session.query(Support).where(Support.support_listing_id == support_listing.id).count()
+    )
+
+    if remaining_supports_count == 0:
+        logger.info(
+            "No remaining supports for SupportListing '%s', deleting it as well",
+            support_listing.name,
+        )
+        db_session.delete(support_listing)
+        logger.info("Deleted SupportListing '%s'", support_listing.name)
+    else:
+        logger.info(
+            "SupportListing '%s' has %d remaining support(s), keeping it",
+            support_listing.name,
+            remaining_supports_count,
+        )
+
+    return True
+
+
+def main() -> None:  # pragma: no cover
+    logging.basicConfig(format="%(levelname)s - %(name)s - %(message)s", level=logging.INFO)
+
+    parser = argparse.ArgumentParser(description="Delete a Support or SupportListing entry by name")
+    parser.add_argument("name", help="Name of the support or support listing to delete")
+
+    args = parser.parse_args()
+
+    with config.db_session() as db_session, db_session.begin():
+        success = delete_support_by_name(db_session, args.name)
+
+    if not success:
+        sys.exit(1)
+
+    logger.info("Done")
+
+
+if __name__ == "__main__":
+    main()

app/tests/src/db/test_delete_support.py

@@ -0,0 +1,80 @@
+"""Tests for delete_support module."""
+import logging
+
+import pytest
+
+from src.db.delete_support import delete_support_by_name
+from src.db.models.support_listing import Support, SupportListing
+from tests.src.db.models import factories
+
+
+@pytest.fixture
+def caplog_info(caplog):
+    """Configure caplog to capture INFO level logs."""
+    caplog.set_level(logging.INFO)
+    return caplog
+
+
+"""Tests for delete_support_by_name function."""
+
+
+def test_delete_single_support_deletes_listing(enable_factory_create, db_session, caplog_info):
+    """Test that deleting the only support also deletes the listing."""
+    # Create a support listing with a single support
+    support_listing = factories.SupportListingFactory.create(name="Test Listing")
+    support = factories.SupportFactory.create(name="Test Support", support_listing=support_listing)
+    db_session.flush()
+
+    support_id = support.id
+    listing_id = support_listing.id
+
+    # Delete the support
+    result = delete_support_by_name(db_session, "Test Support")
+
+    assert result is True
+    assert "Deleted Support 'Test Support'" in caplog_info.text
+    assert "No remaining supports for SupportListing" in caplog_info.text
+    assert "Deleted SupportListing 'Test Listing'" in caplog_info.text
+
+    # Verify support and listing are deleted
+    assert db_session.query(Support).filter_by(id=support_id).one_or_none() is None
+    assert db_session.query(SupportListing).filter_by(id=listing_id).one_or_none() is None
+
+
+def test_delete_support_keeps_listing_with_remaining_supports(
+    enable_factory_create, db_session, caplog_info
+):
+    """Test that deleting a support keeps the listing if other supports remain."""
+    # Create a support listing with multiple supports
+    support_listing = factories.SupportListingFactory.create(name="Test Listing 1")
+    support1 = factories.SupportFactory.create(
+        name="Test Support 1", support_listing=support_listing
+    )
+    support2 = factories.SupportFactory.create(
+        name="Test Support 2", support_listing=support_listing
+    )
+    db_session.flush()
+
+    support1_id = support1.id
+    support2_id = support2.id
+    listing_id = support_listing.id
+
+    # Delete one support
+    result = delete_support_by_name(db_session, "Test Support 1")
+
+    assert result is True
+    assert "Deleted Support 'Test Support 1'" in caplog_info.text
+    assert "has 1 remaining support(s), keeping it" in caplog_info.text
+
+    # Verify first support is deleted but listing and second support remain
+    assert db_session.query(Support).filter_by(id=support1_id).one_or_none() is None
+    assert db_session.query(Support).filter_by(id=support2_id).one_or_none() is not None
+    assert db_session.query(SupportListing).filter_by(id=listing_id).one_or_none() is not None
+
+
+def test_delete_nonexistent_support(enable_factory_create, db_session, caplog_info):
+    """Test that deleting a non-existent support returns False."""
+    result = delete_support_by_name(db_session, "Nonexistent Support")
+
+    assert result is False
+    assert "Support with name 'Nonexistent Support' not found" in caplog_info.text