flask-postgresql-audit 1.1.1__tar.gz → 1.1.2__tar.gz

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/.gitignore

@@ -67,3 +67,4 @@ uv.lock
 
 # Agents
 .agents
+AGENTS.md

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/CHANGES.md

@@ -3,6 +3,12 @@
 Here you can see the full list of changes between each Flask-PostgreSQL-Audit
 release.
 
+## 1.1.2 (2026-08-21)
+
+-   Add dedicated `jsonb_array_subtract()` function to support set difference operations on JSONB arrays.
+-   Add unit tests for `DocumentStaging` and `PGAggregate` extensions.
+-   Add `reorder_migration_ops` troubleshooting guide to `README.md`.
+
 ## 1.1.1 (2026-08-08)
 
 -   Fix test teardown downgrade error in migration listener.

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: flask-postgresql-audit
-Version: 1.1.1
+Version: 1.1.2
 Summary: Versioning and auditing extension for PostgreSQL and SQLAlchemy.
 Project-URL: Homepage, https://github.com/higamigu/flask-postgresql-audit
 Author-email: Higamigu <higamigu@gmail.com>, Konsta Vesterinen <konsta@fastmonkeys.com>
@@ -245,6 +245,29 @@ The `fetch_activity()` method works with:
 - A single instance: `audit.fetch_activity(my_instance)`
 - Multiple instances: `audit.fetch_activity([instance1, instance2])`
 
+### Migration dependency or trigger ordering issues?
+
+If Alembic migration generation creates triggers before tables or schema dependencies:
+
+Use `reorder_migration_ops` and `chain_revision_directives` in `alembic/env.py`:
+
+```python
+from flask_postgresql_audit.alembic import (
+    chain_revision_directives,
+    reorder_migration_ops,
+)
+
+context.configure(
+    connection=connection,
+    target_metadata=target_metadata,
+    include_schemas=True,
+    process_revision_directives=chain_revision_directives(
+        reorder_migration_ops,
+        process_revision_directives,
+    ),
+)
+```
+
 ## Extensions
 
 ### Document Staging

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/README.md

@@ -218,6 +218,29 @@ The `fetch_activity()` method works with:
 - A single instance: `audit.fetch_activity(my_instance)`
 - Multiple instances: `audit.fetch_activity([instance1, instance2])`
 
+### Migration dependency or trigger ordering issues?
+
+If Alembic migration generation creates triggers before tables or schema dependencies:
+
+Use `reorder_migration_ops` and `chain_revision_directives` in `alembic/env.py`:
+
+```python
+from flask_postgresql_audit.alembic import (
+    chain_revision_directives,
+    reorder_migration_ops,
+)
+
+context.configure(
+    connection=connection,
+    target_metadata=target_metadata,
+    include_schemas=True,
+    process_revision_directives=chain_revision_directives(
+        reorder_migration_ops,
+        process_revision_directives,
+    ),
+)
+```
+
 ## Extensions
 
 ### Document Staging

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/flask_postgresql_audit/__init__.py

@@ -1,4 +1,4 @@
 # ruff: noqa: F401
 from .core import Audit, PostgreSQLAudit
 
-__version__ = "1.1.1"
+__version__ = "1.1.2"

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/flask_postgresql_audit/alembic/entities.py

@@ -81,3 +81,12 @@ def jsonb_subtract_factory(**context):
         signature="jsonb_subtract(arg1 jsonb, arg2 jsonb)",
         definition=sql["definition"],
     )
+
+
+def jsonb_array_subtract_factory(**context):
+    sql = parse_template("jsonb_array_subtract.sql", **context)
+    return PGFunction(
+        schema=context["schema_name"],
+        signature="jsonb_array_subtract(arg1 jsonb, arg2 jsonb)",
+        definition=sql["definition"],
+    )

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/flask_postgresql_audit/alembic/setup.py

