velocity-python 0.1.78__tar.gz → 0.1.80__tar.gz

{velocity_python-0.1.78 → velocity_python-0.1.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.78
+Version: 0.1.80
 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.78 → velocity_python-0.1.80}/pyproject.toml

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

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.78"
+__version__ = version = "0.1.80"
 
 import importlib as _importlib
 

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity/aws/handlers/mixins/web_handler.py

@@ -522,8 +522,40 @@ Request Details:
         self.track_activity_start(tx, context)
 
     def _enhanced_after_action(self, tx, context):
-        """Enhanced afterAction that adds activity tracking"""
-        self.track_activity_success(tx, context)
+        """Enhanced afterAction that adds activity tracking.
+
+        Activity tracking is bookkeeping — it must never convert a completed
+        action into a 500. Two guards:
+
+        * If the transaction is already aborted, the action caught a DB error and
+          returned a "success" response WITHOUT rolling back to a savepoint. The
+          tracking UPDATE would then fail at ``SAVEPOINT`` with "current
+          transaction is aborted", masking the real error (prod incident
+          2026-07-01). Skip the write and log loudly — the swallow-without-
+          savepoint is the actual bug; wrap the fallible statement in
+          ``with tx.savepoint():``.
+        * Any other failure of the tracking write is caught and logged rather than
+          propagated, so bookkeeping can't fail an otherwise-successful request.
+        """
+        try:
+            if getattr(tx, "is_aborted", None) and tx.is_aborted():
+                logger.error(
+                    "Skipping success activity tracking: transaction is aborted "
+                    "after a 'successful' action (action=%s handler=%s). An earlier "
+                    "DB error was caught without rolling back to a savepoint — wrap "
+                    "the fallible statement in `with tx.savepoint():`.",
+                    context.action(),
+                    self.__class__.__name__,
+                )
+            else:
+                self.track_activity_success(tx, context)
+        except Exception:
+            logger.exception(
+                "Success activity tracking failed (action=%s handler=%s); "
+                "continuing without it.",
+                context.action(),
+                self.__class__.__name__,
+            )
         if self._perf_timing_enabled:
             elapsed_ms = context.perf.log("web_handler action total")
             if elapsed_ms is not None:

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity/db/core/transaction.py

@@ -577,6 +577,40 @@ class Transaction:
             # Transaction is clean again — no uncommitted work pending.
             self._in_progress = False
 
