velocity-python 0.1.55__tar.gz → 0.1.56__tar.gz

{velocity_python-0.1.55 → velocity_python-0.1.56}/PKG-INFO

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

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

{velocity_python-0.1.55 → velocity_python-0.1.56}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.55"
+__version__ = version = "0.1.56"
 
 import importlib as _importlib
 

{velocity_python-0.1.55 → velocity_python-0.1.56}/src/velocity/db/core/engine.py

@@ -421,13 +421,13 @@ class Engine:
                 config = self.config.copy()
                 if timeout_key not in config:
                     config[timeout_key] = timeout_val
-                return self.driver.connect(**config)
+                conn = self.driver.connect(**config)
 
             elif isinstance(self.config, str):
                 conn_str = self.config
                 if timeout_key not in conn_str:
                     conn_str += f" {timeout_key}={timeout_val}"
-                return self.driver.connect(conn_str)
+                conn = self.driver.connect(conn_str)
 
             elif isinstance(self.config, (tuple, list)):
                 config_args = list(self.config)
@@ -436,16 +436,50 @@ class Engine:
                         config_args[-1][timeout_key] = timeout_val
                 else:
                     config_args.append({timeout_key: timeout_val})
-                return self.driver.connect(*config_args)
+                conn = self.driver.connect(*config_args)
 
             else:
                 raise TypeError(
                     f"Unhandled configuration parameter type: {type(self.config)}"
                 )
 
+            self._register_connection_adapters(conn)
+            return conn
+
         except Exception as e:
             raise self.process_error(e)
 
+    def _register_connection_adapters(self, conn):
+        """
+        Register driver-specific type adapters on a freshly opened connection.
+
+        For PostgreSQL (psycopg v3) this teaches the connection to send a bare
+        ``dict`` as JSONB. psycopg has no built-in ``dict`` dumper, so without
+        this any dict passed for a JSON/JSONB column raises
+        ``cannot adapt type 'dict'``. Registering it here keeps velocity's
+        "dicts in, dicts out" contract: callers pass a dict, it lands as JSONB.
+
+        Only ``dict`` is mapped — ``list`` is intentionally left alone so it
+        keeps adapting to PostgreSQL arrays (``= ANY(%s)``, array columns).
+        Callers that already serialize to a JSON string keep working: a str is
+        sent as text and cast into the JSONB column.
+        """
+        if "postgre" not in self.sql.server.lower():
+            return
+        try:
+            from psycopg.types.json import JsonbDumper, JsonbBinaryDumper
+        except Exception:
+            return
+        try:
+            # Register both text and binary dumpers so dict adapts regardless of
+            # the negotiated parameter format (mirrors psycopg's own default
+            # registration for its Jsonb wrapper type).
+            conn.adapters.register_dumper(dict, JsonbDumper)
+            conn.adapters.register_dumper(dict, JsonbBinaryDumper)
+        except Exception:
+            # Never let adapter registration break connection establishment.
+            pass
+
     def transaction(self, func_or_cls=None):
         """
         Decorator that provides a Transaction. If `tx` is passed in, uses it; otherwise, creates a new one.

{velocity_python-0.1.55 → velocity_python-0.1.56}/src/velocity_python.egg-info/PKG-INFO

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

@@ -162,6 +162,7 @@ tests/test_decorators.py
 tests/test_dirty_pipeline_fast_path.py
 tests/test_email_processing.py
 tests/test_iconv_money_to_cents.py
+tests/test_jsonb_dict_adapter.py
 tests/test_lambda_handler.py
 tests/test_lambda_handler_auth.py
 tests/test_mixins_import.py

velocity_python-0.1.56/tests/test_jsonb_dict_adapter.py

@@ -0,0 +1,82 @@
+"""Tests for automatic dict -> JSONB adaptation on PostgreSQL connections.
+
+Regression for the production failure in client_payment_accounts upserts
+(stripe/braintree/authorizenet mirrors): a bare ``dict`` passed for a JSONB
+column raised ``psycopg.ProgrammingError: cannot adapt type 'dict'`` because
+psycopg v3 ships no built-in dict dumper.
+
+The engine now registers ``JsonbDumper`` for ``dict`` on each new PostgreSQL
+connection, so callers keep velocity's "dicts in, dicts out" contract.
+"""
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+_PG_ENV = {
+    "DBDatabase": "testdb",
+    "DBHost": "localhost",
+    "DBPort": "5432",
+    "DBUser": "user",
+    "DBPassword": "pass",
+}
+
+
+class TestDictJsonbAdapterRegistration:
+    @patch.dict(os.environ, _PG_ENV)
+    def test_dict_dumper_registered_on_postgres_connect(self):
+        from velocity.db.servers.postgres import initialize
+        from psycopg.types.json import JsonbDumper, JsonbBinaryDumper
+
+        conn = MagicMock(closed=False)
+        with patch("psycopg.connect", return_value=conn):
+            engine = initialize(pool_enabled=False)
+            engine.connect()
+
+        conn.adapters.register_dumper.assert_any_call(dict, JsonbDumper)
+        conn.adapters.register_dumper.assert_any_call(dict, JsonbBinaryDumper)
+
+    @patch.dict(os.environ, _PG_ENV)
+    def test_connection_still_returned_if_registration_fails(self):
+        """Adapter registration must never break connection establishment."""
+        from velocity.db.servers.postgres import initialize
+
+        conn = MagicMock(closed=False)
+        conn.adapters.register_dumper.side_effect = RuntimeError("boom")
+        with patch("psycopg.connect", return_value=conn):
+            engine = initialize(pool_enabled=False)
+            result = engine.connect()
+
+        assert result is conn
+
+
+class TestJsonbDumperSerializesBareDict:
+    """The registered dumper must actually serialize a bare dict to JSONB."""
+
+    def test_text_dumper_dumps_bare_dict_to_json(self):
+        from psycopg.types.json import JsonbDumper
+
+        out = bytes(JsonbDumper(dict).dump({"card_payments": "active"}))
+        assert out == b'{"card_payments": "active"}'
+
+    def test_binary_dumper_dumps_bare_dict_to_jsonb(self):
+        from psycopg.types.json import JsonbBinaryDumper
+
+        out = bytes(JsonbBinaryDumper(dict).dump({"card_payments": "active"}))
+        # JSONB binary wire format is a 0x01 version byte followed by JSON text.
+        assert out[:1] == b"\x01"
+        assert b'"card_payments"' in out
+
+
+class TestNonPostgresUnaffected:
+    def test_sqlite_connect_does_not_register_dict_dumper(self):
+        """Non-PostgreSQL engines must not attempt psycopg adapter registration."""
+        from velocity.db.servers.sqlite import initialize
+
+        engine = initialize(config={"database": ":memory:"})
+        conn = engine.connect()
+        # A sqlite3 connection has no `.adapters`; reaching it would have raised.
+        assert conn is not None
+        conn.close()