sqlalchemy-declarative-extensions 0.16.7__tar.gz → 0.16.9__tar.gz

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ## 0.16
 
+### 0.16.9
+
+- fix: Support for duplicate PostgreSQL trigger names.
+- fix: Parsing quoted ACL usernames at end of input.
+
+### 0.16.8
+
+- fix: Adds schema support to audit functions (that is, they will now be created in the schema of the table to avoid conflicts).
+
 ### 0.16.7
 
 - feat: Add missing support for `exclude` on triggers.

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-declarative-extensions
-Version: 0.16.7
+Version: 0.16.9
 Summary: Library to declare additional kinds of objects not natively supported by SQLAlchemy/Alembic.
 Project-URL: documentation, https://sqlalchemy-declarative-extensions.readthedocs.io/en/latest/
 Project-URL: homepage, https://sqlalchemy-declarative-extensions.readthedocs.io/en/latest/

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/docs/source/conf.py

@@ -2,7 +2,7 @@ from sphinx_pyproject import SphinxConfig
 
 config = SphinxConfig("../../pyproject.toml")
 
-project = "SQLAlechemy Declarative Extensions"
+project = "SQLAlchemy Declarative Extensions"
 copyright = "2022, Dan Cardin"
 author = config.author
 release = config.version

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-declarative-extensions"
-version = "0.16.7"
+version = "0.16.9"
 authors = [{ name = "Dan Cardin", email = "ddcardin@gmail.com" }]
 description = "Library to declare additional kinds of objects not natively supported by SQLAlchemy/Alembic."
 license = { file = "LICENSE" }

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/src/sqlalchemy_declarative_extensions/audit.py

@@ -10,7 +10,7 @@ from sqlalchemy_declarative_extensions import (
     register_trigger,
 )
 from sqlalchemy_declarative_extensions.dialects.postgresql.trigger import Trigger
