graphddb-runtime 0.2.2__tar.gz → 0.2.4__tar.gz

{graphddb_runtime-0.2.2 → graphddb_runtime-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 0.2.2
+Version: 0.2.4
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-0.2.2 → graphddb_runtime-0.2.4}/graphddb_runtime/transactions.py

@@ -251,6 +251,12 @@ def _collapse_same_key_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]
     the ADD — the exact silent-drop #93 forbids — so this and any other unhandled same-key
     op combination raise rather than collapse.
 
+    The ``Delete``+``Put`` and ``Put``+``Update`` branches each require the bucket be EXACTLY
+    that pair (no third op kind). A 3-way ``Delete``+``Put``+``Update`` collision (a
+    hand-written self-contradictory transaction that deletes, puts, AND increments one row)
+    is therefore NOT absorbed by the swap no-op nor the Put+Update reject — it reaches the
+    catch-all loud reject below rather than silently dropping the ``Update`` (issue #96).
+
     A genuine swap (``old != new``) resolves to two distinct keys, so both survive.
     First-seen order is preserved (a merged ADD takes the position of the FIRST update
     in its bucket), so the output is identical to the TS runtimes' for the same SSoT.
@@ -267,11 +273,17 @@ def _collapse_same_key_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]
             out.append(item)
             continue
         kinds = {_item_kind(b) for b in bucket}
-        if "Delete" in kinds and "Put" in kinds:
-            # Swap pair resolved to one key → net no-op: drop EVERY member at this key.
+        if kinds == {"Delete", "Put"}:
+            # EXACTLY {Delete, Put} — a swap pair resolved to one key → net no-op: drop
+            # EVERY member at this key. The exact-set guard is load-bearing: a 3-way bucket
+            # that ALSO carries an Update (a hand-written self-contradictory transaction
+            # that deletes, puts, AND increments the SAME row) is NOT a swap no-op —
+            # dropping it here would silently swallow the Update. Such a 3-way collision
+            # falls through to the catch-all reject below (issue #96).
             continue
-        if "Put" in kinds and "Update" in kinds:
-            # Base entity Put + derived counter Update(ADD) on the SAME row (issue #93,
+        if kinds == {"Put", "Update"}:
+            # EXACTLY {Put, Update}: base entity Put + derived counter Update(ADD) on the
+            # SAME row (issue #93,
             # the aliased self-target that evades the build-time guard). A Put+Update on
             # one item is unsupported (DynamoDB rejects touching one key twice) and
             # collapsing it would silently drop the increment — FAIL LOUDLY instead.

{graphddb_runtime-0.2.2 → graphddb_runtime-0.2.4}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 0.2.2
+Version: 0.2.4
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-0.2.2 → graphddb_runtime-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "0.2.2"
+version = "0.2.4"
 description = "Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44)."
 readme = "README.md"
 requires-python = ">=3.9"

{graphddb_runtime-0.2.2 → graphddb_runtime-0.2.4}/tests/test_unit.py

@@ -770,6 +770,61 @@ def test_collapse_unhandled_same_key_combination_rejects_loudly():
         _collapse_same_key_items([delete, update])
 
 
+def test_collapse_three_way_delete_put_update_rejects_loudly():
+    """A 3-way ``Delete``+``Put``+``Update`` on ONE physical row (a hand-written
+    self-contradictory transaction that deletes, puts, AND increments the same row).
+    Pre-#96 the ``Delete``+``Put`` swap no-op branch fired first and silently dropped the
+    ``Update`` too. The shared rule now requires that branch be EXACTLY {Delete, Put}, so the
+    3-way falls through to the catch-all loud reject. Mirrors the TS ``collapseSameKey``."""
+    import pytest
+    from graphddb_runtime.transactions import _collapse_same_key_items
+
+    delete = _delete("T", "GROUP#eng", "META")
+    put = _put("T", "GROUP#eng", "META")  # SAME key
+    add = _add_update("T", "GROUP#eng", "META", "memberCount", 1)  # SAME key — the Update
+    with pytest.raises(ValueError, match=r"unsupported op combination \(Delete\+Put\+Update\)"):
+        _collapse_same_key_items([delete, put, add])
+
+
+def test_expand_three_way_delete_put_update_rejects_loudly():
+    """End-to-end through ``TransactionExpander.expand`` (the public, spec-driven path, the
+    Python mirror of the TS ``expandTransaction``): a 3-way ``Delete``+``Put``+``Update``
+    resolving to ONE marker row must throw rather than silently drop the ``Update`` (#96)."""
+    import pytest
+    from graphddb_runtime.transactions import TransactionExpander
+
+    rt = make_runtime(FakeClient())
+    expander = TransactionExpander(rt)
+    spec = {
+        "items": [
+            {
+                "type": "Delete",
+                "tableName": "UniqTbl",
+                "entity": "__marker__",
+                "literalKey": True,
+                "keyCondition": {"PK": "ROW#{rowId}", "SK": "META"},
+            },
+            {
+                "type": "Put",
+                "tableName": "UniqTbl",
+                "entity": "__marker__",
+                "literalKey": True,
+                "item": {"PK": "ROW#{rowId}", "SK": "META"},
+            },
+            {
+                "type": "Update",
+                "tableName": "UniqTbl",
+                "entity": "__marker__",
+                "literalKey": True,
+                "keyCondition": {"PK": "ROW#{rowId}", "SK": "META"},
+                "add": {"hits": "1"},
+            },
+        ]
+    }
+    with pytest.raises(ValueError, match=r"unsupported op combination \(Delete\+Put\+Update\)"):
+        expander.expand(spec, {"rowId": "r1"})
+
+
 def test_expand_collapses_unchanged_unique_guard_swap_to_no_op():
     """End-to-end through ``TransactionExpander.expand``: a literalKey guard swap whose
     ``old.* == input.*`` collapses to a net no-op, leaving only the base write — the