velocity-python 0.1.85__tar.gz → 0.1.86__tar.gz

{velocity_python-0.1.85/src/velocity_python.egg-info → velocity_python-0.1.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.85
+Version: 0.1.86
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.85 → velocity_python-0.1.86}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.85"
+version = "0.1.86"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.85 → velocity_python-0.1.86}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.85"
+__version__ = version = "0.1.86"
 
 import importlib as _importlib
 

{velocity_python-0.1.85 → velocity_python-0.1.86}/src/velocity/aws/handlers/mixins/data_service.py

@@ -17,10 +17,36 @@ from io import BytesIO, StringIO
 
 from velocity.aws import dirty_pipeline
 from velocity.aws.handlers.exceptions import AlertError
+from velocity.db.exceptions import DbDataIntegrityError
 from velocity.misc import export
 
 logger = logging.getLogger(__name__)
 
+# Postgres FK-violation text, e.g.:
+#   ... violates foreign key constraint "billing_formula_client_sys_id_fkey"
+#   on table "billing_formula"
+#   DETAIL:  Key (sys_id)=(1364) is still referenced from table "billing_formula".
+_REFERENCED_FROM_RE = re.compile(r'still referenced from table "([^"]+)"')
+_FK_ON_TABLE_RE = re.compile(r'foreign key constraint "[^"]+" on table "([^"]+)"')
+
+
+def _fk_blocked_delete_message(table, exc):
+    """User-facing message for a delete blocked by a foreign key reference."""
+    text = str(exc)
+    match = _REFERENCED_FROM_RE.search(text) or _FK_ON_TABLE_RE.search(text)
+    label = table.replace("_", " ")
+    if match:
+        referencing = match.group(1).replace("_", " ")
+        return (
+            f"This {label} record can't be deleted because {referencing} "
+            f"records still reference it. Remove or reassign those related "
+            f"records first."
+        )
+    return (
+        f"This {label} record can't be deleted because related records "
+        f"still reference it."
+    )
+
 
 class DataServiceMixin:
     """
@@ -463,7 +489,16 @@ class DataServiceMixin:
             self._call_rwx_hook("before_delete", table, tx, table, sys_id, context)
             row = tx.table(table).find(sys_id)
             if row:
-                row.clear()
+                # A failed DELETE aborts the whole postgres transaction; the
+                # savepoint confines the abort so the outer tx (activity
+                # tracking, response writes) stays usable.
+                try:
+                    with tx.savepoint():
+                        row.clear()
+                except DbDataIntegrityError as exc:
+                    raise AlertError(
+                        _fk_blocked_delete_message(table, exc)
+                    ) from exc
             self._call_rwx_hook("after_delete", "common", tx, table, sys_id, context)
             self._call_rwx_hook("after_delete", table, tx, table, sys_id, context)
 

{velocity_python-0.1.85 → velocity_python-0.1.86/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.85
+Version: 0.1.86
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.85 → velocity_python-0.1.86}/src/velocity_python.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ tests/test_context_job_descriptions.py
 tests/test_db_credentials_ssm_cascade.py
 tests/test_db_maintenance.py
 tests/test_decorators.py
+tests/test_delete_hook_fk_blocked.py
 tests/test_dirty_pipeline_fast_path.py
 tests/test_email_processing.py
 tests/test_enqueue_send_failures.py

velocity_python-0.1.86/tests/test_delete_hook_fk_blocked.py

@@ -0,0 +1,154 @@
+"""delete_hook must convert an FK-blocked delete into a user-facing AlertError.
+
+A DELETE that violates a foreign key (e.g. deleting a customers row still
+referenced by billing_formula) previously escaped as an unhandled
+DbDataIntegrityError — a 500 with a raw SQL traceback. delete_hook now
+attempts the delete inside a savepoint (so the outer transaction survives
+the aborted statement) and raises AlertError with a readable message naming
+the referencing table.
+"""
+
+import importlib.util
+import pathlib
+import unittest
+
+MODULE_PATH = (
+    pathlib.Path(__file__).resolve().parents[1]
+    / "src"
+    / "velocity"
+    / "aws"
+    / "handlers"
+    / "mixins"
+    / "data_service.py"
+)
+_spec = importlib.util.spec_from_file_location("test_delete_hook_module", MODULE_PATH)
+_mod = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+DataServiceMixin = _mod.DataServiceMixin
+AlertError = _mod.AlertError
+DbDataIntegrityError = _mod.DbDataIntegrityError
+
+FK_MESSAGE = (
+    'update or delete on table "customers" violates foreign key constraint '
+    '"billing_formula_client_sys_id_fkey" on table "billing_formula"\n'
+    "DETAIL:  Key (sys_id)=(1364) is still referenced from table "
+    '"billing_formula".'
+)
+
+
+class FakeRow:
+    def __init__(self, clear_exc=None):
+        self.clear_exc = clear_exc
+        self.cleared = False
+
+    def clear(self):
+        if self.clear_exc:
+            raise self.clear_exc
+        self.cleared = True
+
+
+class FakeTable:
+    def __init__(self, row):
+        self.row = row
+
+    def find(self, sys_id):
+        return self.row
+
+
+class FakeTx:
+    """Mimics Transaction.savepoint(): rollback + re-raise on error."""
+
+    def __init__(self, table):
+        self._table = table
+        self.savepoints_opened = 0
+        self.savepoints_rolled_back = 0
+        self.savepoints_released = 0
+
+    def table(self, name):
+        return self._table
+
+    def savepoint(self, name=None):
+        tx = self
+
+        class _SP:
+            def __enter__(self):
+                tx.savepoints_opened += 1
+                return "sp1"
+
+            def __exit__(self, exc_type, exc, tb):
+                if exc_type:
+                    tx.savepoints_rolled_back += 1
+                else:
+                    tx.savepoints_released += 1
+                return False  # re-raise, like the real context manager
+
+        return _SP()
+
+
+class _Service(DataServiceMixin):
+    def __init__(self):
+        self.hooks_called = []
+
+    def _call_rwx_hook(self, hook_name, table, *args, **kwargs):
+        self.hooks_called.append((hook_name, table))
+
+
+class DeleteHookFkBlockedTest(unittest.TestCase):
+    def test_fk_violation_becomes_alert_error(self):
+        row = FakeRow(clear_exc=DbDataIntegrityError(FK_MESSAGE))
+        tx = FakeTx(FakeTable(row))
+        service = _Service()
+
+        with self.assertRaises(AlertError) as ctx:
+            service.delete_hook(tx, "customers", 1364, object())
+
+        message = str(ctx.exception)
+        self.assertIn("billing formula", message)
+        self.assertIn("can't be deleted", message)
+        self.assertNotIn("DELETE", message)  # no raw SQL leaks to the UI
+        # The savepoint was rolled back so the outer tx stays usable.
+        self.assertEqual(1, tx.savepoints_rolled_back)
+        # after_delete hooks must not run for a failed delete.
+        after_hooks = [h for h in service.hooks_called if h[0] == "after_delete"]
+        self.assertEqual([], after_hooks)
+
+    def test_successful_delete_releases_savepoint_and_runs_after_hooks(self):
+        row = FakeRow()
+        tx = FakeTx(FakeTable(row))
+        service = _Service()
+
+        service.delete_hook(tx, "customers", 1364, object())
+
+        self.assertTrue(row.cleared)
+        self.assertEqual(1, tx.savepoints_released)
+        self.assertEqual(0, tx.savepoints_rolled_back)
+        after_hooks = [h for h in service.hooks_called if h[0] == "after_delete"]
+        self.assertEqual([("after_delete", "common"), ("after_delete", "customers")], after_hooks)
+
+    def test_non_integrity_errors_propagate_unchanged(self):
+        row = FakeRow(clear_exc=RuntimeError("connection lost"))
+        tx = FakeTx(FakeTable(row))
+        service = _Service()
+
+        with self.assertRaises(RuntimeError):
+            service.delete_hook(tx, "customers", 1364, object())
+
+    def test_message_without_detail_still_names_referencing_table(self):
+        # Some drivers omit the DETAIL line; fall back to the constraint clause.
+        exc = DbDataIntegrityError(
+            'update or delete on table "customers" violates foreign key '
+            'constraint "billing_formula_client_sys_id_fkey" on table '
+            '"billing_formula"'
+        )
+        message = _mod._fk_blocked_delete_message("customers", exc)
+        self.assertIn("billing formula", message)
+
+    def test_unparseable_message_gets_generic_text(self):
+        message = _mod._fk_blocked_delete_message(
+            "customers", DbDataIntegrityError("something unexpected")
+        )
+        self.assertIn("related records", message)
+
+
+if __name__ == "__main__":
+    unittest.main()