+    def is_aborted(self):
+        """Return True if the connection is in a failed/aborted transaction.
+
+        After a statement errors on PostgreSQL, the whole transaction is poisoned:
+        every subsequent statement — *including* ``SAVEPOINT`` — fails with
+        "current transaction is aborted, commands ignored until end of transaction
+        block" until a ``ROLLBACK`` (or rollback to a savepoint taken *before* the
+        error). Because even ``SAVEPOINT`` fails in this state, a ``tx.savepoint()``
+        wrapper cannot rescue an already-poisoned transaction — callers that want to
+        run bookkeeping after a fallible step should check this first and skip (and
+        fix the swallow-without-savepoint upstream).
+
+        Best-effort and driver-specific: returns False when it cannot be determined
+        (no open connection, or a driver without a transaction-status concept). For
+        psycopg (v2/v3) this maps to libpq ``PQTRANS_INERROR`` (numeric 3).
+        """
+        conn = self.connection
+        if conn is None:
+            return False
+        try:
+            status = conn.info.transaction_status
+        except Exception:
+            return False
+        if status is None:
+            return False
+        # psycopg3: pq.TransactionStatus.INERROR (IntEnum, name 'INERROR', value 3).
+        # Compare by name and by the stable libpq numeric to stay driver-robust.
+        try:
+            if getattr(status, "name", None) == "INERROR":
+                return True
+            return int(status) == 3
+        except Exception:
+            return False
+
     def create_savepoint(self, sp=None, cursor=None):
         """
         Creates a savepoint named `sp`. If none given, uses a random name.

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity/payment/braintree_mirror.py

@@ -114,7 +114,10 @@ def _filtered_payload_for_table(table, payload: Dict[str, Any]) -> Dict[str, Any
 
 def _upsert(tx, table_name: str, payload: Dict[str, Any], key: Dict[str, Any]):
     table = _table(tx, table_name)
-    if not table:
+    # `is None`, NOT falsy: a velocity Table's truthiness is its row count
+    # (__len__), so `if not table` is True for an EMPTY table -- which would
+    # silently skip the first write to an empty mirror table (chicken-and-egg).
+    if table is None:
         return None
     payload = _filtered_payload_for_table(table, payload)
     table.upsert(payload, key)

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity/payment/stripe_mirror.py

@@ -50,7 +50,10 @@ def _table(tx, table_name: str):
 
 def _upsert(tx, table_name: str, payload: Dict[str, Any], key: Dict[str, Any]):
     table = _table(tx, table_name)
-    if not table:
+    # `is None`, NOT falsy: a velocity Table's truthiness is its row count
+    # (__len__), so `if not table` is True for an EMPTY table -- which would
+    # silently skip the first write to any empty mirror table (chicken-and-egg).
+    if table is None:
         return None
     table.upsert(payload, key)
     return payload
@@ -99,7 +102,10 @@ def sync_customer_from_stripe_account(tx, account: Any, client_id: Any):
     if not client_id:
         return None
     table = _table(tx, "customers")
-    if not table:
+    # `is None`, NOT falsy: a velocity Table's truthiness is its row count
+    # (__len__), so `if not table` is True for an EMPTY table -- which would
+    # silently skip the first write to any empty mirror table (chicken-and-egg).
+    if table is None:
         return None
     row = table.find({"client_id": client_id})
     if not row:

{velocity_python-0.1.78 → velocity_python-0.1.80}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.78
+Version: 0.1.80
 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.78 → velocity_python-0.1.80}/src/velocity_python.egg-info/SOURCES.txt

@@ -151,6 +151,7 @@ src/velocity_python.egg-info/dependency_links.txt
 src/velocity_python.egg-info/entry_points.txt
 src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
+tests/test_activity_tracking_aborted_tx.py
 tests/test_amplify_build.py
 tests/test_asset_indexing.py
 tests/test_asset_references.py
@@ -184,6 +185,7 @@ tests/test_observability.py
 tests/test_payment_authorizenet_adapter.py
 tests/test_payment_braintree_adapter.py
 tests/test_payment_braintree_mirror.py
+tests/test_payment_mirror_empty_table.py
 tests/test_payment_profile_sorting.py
 tests/test_payment_stripe_adapter.py
 tests/test_pdf.py

velocity_python-0.1.80/tests/test_activity_tracking_aborted_tx.py

@@ -0,0 +1,116 @@
+"""Bookkeeping must never turn a completed action into a 500.
+
+If an action catches a DB error and returns a "success" response WITHOUT rolling
+back to a savepoint, the transaction stays aborted. velocity's afterAction
+activity-tracking UPDATE would then fail at SAVEPOINT with "current transaction is
+aborted", masking the real error and producing an unhandled 500 (prod incident
+2026-07-01, BackOfficeData BillingDashboard). These tests pin:
+
+  * Transaction.is_aborted() detects the poisoned state.
+  * _enhanced_after_action skips the tracking write when aborted (and never
+    raises), and still tracks on a healthy transaction.
+"""
+
+import unittest
+from unittest.mock import MagicMock
+
+from velocity.db.core.transaction import Transaction
+from velocity.aws.handlers.mixins.web_handler import WebHandler
+
+
+class IsAbortedTest(unittest.TestCase):
+    def _tx_with_status(self, status):
+        tx = Transaction.__new__(Transaction)
+        conn = MagicMock()
+        conn.info.transaction_status = status
+        tx.connection = conn
+        return tx
+
+    def test_no_connection_is_not_aborted(self):
+        tx = Transaction.__new__(Transaction)
+        tx.connection = None
+        self.assertFalse(tx.is_aborted())
+
+    def test_inerror_by_name_is_aborted(self):
+        status = MagicMock()
+        status.name = "INERROR"
+        self.assertTrue(self._tx_with_status(status).is_aborted())
+
+    def test_inerror_by_numeric_is_aborted(self):
+        # A driver enum member whose .name isn't 'INERROR' but int() == 3.
+        class _Status:
+            name = "PQTRANS_INERROR"
+
+            def __int__(self):
+                return 3
+
+        self.assertTrue(self._tx_with_status(_Status()).is_aborted())
+
+    def test_intrans_is_not_aborted(self):
+        status = MagicMock()
+        status.name = "INTRANS"
+        status.__int__ = lambda self: 2
+        self.assertFalse(self._tx_with_status(status).is_aborted())
+
+    def test_status_probe_failure_is_not_aborted(self):
+        tx = Transaction.__new__(Transaction)
+        conn = MagicMock()
+        type(conn).info = property(lambda self: (_ for _ in ()).throw(RuntimeError()))
+        tx.connection = conn
+        self.assertFalse(tx.is_aborted())
+
+
+class _Handler(WebHandler):
+    """Minimal harness exercising the real _enhanced_after_action."""
+
+    def __init__(self):
+        self._perf_timing_enabled = False
+        self.track_activity_success = MagicMock()
+
+
+def _context():
+    ctx = MagicMock()
+    ctx.action.return_value = "query"
+    return ctx
+
+
+class EnhancedAfterActionGuardTest(unittest.TestCase):
+    def test_skips_tracking_when_tx_aborted(self):
+        handler = _Handler()
+        tx = MagicMock()
+        tx.is_aborted.return_value = True
+
+        handler._enhanced_after_action(tx, _context())  # must not raise
+
+        handler.track_activity_success.assert_not_called()
+
+    def test_tracks_when_tx_healthy(self):
+        handler = _Handler()
+        tx = MagicMock()
+        tx.is_aborted.return_value = False
+
+        handler._enhanced_after_action(tx, _context())
+
+        handler.track_activity_success.assert_called_once()
+
+    def test_tracking_failure_is_swallowed(self):
+        handler = _Handler()
+        handler.track_activity_success.side_effect = RuntimeError("boom")
+        tx = MagicMock()
+        tx.is_aborted.return_value = False
+
+        # A failing bookkeeping write must not propagate out of afterAction.
+        handler._enhanced_after_action(tx, _context())
+
+    def test_missing_is_aborted_falls_back_to_tracking(self):
+        # Older Transaction without is_aborted() (getattr guard) still tracks.
+        handler = _Handler()
+        tx = MagicMock(spec=[])  # no is_aborted attribute
+
+        handler._enhanced_after_action(tx, _context())
+
+        handler.track_activity_success.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.1.80/tests/test_payment_mirror_empty_table.py

@@ -0,0 +1,58 @@
+"""Regression: mirror `_upsert` must write to an EMPTY table.
+
+A velocity ``Table``'s truthiness is its row count (``__len__``), so an empty
+table is falsy. The mirror guards must therefore test ``table is None``, not
+``if not table`` -- otherwise the FIRST write to any empty mirror table silently
+no-ops (chicken-and-egg: the table stays empty forever, so it never becomes
+truthy and never gets written). This bit the Stripe client-account sync: an
+empty ``stripe_accounts`` / ``client_payment_accounts`` could never be seeded.
+
+The prior FakeTable in the mirror tests did not implement ``__len__``, so it was
+always truthy and never exercised this path.
+"""
+from velocity.payment import braintree_mirror, stripe_mirror
+
+
+class EmptyTable:
+    """Models a real velocity Table whose truthiness is its row count: 0 -> falsy."""
+
+    def __init__(self):
+        self.upserts = []
+
+    def __len__(self):
+        return 0  # empty table -> bool(table) is False
+
+    def exists(self):
+        return True
+
+    def sys_columns(self):
+        return ["stripe_id", "client_id", "id", "amount", "status"]
+
+    def upsert(self, payload, key):
+        self.upserts.append((payload, key))
+
+
+class FakeTx:
+    def __init__(self, table):
+        self._table = table
+
+    def table(self, _name):
+        return self._table
+
+
+def test_stripe_mirror_upsert_writes_to_empty_table():
+    t = EmptyTable()
+    result = stripe_mirror._upsert(
+        FakeTx(t), "stripe_accounts", {"stripe_id": "acct_x"}, {"stripe_id": "acct_x"}
+    )
+    assert result is not None, "write to an empty table silently no-op'd"
+    assert len(t.upserts) == 1
+
+
+def test_braintree_mirror_upsert_writes_to_empty_table():
+    t = EmptyTable()
+    result = braintree_mirror._upsert(
+        FakeTx(t), "braintree_transaction", {"id": "txn_x", "amount": "1.00"}, {"id": "txn_x"}
+    )
+    assert result is not None, "write to an empty table silently no-op'd"
+    assert len(t.upserts) == 1