@@ -128,6 +128,7 @@ def register_core_entities(audit: "PostgreSQLAudit"):
     audit.pg_audit_entities.add(entities.get_table_relid(**audit.context))
     audit.pg_audit_entities.add(entities.get_setting_factory(**audit.context))
     audit.pg_audit_entities.add(entities.jsonb_subtract_factory(**audit.context))
+    audit.pg_audit_entities.add(entities.jsonb_array_subtract_factory(**audit.context))
     audit.pg_audit_entities.add(entities.create_activity_factory(**audit.context))
 
 

flask_postgresql_audit-1.1.2/flask_postgresql_audit/templates/jsonb_array_subtract.sql

@@ -0,0 +1,29 @@
+CREATE FUNCTION ${schema_prefix}jsonb_array_subtract(arg1 jsonb, arg2 jsonb) RETURNS jsonb AS $$
+SELECT
+    CASE
+        WHEN jsonb_typeof(arg1) = 'array' THEN
+            COALESCE(
+                (
+                    SELECT jsonb_agg(elem ORDER BY ord)
+                    FROM jsonb_array_elements(arg1) WITH ORDINALITY AS t(elem, ord)
+                    WHERE NOT (
+                        CASE
+                            WHEN arg2 IS NULL THEN FALSE
+                            WHEN jsonb_typeof(arg2) = 'array' THEN
+                                EXISTS (
+                                    SELECT 1
+                                    FROM jsonb_array_elements(arg2) AS old_elem
+                                    WHERE old_elem = elem
+                                )
+                            ELSE elem = arg2
+                        END
+                    )
+                ),
+                '[]'::jsonb
+            )
+        WHEN arg1 IS DISTINCT FROM arg2 THEN
+            arg1
+        ELSE
+            NULL
+    END
+$$ LANGUAGE SQL;

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/tests/app.py

@@ -7,6 +7,12 @@ from sqlalchemy import Table
 from sqlalchemy.orm import Mapped, mapped_column
 
 from flask_postgresql_audit import Audit, PostgreSQLAudit
+from flask_postgresql_audit.extensions.document_staging import (
+    DocumentStaging,
+    attach_listener,
+)
+
+attach_listener(actor_id_getter=lambda: "test_actor")
 
 
 class DefaultConfig:
@@ -52,6 +58,12 @@ class Article(BaseModel, Audit):
     name: Mapped[str]
 
 
+class Document(BaseModel, DocumentStaging, Audit):
+    __tablename__ = "document"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    title: Mapped[str]
+
+
 app = Flask(__name__)
 
 app.config.from_object(DefaultConfig)

flask_postgresql_audit-1.1.2/tests/test_document_staging.py

