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

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

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

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

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

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

{velocity_python-0.1.55 → velocity_python-0.1.57}/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.57}/src/velocity/db/servers/mysql/__init__.py

@@ -1,4 +1,5 @@
 import os
+from velocity.aws.ssm_config import getenv as _getenv
 from ..base.initializer import BaseInitializer
 from velocity.db.core import engine
 from .sql import SQL
@@ -27,13 +28,13 @@ class MySQLInitializer(BaseInitializer):
                 "MySQL connector not available. Install with: pip install mysql-connector-python"
             )
 
-        # Base configuration from environment (if available)
+        # Base configuration from environment / SSM (same cascade as postgres)
         base_config = {
-            "database": os.environ.get("DBDatabase"),
-            "host": os.environ.get("DBHost"),
-            "port": os.environ.get("DBPort"),
-            "user": os.environ.get("DBUser"),
-            "password": os.environ.get("DBPassword"),
+            "database": _getenv("DBDatabase"),
+            "host": _getenv("DBHost"),
+            "port": _getenv("DBPort"),
+            "user": _getenv("DBUser"),
+            "password": _getenv("DBPassword"),
         }
 
         # Remove None values

{velocity_python-0.1.55 → velocity_python-0.1.57}/src/velocity/db/servers/sqlserver/__init__.py

@@ -1,4 +1,5 @@
 import os
+from velocity.aws.ssm_config import getenv as _getenv
 from ..base.initializer import BaseInitializer
 from velocity.db.core import engine
 from .sql import SQL
@@ -27,15 +28,13 @@ class SQLServerInitializer(BaseInitializer):
                 "SQL Server connector not available. Install with: pip install python-tds"
             )
 
-        # Base configuration from environment (if available)
+        # Base configuration from environment / SSM (same cascade as postgres)
         base_config = {
-            "database": os.environ.get("DBDatabase"),
-            "server": os.environ.get(
-                "DBHost"
-            ),  # SQL Server uses 'server' instead of 'host'
-            "port": os.environ.get("DBPort"),
-            "user": os.environ.get("DBUser"),
-            "password": os.environ.get("DBPassword"),
+            "database": _getenv("DBDatabase"),
+            "server": _getenv("DBHost"),  # SQL Server uses 'server' instead of 'host'
+            "port": _getenv("DBPort"),
+            "user": _getenv("DBUser"),
+            "password": _getenv("DBPassword"),
         }
 
         # Remove None values

{velocity_python-0.1.55 → velocity_python-0.1.57}/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.57
 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.57}/src/velocity_python.egg-info/SOURCES.txt

@@ -158,10 +158,12 @@ tests/test_concurrency_safety.py
 tests/test_connection_pool.py
 tests/test_connection_resilience.py
 tests/test_context_job_descriptions.py
+tests/test_db_credentials_ssm_cascade.py
 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.57/tests/test_db_credentials_ssm_cascade.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""DB credential resolution must go through the SSM->env cascade (ssm_config.getenv),
+the same way the postgres initializer does, so MySQL/SQL Server work in SSM-only
+environments rather than only reading raw os.environ.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from velocity.db.servers import mysql as mysql_server
+from velocity.db.servers import sqlserver as sqlserver_server
+
+FAKE = {
+    "DBDatabase": "ssm_db",
+    "DBHost": "ssm_host",
+    "DBPort": "5599",
+    "DBUser": "ssm_user",
+    "DBPassword": "ssm_pass",
+}
+
+
+class TestDbCredentialsSsmCascade(unittest.TestCase):
+    def test_mysql_resolves_credentials_via_getenv(self):
+        captured = {}
+
+        def fake_engine(driver, cfg, sql, **kwargs):
+            captured.update(cfg)
+            return MagicMock()
+
+        with patch.object(mysql_server, "_getenv", lambda key: FAKE.get(key)), patch.object(
+            mysql_server.engine, "Engine", fake_engine
+        ):
+            mysql_server.MySQLInitializer.initialize(None)
+
+        self.assertEqual(captured["database"], "ssm_db")
+        self.assertEqual(captured["host"], "ssm_host")
+        self.assertEqual(captured["port"], "5599")
+        self.assertEqual(captured["user"], "ssm_user")
+        self.assertEqual(captured["password"], "ssm_pass")
+
+    def test_sqlserver_resolves_credentials_via_getenv(self):
+        captured = {}
+
+        def fake_engine(driver, cfg, sql, **kwargs):
+            captured.update(cfg)
+            return MagicMock()
+
+        with patch.object(
+            sqlserver_server, "_getenv", lambda key: FAKE.get(key)
+        ), patch.object(sqlserver_server.engine, "Engine", fake_engine):
+            sqlserver_server.SQLServerInitializer.initialize(None)
+
+        self.assertEqual(captured["database"], "ssm_db")
+        self.assertEqual(captured["server"], "ssm_host")  # SQL Server uses 'server'
+        self.assertEqual(captured["port"], "5599")
+        self.assertEqual(captured["user"], "ssm_user")
+        self.assertEqual(captured["password"], "ssm_pass")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.1.57/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()