-from sqlalchemy_declarative_extensions.sql import quote_name
+from sqlalchemy_declarative_extensions.sql import qualify_name, quote_name
 
 default_primary_key = Column(
     "audit_pk", types.Integer(), primary_key=True, autoincrement=True
@@ -109,6 +109,7 @@ def audit_table(
     create_audit_triggers(
         table.metadata,
         table,
+        audit_table,
         insert=insert,
         update=update,
         delete=delete,
@@ -242,6 +243,7 @@ def create_audit_functions(
             """,
             returns="TRIGGER",
             language="plpgsql",
+            schema=audit_table.schema,
         )
         functions.append(function)
         register_function(metadata, function)
@@ -252,6 +254,7 @@ def create_audit_functions(
 def create_audit_triggers(
     metadata: MetaData,
     table: Table,
+    audit_table: Table,
     insert: bool = True,
     update: bool = True,
     delete: bool = True,
@@ -282,10 +285,15 @@ def create_audit_triggers(
         if not enabled:
             continue
 
+        # Use qualified function name (schema.function_name) for trigger execution
+        # Use audit_table.schema since functions are created in the audit table's schema
+        function_qualified_name = qualify_name(
+            audit_table.schema, "_".join([function_name, op])
+        )
         trigger = Trigger.after(
             op,
             on=table.fullname,
-            execute="_".join([function_name, op]),
+            execute=function_qualified_name,
             name="_".join([trigger_name, op]),
         ).for_each_row()
         triggers.append(trigger)

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/src/sqlalchemy_declarative_extensions/dialects/postgresql/acl.py

@@ -78,7 +78,8 @@ def _parse_acl(
 
     if acl is not None:
         eq_pos, grantee = get_acl_username(acl)
-        assert acl[eq_pos] == "="
+        if eq_pos >= len(acl) or acl[eq_pos] != "=":
+            raise ValueError("ACL syntax error: missing '='.")
 
         if not grantee:
             grantee = "PUBLIC"
@@ -157,6 +158,7 @@ def get_acl_username(acl: str):
                     # Quoting convention is to escape " as "".
                     has_next_char = i + 1 < acl_len
                     if not has_next_char:
+                        i += 1
                         break
 
                     next_char = acl[i + 1]

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/src/sqlalchemy_declarative_extensions/dialects/postgresql/trigger.py

@@ -94,6 +94,10 @@ class Trigger(base.Trigger):
     old_table: str | None = None
     new_table: str | None = None
 
+    @property
+    def identity(self) -> tuple[str, str]:
+        return self.on, self.name
+
     @classmethod
     def before(
         cls, *events: TriggerEvents | str, on: str, execute: str, name: str = ""

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/src/sqlalchemy_declarative_extensions/trigger/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field, replace
-from typing import Iterable, Sequence
+from typing import Hashable, Iterable, Sequence
 
 from sqlalchemy import MetaData
 from sqlalchemy.engine import Connection
@@ -18,6 +18,11 @@ class Trigger:
     on: str
     execute: str
 
+    @property
+    def identity(self) -> Hashable:
+        """Return the dialect-specific identity used to compare triggers."""
+        return self.name
+
     def named(self, name: str):
         return replace(self, name=name)
 

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/src/sqlalchemy_declarative_extensions/trigger/compare.py

@@ -51,34 +51,36 @@ Operation = Union[CreateTriggerOp, UpdateTriggerOp, DropTriggerOp]
 def compare_triggers(connection: Connection, triggers: Triggers) -> list[Operation]:
     result: list[Operation] = []
 
-    triggers_by_name = {r.name: r for r in triggers.triggers}
-    expected_trigger_names = set(triggers_by_name)
+    triggers_by_identity = {r.identity: r for r in triggers.triggers}
+    expected_trigger_identities = set(triggers_by_identity)
 
     raw_existing_triggers = get_triggers(connection)
     existing_triggers = filter_triggers(
         raw_existing_triggers, exclude=triggers.ignore, include=triggers.include
     )
 
-    existing_triggers_by_name = {r.name: r for r in existing_triggers}
-    existing_trigger_names = set(existing_triggers_by_name)
+    existing_triggers_by_identity = {r.identity: r for r in existing_triggers}
+    existing_trigger_identities = set(existing_triggers_by_identity)
 
-    new_trigger_names = expected_trigger_names - existing_trigger_names
-    removed_trigger_names = existing_trigger_names - expected_trigger_names
+    new_trigger_identities = expected_trigger_identities - existing_trigger_identities
+    removed_trigger_identities = (
+        existing_trigger_identities - expected_trigger_identities
+    )
 
     for trigger in triggers:
-        trigger_created = trigger.name in new_trigger_names
+        trigger_created = trigger.identity in new_trigger_identities
 
         if trigger_created:
             result.append(CreateTriggerOp(trigger))
         else:
-            existing_trigger = existing_triggers_by_name[trigger.name]
+            existing_trigger = existing_triggers_by_identity[trigger.identity]
 
             if existing_trigger != trigger:
                 result.append(UpdateTriggerOp(existing_trigger, trigger))
 
     if not triggers.ignore_unspecified:
-        for removed_trigger in removed_trigger_names:
-            trigger = existing_triggers_by_name[removed_trigger]
+        for removed_trigger in removed_trigger_identities:
+            trigger = existing_triggers_by_identity[removed_trigger]
             result.append(DropTriggerOp(trigger))
 
     return result

sqlalchemy_declarative_extensions-0.16.9/tests/audit/test_schema_support.py

@@ -0,0 +1,253 @@
+"""Tests for schema-aware audit function and trigger creation."""
+from pytest_mock_resources import create_postgres_fixture
+from sqlalchemy import Column, text, types
+
+from sqlalchemy_declarative_extensions import (
+    Schemas,
+    declarative_database,
+    register_sqlalchemy_events,
+)
+from sqlalchemy_declarative_extensions.audit import audit
+from sqlalchemy_declarative_extensions.sqlalchemy import declarative_base
+
+_Base = declarative_base()
+
+
+@declarative_database
+class Base(_Base):  # type: ignore
+    __abstract__ = True
+
+    schemas = Schemas().are("myschema", "otherschema")
+
+
+# Test table with schema from __table_args__
+@audit()
+class Product(Base):
+    __tablename__ = "product"
+    __table_args__ = {"schema": "myschema"}
+
+    id = Column(types.Integer(), primary_key=True)
+    name = Column(types.Unicode())
+    price = Column(types.Numeric())
+
+
+# Test table with explicit schema parameter in @audit decorator
+@audit(schema="otherschema")
+class Order(Base):
+    __tablename__ = "order"
+    __table_args__ = {"schema": "myschema"}
+
+    id = Column(types.Integer(), primary_key=True)
+    product_id = Column(types.Integer())
+    quantity = Column(types.Integer())
+
+
+# Test table without schema (should use default)
+@audit()
+class Customer(Base):
+    __tablename__ = "customer"
+
+    id = Column(types.Integer(), primary_key=True)
+    name = Column(types.Unicode())
+
+
+register_sqlalchemy_events(Base.metadata, schemas=True, functions=True, triggers=True)
+
+pg = create_postgres_fixture(engine_kwargs={"echo": True}, session=True)
+
+
+def test_audit_functions_in_table_schema(pg):
+    """Test that audit functions are created in the same schema as the audited table."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Check that audit functions exist in myschema (for Product table)
+    result = pg.execute(
+        text(
+            """
+            SELECT routine_schema, routine_name
+            FROM information_schema.routines
+            WHERE routine_schema = 'myschema'
+              AND routine_name LIKE '%product_audit%'
+            ORDER BY routine_name
+            """
+        )
+    ).fetchall()
+
+    # Should have 3 functions: insert, update, delete
+    assert len(result) == 3
+    schemas = {r[0] for r in result}
+    assert schemas == {"myschema"}
+
+    function_names = {r[1] for r in result}
+    assert function_names == {
+        "myschema_product_audit_insert",
+        "myschema_product_audit_update",
+        "myschema_product_audit_delete",
+    }
+
+
+def test_audit_functions_with_explicit_schema(pg):
+    """Test that audit functions respect explicit schema parameter in @audit decorator."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Check that audit functions exist in otherschema (explicit schema for Order)
+    result = pg.execute(
+        text(
+            """
+            SELECT routine_schema, routine_name
+            FROM information_schema.routines
+            WHERE routine_schema = 'otherschema'
+              AND routine_name LIKE '%order_audit%'
+            ORDER BY routine_name
+            """
+        )
+    ).fetchall()
+
+    # Should have 3 functions: insert, update, delete
+    assert len(result) == 3
+    schemas = {r[0] for r in result}
+    assert schemas == {"otherschema"}
+
+
+def test_audit_table_in_correct_schema(pg):
+    """Test that audit tables are created in the correct schema."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Check Product audit table is in myschema
+    result = pg.execute(
+        text(
+            """
+            SELECT table_schema, table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'myschema'
+              AND table_name = 'product_audit'
+            """
+        )
+    ).fetchall()
+
+    assert len(result) == 1
+    assert result[0] == ("myschema", "product_audit")
+
+    # Check Order audit table is in otherschema (explicit schema)
+    result = pg.execute(
+        text(
+            """
+            SELECT table_schema, table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'otherschema'
+              AND table_name = 'order_audit'
+            """
+        )
+    ).fetchall()
+
+    assert len(result) == 1
+    assert result[0] == ("otherschema", "order_audit")
+
+
+def test_audit_triggers_reference_correct_functions(pg):
+    """Test that triggers correctly reference schema-qualified function names."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Check Product triggers reference myschema functions
+    result = pg.execute(
+        text(
+            """
+            SELECT trigger_name, action_statement
+            FROM information_schema.triggers
+            WHERE event_object_schema = 'myschema'
+              AND event_object_table = 'product'
+            ORDER BY trigger_name
+            """
+        )
+    ).fetchall()
+
+    assert len(result) == 3
+
+    # Each trigger should execute a function from myschema
+    for trigger_name, action_statement in result:
+        assert "myschema." in action_statement.lower(), (
+            f"Trigger {trigger_name} should reference myschema-qualified function, "
+            f"got: {action_statement}"
+        )
+
+
+def test_audit_functionality_with_schema(pg):
+    """Integration test: verify audit trail works correctly with schema-qualified functions."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Insert a product
+    product = Product(id=1, name="Widget", price=19.99)
+    pg.add(product)
+    pg.commit()
+
+    # Check audit trail
+    result = pg.execute(
+        text("SELECT audit_operation, name, price FROM myschema.product_audit ORDER BY audit_pk")
+    ).fetchall()
+
+    assert len(result) == 1
+    assert result[0][0] == "I"  # Insert operation
+    assert result[0][1] == "Widget"
+    assert float(result[0][2]) == 19.99
+
+    # Update the product
+    product.price = 24.99
+    pg.commit()
+
+    result = pg.execute(
+        text("SELECT audit_operation, name, price FROM myschema.product_audit ORDER BY audit_pk")
+    ).fetchall()
+
+    assert len(result) == 2
+    assert result[1][0] == "U"  # Update operation
+    assert float(result[1][2]) == 24.99
+
+    # Delete the product
+    pg.delete(product)
+    pg.commit()
+
+    result = pg.execute(
+        text("SELECT audit_operation FROM myschema.product_audit ORDER BY audit_pk")
+    ).fetchall()
+
+    assert len(result) == 3
+    assert result[2][0] == "D"  # Delete operation
+
+
+def test_audit_functions_default_schema(pg):
+    """Test that audit functions work in default schema when no schema is specified."""
+    Base.metadata.create_all(bind=pg.connection())
+    pg.commit()
+
+    # Check that Customer audit functions exist in public schema
+    result = pg.execute(
+        text(
+            """
+            SELECT routine_schema, routine_name
+            FROM information_schema.routines
+            WHERE routine_schema = 'public'
+              AND routine_name LIKE '%customer_audit%'
+            ORDER BY routine_name
+            """
+        )
+    ).fetchall()
+
+    # Should have 3 functions: insert, update, delete
+    assert len(result) == 3
+
+    # Verify Customer audit works
+    customer = Customer(id=1, name="John Doe")
+    pg.add(customer)
+    pg.commit()
+
+    result = pg.execute(
+        text("SELECT audit_operation, name FROM public.customer_audit ORDER BY audit_pk")
+    ).fetchall()
+
+    assert len(result) == 1
+    assert result[0] == ("I", "John Doe")

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/tests/dialect/postgresql/test_acl.py

@@ -1,6 +1,7 @@
 import pytest
 
 from sqlalchemy_declarative_extensions.dialects.postgresql.acl import (
+    get_acl_username,
     parse_acl,
     parse_default_acl,
 )
@@ -23,6 +24,25 @@ def test_invalid(acl):
         parse_default_acl(acl, "r", "public")
 
 
+@pytest.mark.parametrize(
+    "acl, expected",
+    (
+        ('"role-name"=x', (11, "role-name")),
+        ('"role-name"', (11, "role-name")),
+        ('"role""name"', (12, 'role"name')),
+    ),
+)
+def test_get_acl_username_quoted(acl, expected):
+    assert get_acl_username(acl) == expected
+
+
+def test_acl_with_quoted_grantor():
+    result = parse_acl('"grantee-name"=r/"grantor-name"', "r", "foo")
+
+    assert len(result) == 1
+    assert result[0].grant.target_role == "grantee-name"
+
+
 @pytest.mark.parametrize(
     "acl, grant_option", (("user=r/user", False), ("user=r*/user", True))
 )

{sqlalchemy_declarative_extensions-0.16.7 → sqlalchemy_declarative_extensions-0.16.9}/tests/trigger/test_create_postgres.py

@@ -37,6 +37,10 @@ class Base(_Base):  # type: ignore
         .named("on_insert_foo")
         .when("pg_trigger_depth() < 1")
         .for_each_row(),
+        Trigger.after("insert", on="bar", execute="gimme")
+        .named("on_insert_foo")
+        .when("pg_trigger_depth() < 1")
+        .for_each_row(),
     )
 
 
@@ -46,6 +50,12 @@ class Foo(Base):
     id = Column(types.Integer(), primary_key=True)
 
 
+class Bar(Base):
+    __tablename__ = "bar"
+
+    id = Column(types.Integer(), primary_key=True)
+
+
 register_sqlalchemy_events(Base.metadata, functions=True, triggers=True)
 
 pg = create_postgres_fixture(engine_kwargs={"echo": True}, session=True)

sqlalchemy_declarative_extensions-0.16.9/tests/trigger/test_same_name_postgres.py

@@ -0,0 +1,63 @@
+from unittest.mock import Mock
+
+from sqlalchemy_declarative_extensions import Triggers
+from sqlalchemy_declarative_extensions.dialects.postgresql import Trigger
+from sqlalchemy_declarative_extensions.trigger.compare import (
+    CreateTriggerOp,
+    DropTriggerOp,
+    UpdateTriggerOp,
+    compare_triggers,
+)
+
+
+def trigger(on: str, event: str = "insert"):
+    return Trigger.after(event, on=on, execute="gimme").named("on_change")
+
+
+def test_same_name_on_different_tables_matches_existing(monkeypatch):
+    expected = Triggers().are(trigger("foo"), trigger("bar"))
+    monkeypatch.setattr(
+        "sqlalchemy_declarative_extensions.trigger.compare.get_triggers",
+        Mock(return_value=list(expected)),
+    )
+
+    assert compare_triggers(Mock(), expected) == []
+
+
+def test_same_name_on_different_table_is_created(monkeypatch):
+    foo_trigger = trigger("foo")
+    bar_trigger = trigger("bar")
+    expected = Triggers().are(foo_trigger, bar_trigger)
+    monkeypatch.setattr(
+        "sqlalchemy_declarative_extensions.trigger.compare.get_triggers",
+        Mock(return_value=[foo_trigger]),
+    )
+
+    assert compare_triggers(Mock(), expected) == [CreateTriggerOp(bar_trigger)]
+
+
+def test_same_name_updates_only_trigger_on_matching_table(monkeypatch):
+    foo_trigger = trigger("foo")
+    old_bar_trigger = trigger("bar")
+    new_bar_trigger = trigger("bar", event="update")
+    expected = Triggers().are(foo_trigger, new_bar_trigger)
+    monkeypatch.setattr(
+        "sqlalchemy_declarative_extensions.trigger.compare.get_triggers",
+        Mock(return_value=[foo_trigger, old_bar_trigger]),
+    )
+
+    assert compare_triggers(Mock(), expected) == [
+        UpdateTriggerOp(old_bar_trigger, new_bar_trigger)
+    ]
+
+
+def test_same_name_drops_only_trigger_on_unspecified_table(monkeypatch):
+    foo_trigger = trigger("foo")
+    bar_trigger = trigger("bar")
+    expected = Triggers().are(foo_trigger)
+    monkeypatch.setattr(
+        "sqlalchemy_declarative_extensions.trigger.compare.get_triggers",
+        Mock(return_value=[foo_trigger, bar_trigger]),
+    )
+
+    assert compare_triggers(Mock(), expected) == [DropTriggerOp(bar_trigger)]