@@ -0,0 +1,106 @@
+import pytest
+
+from flask_postgresql_audit.extensions.document_staging import Docstatus
+
+from .app import Document, db
+
+
+@pytest.mark.usefixtures("test_client")
+class TestDocumentStaging:
+    def test_document_creation(self):
+        doc = Document(title="Doc 1")
+        db.session.add(doc)
+        db.session.commit()
+
+        assert doc.docstatus == Docstatus.DRAFT
+        assert doc.created_by == "test_actor"
+        assert doc.created_on is not None
+
+    def test_document_bump_lifecycle(self):
+        doc = Document(title="Doc 2")
+        db.session.add(doc)
+        db.session.commit()
+
+        # DRAFT -> SUBMITTED
+        doc.bump()
+        db.session.commit()
+        assert doc.docstatus == Docstatus.SUBMITTED
+        assert doc.submitted_by == "test_actor"
+        assert doc.submitted_on is not None
+
+        # SUBMITTED -> CANCELLED
+        doc.bump()
+        db.session.commit()
+        assert doc.docstatus == Docstatus.CANCELLED
+        assert doc.cancelled_by == "test_actor"
+        assert doc.cancelled_on is not None
+
+        # Bumping CANCELLED raises ValueError
+        with pytest.raises(ValueError, match="cannot be bumped"):
+            doc.bump()
+
+    def test_document_revise(self):
+        doc1 = Document(title="Original")
+        db.session.add(doc1)
+        db.session.commit()
+
+        # Cannot revise DRAFT
+        with pytest.raises(ValueError, match="cannot be revised"):
+            doc1.revise(Document(title="V2"))
+
+        doc1.bump()  # SUBMITTED
+        doc1.bump()  # CANCELLED
+        db.session.commit()
+
+        doc2 = Document(title="V2")
+        revised_doc = doc1.revise(doc2)
+        db.session.add(revised_doc)
+        db.session.commit()
+
+        assert doc1.docstatus == Docstatus.REVISED
+        assert doc1.revision == doc2
+        assert doc2.revision_of == doc1
+        assert doc2.docstatus == Docstatus.DRAFT
+
+    def test_document_delete(self):
+        # Delete DRAFT
+        doc = Document(title="Draft to delete")
+        db.session.add(doc)
+        db.session.commit()
+        doc_id = doc.id
+
+        doc.delete(db.session)
+        db.session.commit()
+
+        assert db.session.get(Document, doc_id) is None
+
+        # Delete non-DRAFT raises ValueError
+        doc_submitted = Document(title="Submitted")
+        db.session.add(doc_submitted)
+        db.session.commit()
+        doc_submitted.bump()
+        db.session.commit()
+
+        with pytest.raises(ValueError, match="cannot be deleted"):
+            doc_submitted.delete(db.session)
+
+    def test_delete_revision_reverts_parent_status(self):
+        doc1 = Document(title="Original")
+        db.session.add(doc1)
+        db.session.commit()
+        doc1.bump()
+        doc1.bump()  # CANCELLED
+        db.session.commit()
+
+        doc2 = Document(title="V2 Revision")
+        doc1.revise(doc2)
+        db.session.add(doc2)
+        db.session.commit()
+
+        assert doc1.docstatus == Docstatus.REVISED
+
+        # Delete revision doc2
+        doc2.delete(db.session)
+        db.session.commit()
+
+        assert doc1.docstatus == Docstatus.CANCELLED

{flask_postgresql_audit-1.1.1 → flask_postgresql_audit-1.1.2}/tests/test_operators.py

@@ -31,3 +31,35 @@ def test_jsonb_subtract(test_client, old, new, result):
         )
         == result
     )
+
+
+JSONB_ARRAY_SUBTRACT = (
+    "SELECT {schema}jsonb_array_subtract((:arg1)::jsonb, (:arg2)::jsonb)"
+)
+
+
+@pytest.mark.parametrize(
+    ("arg1", "arg2", "result"),
+    (
+        ([1, 2, 3], [2], [1, 3]),
+        ([1, 2, 3], [1, 2, 3], []),
+        ([1, 2, 3], [4, 5], [1, 2, 3]),
+        (["a", "b", "c"], ["b"], ["a", "c"]),
+        ([], [1, 2], []),
+        ([1, 2], [], [1, 2]),
+        ([1, 2, 2, 3], [2], [1, 3]),
+        ([{"a": 1}, {"b": 2}], [{"a": 1}], [{"b": 2}]),
+        ([1, 2, 3], 2, [1, 3]),
+        ([1, 2, 3], None, [1, 2, 3]),
+        ([1, 2], {"a": 1}, [1, 2]),
+        ({"a": 1}, [1, 2], {"a": 1}),
+    ),
+)
+def test_jsonb_array_subtract(test_client, arg1, arg2, result):
+    assert (
+        db.session.scalar(
+            text(JSONB_ARRAY_SUBTRACT.format(schema=audit.context["schema_prefix"])),
+            {"arg1": json.dumps(arg1), "arg2": json.dumps(arg2)},
+        )
+        == result
+    )

flask_postgresql_audit-1.1.2/tests/test_pg_aggregate.py

