graphddb-runtime 0.2.1__tar.gz → 0.2.3__tar.gz

{graphddb_runtime-0.2.1 → graphddb_runtime-0.2.3}/PKG-INFO

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

{graphddb_runtime-0.2.1 → graphddb_runtime-0.2.3}/graphddb_runtime/runtime.py

@@ -1649,6 +1649,17 @@ class GraphDDBRuntime:
             values[v] = self._serializer.serialize(resolve_template(tmpl, params))
             sets.append(f"{n} = {v}")
 
+        # GSI key re-derivation (issue #115): an UpdateItem that changes a GSI's
+        # composing field MUST re-derive its `<index>PK`/`<index>SK` or the index
+        # silently rots — exactly as the TS `buildUpdateInput` does. The available
+        # values are the caller `params` (key fields ∪ change fields); a GSI is
+        # affected when at least one of its template placeholders is a changed
+        # field. An affected GSI whose composing fields are not all available
+        # throws (mirroring the base-table partial-key throw).
+        self._append_gsi_rederive_sets(
+            command_id, spec, params, names, values, sets
+        )
+
         request: Dict[str, Any] = {
             "TableName": self._physical_table(spec["tableName"]),
             "Key": key,
@@ -1660,6 +1671,66 @@ class GraphDDBRuntime:
         self._apply_condition(spec, request, params)
         self._call(command_id, self._client.update_item, request)
 
+    def _append_gsi_rederive_sets(
+        self,
+        command_id: str,
+        spec: Mapping[str, Any],
+        params: Mapping[str, Any],
+        names: Dict[str, str],
+        values: Dict[str, Any],
+        sets: List[str],
+    ) -> None:
+        """Re-derive every affected GSI key into the UpdateExpression (issue #115).
+
+        Mirrors the TS ``buildUpdateInput``: a GSI is *affected* when at least one
+        of its ``inputFields`` is a changed field; an affected GSI re-derives its
+        ``<index>PK``/``<index>SK`` from the available caller params (key fields ∪
+        change fields). An affected GSI whose ``inputFields`` are not all available
+        throws — the SAME explicit error the TS path raises — rather than letting
+        the index silently rot.
+        """
+        entity_meta = self._entities.get(spec.get("entity"), {})
+        gsis = entity_meta.get("gsis", [])
+        if not gsis:
+            return
+        changed = set(spec.get("changes", {}).keys())
+        if not changed:
+            return
+        # Available value map: caller params with a non-None value.
+        available = {k: v for k, v in params.items() if v is not None}
+        gsi_index = 0
+        for gsi in gsis:
+            input_fields = list(gsi.get("inputFields", []))
+            if not any(f in changed for f in input_fields):
+                continue  # unaffected GSI — never touched (non-regression).
+            missing = [f for f in input_fields if f not in available]
+            if missing:
+                changed_in_gsi = [f for f in input_fields if f in changed]
+                raise GraphDDBError(
+                    f"{command_id}: updating "
+                    f"{', '.join(repr(f) for f in changed_in_gsi)} affects index "
+                    f"'{gsi['indexName']}' (also depends on "
+                    f"{', '.join(repr(f) for f in missing)}); provide "
+                    f"{'them' if len(missing) > 1 else 'it'}, or use "
+                    f"read-modify-write."
+                )
+            index = gsi["indexName"]
+            pk_tmpl = gsi.get("pkTemplate")
+            sk_tmpl = gsi.get("skTemplate")
+            if pk_tmpl is not None:
+                n = f"#gsi{gsi_index}pk"
+                v = f":gsi{gsi_index}pk"
+                names[n] = f"{index}PK"
+                values[v] = self._serializer.serialize(self._fill(pk_tmpl, available))
+                sets.append(f"{n} = {v}")
+            if sk_tmpl is not None:
+                n = f"#gsi{gsi_index}sk"
+                v = f":gsi{gsi_index}sk"
+                names[n] = f"{index}SK"
+                values[v] = self._serializer.serialize(self._fill(sk_tmpl, available))
+                sets.append(f"{n} = {v}")
+            gsi_index += 1
+
     def _run_delete_item(
         self, command_id: str, spec: Mapping[str, Any], params: Mapping[str, Any]
     ) -> None:

{graphddb_runtime-0.2.1 → graphddb_runtime-0.2.3}/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.1 → graphddb_runtime-0.2.3}/graphddb_runtime.egg-info/PKG-INFO

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

{graphddb_runtime-0.2.1 → graphddb_runtime-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "0.2.1"
+version = "0.2.3"
 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.1 → graphddb_runtime-0.2.3}/tests/test_unit.py

@@ -231,6 +231,54 @@ def test_update_item_builds_set_expression():
     assert plain(req["ExpressionAttributeValues"]) == {":c0": "disabled"}
 
 
+def test_update_item_rederives_affected_gsi_key():
+    # #115: setOrderStatus changes `status` (a GSI1 composing field). With
+    # `tenantId` also supplied, GSI1's composing fields {tenantId, status, orderId}
+    # are all available, so the update re-derives GSI1PK/GSI1SK in the SAME
+    # UpdateExpression — the index follows the row instead of rotting.
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt.execute_command(
+        "setOrderStatus",
+        {"orderId": "o1", "tenantId": "t1", "status": "SHIPPED"},
+    )
+    method, req = client.calls[0]
+    assert method == "update_item"
+    names = req["ExpressionAttributeNames"]
+    values = plain(req["ExpressionAttributeValues"])
+    # The status SET plus the re-derived GSI key attributes.
+    assert "status" in names.values()
+    gsi_pk_alias = next(a for a, n in names.items() if n == "GSI1PK")
+    gsi_sk_alias = next(a for a, n in names.items() if n == "GSI1SK")
+    assert f"{gsi_pk_alias} = " in req["UpdateExpression"]
+    pk_val_alias = req["UpdateExpression"].split(f"{gsi_pk_alias} = ")[1].split()[0].rstrip(",")
+    sk_val_alias = req["UpdateExpression"].split(f"{gsi_sk_alias} = ")[1].split()[0].rstrip(",")
+    assert values[pk_val_alias] == "TENANT#t1#STATUS#SHIPPED"
+    assert values[sk_val_alias] == "ORDER#o1"
+
+
+def test_update_item_throws_when_gsi_field_unavailable():
+    # #115: status alone affects GSI1 but tenantId is missing → explicit throw.
+    from graphddb_runtime.errors import GraphDDBError
+
+    client = FakeClient()
+    rt = make_runtime(client)
+    with pytest.raises(GraphDDBError, match=r"affects index 'GSI1'.*depends on 'tenantId'"):
+        rt.execute_command("setOrderStatusBad", {"orderId": "o1", "status": "SHIPPED"})
+    assert client.calls == []  # nothing written
+
+
+def test_update_item_does_not_touch_unaffected_gsi():
+    # #115 non-regression: disableUser changes `status` on a User whose GSI1 is
+    # keyed by `email` (status is NOT a composing field), so NO GSI re-derivation.
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt.execute_command("disableUser", {"userId": "alice", "status": "disabled"})
+    _method, req = client.calls[0]
+    assert "GSI1PK" not in req["ExpressionAttributeNames"].values()
+    assert req["UpdateExpression"] == "SET #c0 = :c0"
+
+
 def test_put_item_injects_key_attributes():
     client = FakeClient()
     rt = make_runtime(client)
@@ -722,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