@@ -0,0 +1,96 @@
+import pytest
+from alembic_utils.exceptions import SQLParseFailure
+from sqlalchemy import text
+
+from flask_postgresql_audit.extensions.alembic_utils import PGAggregate
+from tests.app import audit, db
+
+
+@pytest.mark.usefixtures("test_client")
+class TestPGAggregate:
+    def test_properties_and_signatures(self):
+        agg = PGAggregate(
+            schema="public",
+            signature="custom_sum(numeric)",
+            definition="(SFUNC = numeric_add, STYPE = numeric, INITCOND = '0')",
+        )
+        assert agg.type_ == "aggregate"
+        assert agg.literal_signature == '"custom_sum"(numeric)'
+
+    def test_from_sql_parsing(self):
+        sql = "CREATE AGGREGATE public.custom_sum(numeric) (SFUNC = numeric_add, STYPE = numeric, INITCOND = '0')"
+        agg = PGAggregate.from_sql(sql)
+
+        assert agg.schema == "public"
+        assert agg.signature == "custom_sum(numeric)"
+        assert (
+            agg.definition == "(SFUNC = numeric_add, STYPE = numeric, INITCOND = '0')"
+        )
+
+        # Quoted signature in SQL
+        sql_quoted = 'CREATE AGGREGATE public."custom_sum"(numeric) (SFUNC = numeric_add, STYPE = numeric)'
+        agg_quoted = PGAggregate.from_sql(sql_quoted)
+        assert agg_quoted.signature == "custom_sum(numeric)"
+
+        # Invalid SQL raises SQLParseFailure
+        with pytest.raises(SQLParseFailure):
+            PGAggregate.from_sql("INVALID SQL STATEMENT")
+
+    def test_sql_statement_generation(self):
+        agg = PGAggregate(
+            schema="public",
+            signature="custom_sum(numeric)",
+            definition="(SFUNC = numeric_add, STYPE = numeric)",
+        )
+
+        create_sql = str(agg.to_sql_statement_create())
+        assert (
+            create_sql
+            == 'CREATE AGGREGATE "public"."custom_sum"(numeric) (SFUNC = numeric_add, STYPE = numeric)'
+        )
+
+        create_or_replace = list(agg.to_sql_statement_create_or_replace())
+        assert len(create_or_replace) == 1
+        assert (
+            str(create_or_replace[0])
+            == 'CREATE OR REPLACE AGGREGATE "public"."custom_sum"(numeric) (SFUNC = numeric_add, STYPE = numeric)'
+        )
+
+        drop_sql = str(agg.to_sql_statement_drop())
+        assert drop_sql == 'DROP AGGREGATE "public"."custom_sum"(numeric)'
+
+        drop_cascade_sql = str(agg.to_sql_statement_drop(cascade=True))
+        assert (
+            drop_cascade_sql == 'DROP AGGREGATE "public"."custom_sum"(numeric) CASCADE'
+        )
+
+    def test_from_database(self):
+        schema = audit.context["schema_name"]
+        prefix = audit.context["schema_prefix"]
+
+        # Create temporary custom aggregate in DB
+        db.session.execute(
+            text(
+                f"""
+                CREATE OR REPLACE AGGREGATE {prefix}test_sum(numeric) (
+                    SFUNC = numeric_add,
+                    STYPE = numeric,
+                    INITCOND = '0'
+                );
+                """
+            )
+        )
+        db.session.commit()
+
+        try:
+            aggregates = PGAggregate.from_database(db.session, schema=schema)  # type: ignore
+            matching = [
+                a for a in aggregates if a.identity.endswith("test_sum(numeric)")
+            ]
+            assert len(matching) == 1
+            assert matching[0].schema == schema
+        finally:
+            db.session.execute(
+                text(f"DROP AGGREGATE IF EXISTS {prefix}test_sum(numeric);")
+            )
+            db.session.commit()