graphddb-runtime 0.8.1__tar.gz → 0.8.3__tar.gz

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/PKG-INFO

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

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/graphddb_runtime/runtime.py

@@ -54,6 +54,7 @@ from .per_key_cursor import (
 from .relations import RelationAssembler, collect_parents, parse_result_path
 from .templates import (
     resolve_template,
+    _key_field_names,
     validate_params,
 )
 from .transactions import MAX_TRANSACT_ITEMS, TransactionExpander
@@ -2397,22 +2398,32 @@ class GraphDDBRuntime:
         names: Dict[str, str] = {}
         values: Dict[str, Any] = {}
         sets: List[str] = []
+        # Each change's new value is resolved ONCE here and reused for both the SET
+        # clause and the GSI availability map below (they must agree by construction).
+        resolved_changes: Dict[str, Any] = {}
         for i, (field, tmpl) in enumerate(spec.get("changes", {}).items()):
             n = f"#c{i}"
             v = f":c{i}"
             names[n] = field
-            values[v] = self._serializer.serialize(resolve_template(tmpl, params))
+            resolved = resolve_template(tmpl, params)
+            resolved_changes[field] = resolved
+            values[v] = self._serializer.serialize(resolved)
             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).
+        # rots — exactly as the TS `buildUpdateInput` does. A GSI is affected when
+        # at least one of its composing fields is changed. 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
+            command_id,
+            spec.get("entity"),
+            resolved_changes,
+            {f: params[f] for f in _key_field_names(spec.get("keyCondition")) if f in params},
+            names,
+            values,
+            sets,
         )
 
         request: Dict[str, Any] = {
@@ -2437,41 +2448,70 @@ class GraphDDBRuntime:
 
     def _append_gsi_rederive_sets(
         self,
-        command_id: str,
-        spec: Mapping[str, Any],
-        params: Mapping[str, Any],
+        context: str,
+        entity_name: Optional[str],
+        resolved_changes: Mapping[str, Any],
+        available_base: 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).
+        """Re-derive every affected GSI key into an UpdateExpression (issue #115).
+
+        THE single place an update re-derives GSI keys. Both write paths compose
+        through it — the single-op ``UpdateItem`` and the transaction/batch
+        ``Update`` item — so a transacted update can never write a stale index
+        that the equivalent single write would have refreshed (issue #377); the TS
+        side likewise routes both through ``buildUpdateInput``.
 
         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.
+        ``<index>PK``/``<index>SK`` from the available values. An affected GSI whose
+        ``inputFields`` are not all available throws — the SAME explicit error the
+        TS path raises — rather than letting the index rot.
+
+        ``resolved_changes`` are the changed fields' ALREADY-RESOLVED new values
+        (the caller resolved them for the SET clause, so the two agree by
+        construction); ``available_base`` is the surrounding value scope — caller
+        params, plus the fan-out ``element`` fields for a transaction item.
         """
-        entity_meta = self._entities.get(spec.get("entity"), {})
+        entity_meta = self._entities.get(entity_name or "", {})
         gsis = entity_meta.get("gsis", [])
         if not gsis:
             return
-        changed = set(spec.get("changes", {}).keys())
+        changed = set(resolved_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}
+        # Available value map: the surrounding scope (non-None) overlaid with each
+        # change's resolved new value. A changed GSI-composing field thus supplies
+        # its value whether it arrives as a param (``{status}``) or a baked literal
+        # (``running``) — mirroring the TS ``buildUpdateInput``
+        # (``available = { ...keyFields, ...serializedChanges }``, changes win).
+        # Without the overlay a literal-changed field counts as "no value", so the
+        # GSI is never re-derived from it: the write is refused as if the value were
+        # missing — or, where a same-named param exists, the key is composed from
+        # that stale value and the index rots (issue #377).
+        available = {k: v for k, v in available_base.items() if v is not None}
+        available.update(resolved_changes)
         gsi_index = 0
         for gsi in gsis:
+            index = gsi["indexName"]
             input_fields = list(gsi.get("inputFields", []))
             if not any(f in changed for f in input_fields):
                 continue  # unaffected GSI — never touched (non-regression).
+            # An index whose key attributes the update ALREADY sets explicitly is
+            # spoken for: `defineTransaction` derives `<index>PK`/`<index>SK` into
+            # `changes` when the spec is built, and every runtime (TS included)
+            # applies those verbatim. Deriving them again here would SET the same
+            # attribute twice in one UpdateExpression, which DynamoDB rejects as
+            # overlapping document paths.
+            if f"{index}PK" in changed or f"{index}SK" in changed:
+                continue
             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"{context}: 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 "

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/graphddb_runtime/templates.py

@@ -14,7 +14,7 @@ serialized ``Date`` like ``1970-01-01T00:00:00.000Z``).
 from __future__ import annotations
 
 import re
-from typing import Any, Mapping
+from typing import Any, List, Mapping, Optional
 
 from behavior_contracts import TemplateFailure as _TemplateFailure
 from behavior_contracts import render_template as _render_template
@@ -125,6 +125,30 @@ def _check_value(
             )
 
 
+def _key_field_names(key_condition: Optional[Mapping[str, Any]]) -> List[str]:
+    """The entity fields a write's key pins, read off its ``keyCondition`` templates.
+
+    These are the only field values a keyed write KNOWS the row will carry (besides
+    the changes it makes), so they — not the caller's whole param bag — are the base
+    of the GSI availability map (issue #377). A param that merely feeds a write
+    CONDITION says nothing about the row's contents, and composing an index key from
+    it would point the index at a value the row does not have. This matches the TS
+    ``buildUpdateInput``, whose availability base is the update key's fields.
+
+    A fan-out ``{item.field}`` placeholder names the element field, so the leading
+    ``item.`` scope is stripped.
+    """
+    out: List[str] = []
+    for template in (key_condition or {}).values():
+        for match in _PLACEHOLDER.finditer(str(template)):
+            name = match.group(1)
+            if name.startswith("item."):
+                name = name[len("item.") :]
+            if name not in out:
+                out.append(name)
+    return out
+
+
 def has_result_placeholder(template: str) -> bool:
     """True if the template references a prior result (``{result.*}``)."""
     return any(m.group(1).startswith("result.") for m in _PLACEHOLDER.finditer(template))

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/graphddb_runtime/transactions.py

@@ -22,6 +22,7 @@ from behavior_contracts import ExprFailure as _ExprFailure
 from behavior_contracts import evaluate_expression as _evaluate_expression
 
 from .filters import compile_filter
+from .templates import _key_field_names
 
 _PLACEHOLDER_RE = re.compile(r"\{[^{}]+\}")
 _WHOLE_PLACEHOLDER_RE = re.compile(r"^\{[^{}]+\}$")
@@ -717,6 +718,28 @@ class TransactionExpander:
             # template rendered it to a string (the literal `"1"` / `"-1"`).
             values[v] = self._serializer.serialize(int(value) if isinstance(value, str) else value)
             add_clauses.append(f"{n} {v}")
+        # GSI key re-derivation (#377): a transacted `Update` that changes a GSI's
+        # composing field must refresh `<index>PK`/`<index>SK` exactly as the
+        # single-op `UpdateItem` does — otherwise the same logical write leaves a
+        # stale index purely because it rode inside a transaction. Delegates to the
+        # runtime's SINGLE re-derivation helper (no second implementation). The
+        # available scope is `params ∪ element ∪ resolved changes`, so a fan-out
+        # item's `{item.field}` values count as supplied.
+        scope = {**params, **(element or {})}
+        self._rt._append_gsi_rederive_sets(
+            entity_name,
+            entity_name,
+            changes,
+            {
+                f: scope[f]
+                for f in _key_field_names(spec.get("keyCondition"))
+                if f in scope
+            },
+            names,
+            values,
+            sets,
+        )
+
         update: Dict[str, Any] = {"TableName": table, "Key": key}
         expr_parts: List[str] = []
         if sets:

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/graphddb_runtime.egg-info/PKG-INFO

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

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "0.8.1"
+version = "0.8.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.8.1 → graphddb_runtime-0.8.3}/tests/test_integration_command.py

@@ -145,6 +145,92 @@ def test_single_update_applies(rt, client):
     assert _user_status(client, "z") == "disabled"
 
 
+def test_single_update_rederives_gsi_from_literal_change(rt, client):
+    # #377: `setOrderStatusLiteral` carries its new status as a BAKED LITERAL
+    # ('running') inside `changes` — it is NOT a param. `status` composes the GSI1
+    # key, so the UpdateItem must re-derive GSI1PK onto the literal's partition.
+    # Building the GSI availability map from `params` alone counted the
+    # literal-changed field as "no value", so GSI1 was never re-derived from it
+    # and the write was refused as if `status` had not been supplied.
+    key = {"PK": {"S": "ORDER#o377"}, "SK": {"S": "META"}}
+    client.put_item(
+        TableName=TABLE,
+        Item={
+            **key,
+            "orderId": {"S": "o377"},
+            "tenantId": {"S": "t377"},
+            "status": {"S": "pending"},
+            "GSI1PK": {"S": "TENANT#t377#STATUS#pending"},
+            "GSI1SK": {"S": "ORDER#o377"},
+        },
+    )
+
+    rt.execute_command(
+        "OrderConfCommands__setOrderStatusLiteral",
+        {"orderId": "o377", "tenantId": "t377"},
+    )
+
+    item = client.get_item(TableName=TABLE, Key=key)["Item"]
+    assert item["status"]["S"] == "running"
+    # The GSI key followed the row onto the literal's partition.
+    assert item["GSI1PK"]["S"] == "TENANT#t377#STATUS#running"
+    assert item["GSI1SK"]["S"] == "ORDER#o377"
+
+    # …and the index really resolves the row under the NEW partition, while the
+    # stale partition no longer does (the index did not rot).
+    def _by_gsi(pk):
+        return client.query(
+            TableName=TABLE,
+            IndexName="GSI1",
+            KeyConditionExpression="GSI1PK = :pk",
+            ExpressionAttributeValues={":pk": {"S": pk}},
+        )["Items"]
+
+    assert [i["orderId"]["S"] for i in _by_gsi("TENANT#t377#STATUS#running")] == ["o377"]
+    assert _by_gsi("TENANT#t377#STATUS#pending") == []
+
+
+def test_transacted_update_rederives_gsi_from_literal_change(rt, client):
+    # #377, the reporter's actual path: a multi-write body compiles to
+    # TransactWriteItems, and the transaction expanders derived GSI keys for `Put`
+    # only — so a transacted update committed a row whose GSI1PK still named the
+    # OLD partition, silently and with no error, while the identical single-key
+    # write refreshed it.
+    key = {"PK": {"S": "ORDER#o377tx"}, "SK": {"S": "META"}}
+    client.put_item(
+        TableName=TABLE,
+        Item={
+            **key,
+            "orderId": {"S": "o377tx"},
+            "tenantId": {"S": "t377tx"},
+            "status": {"S": "pending"},
+            "GSI1PK": {"S": "TENANT#t377tx#STATUS#pending"},
+            "GSI1SK": {"S": "ORDER#o377tx"},
+        },
+    )
+
+    rt.execute_transaction(
+        "OrderConfCommands__setOrderStatusLiteral__batch",
+        {"tenantId": "t377tx", "keys": [{"orderId": "o377tx"}]},
+    )
+
+    item = client.get_item(TableName=TABLE, Key=key)["Item"]
+    assert item["status"]["S"] == "running"
+    assert item["GSI1PK"]["S"] == "TENANT#t377tx#STATUS#running"
+    assert item["GSI1SK"]["S"] == "ORDER#o377tx"
+
+    def _by_gsi(pk):
+        return client.query(
+            TableName=TABLE,
+            IndexName="GSI1",
+            KeyConditionExpression="GSI1PK = :pk",
+            ExpressionAttributeValues={":pk": {"S": pk}},
+        )["Items"]
+
+    assert [i["orderId"]["S"] for i in _by_gsi("TENANT#t377tx#STATUS#running")] == ["o377tx"]
+    assert _by_gsi("TENANT#t377tx#STATUS#pending") == []
+
+
 def test_single_put_then_delete(rt, client):
     rt.execute_command_method(
         "MembershipCommands",

{graphddb_runtime-0.8.1 → graphddb_runtime-0.8.3}/tests/test_unit.py

@@ -257,6 +257,156 @@ def test_update_item_rederives_affected_gsi_key():
     assert values[sk_val_alias] == "ORDER#o1"
 
 
+def test_update_item_rederives_affected_gsi_key_from_literal_change():
+    # #377: setOrderStatusLiteral bakes `status` as the LITERAL 'running' — the new
+    # value rides in `changes` and is NOT a param. `status` composes GSI1, so the
+    # update MUST still re-derive GSI1PK/GSI1SK from that literal. Building the
+    # availability map from `params` alone counted the literal-changed field as
+    # "no value", so GSI1 was never re-derived from it and the write was refused
+    # outright — demanding a `status` the command already supplies.
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt.execute_command(
+        "OrderConfCommands__setOrderStatusLiteral",
+        {"orderId": "o1", "tenantId": "t1"},
+    )
+    method, req = client.calls[0]
+    assert method == "update_item"
+    names = req["ExpressionAttributeNames"]
+    values = plain(req["ExpressionAttributeValues"])
+    expr = req["UpdateExpression"]
+    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")
+    pk_val_alias = expr.split(f"{gsi_pk_alias} = ")[1].split()[0].rstrip(",")
+    sk_val_alias = expr.split(f"{gsi_sk_alias} = ")[1].split()[0].rstrip(",")
+    # The GSI partition key carries the LITERAL new status, not a stale/empty one.
+    assert values[pk_val_alias] == "TENANT#t1#STATUS#running"
+    assert values[sk_val_alias] == "ORDER#o1"
+    # …and the literal is what the row itself is set to.
+    status_alias = next(a for a, n in names.items() if n == "status")
+    status_val_alias = expr.split(f"{status_alias} = ")[1].split()[0].rstrip(",")
+    assert values[status_val_alias] == "running"
+
+
+def test_update_item_gsi_prefers_literal_change_over_same_named_param():
+    # #377, the genuinely SILENT shape: a GSI-composing field is set by a LITERAL
+    # change while a param of the SAME name carries a different (stale) value — as a
+    # W1 `write.before` hook's injected change produces. There is nothing "missing",
+    # so no error is raised; the availability map just had to choose. Building it
+    # from `params` alone chose the STALE param, quietly writing GSI1PK
+    # =TENANT#t1#STATUS#STALE while the row's status became 'running' — the index
+    # pointed at a partition the row was no longer in. The change must win.
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt._commands["OrderConfCommands__setOrderStatusStale"] = {
+        "type": "UpdateItem",
+        "tableName": "UserPermissions",
+        "entity": "OrderModel",
+        "params": {
+            "orderId": {"type": "string", "required": True},
+            "tenantId": {"type": "string", "required": True},
+            "status": {"type": "string", "required": True},
+        },
+        "keyCondition": {"PK": "ORDER#{orderId}", "SK": "META"},
+        "changes": {"status": "running", "tenantId": "{tenantId}"},
+    }
+    rt.execute_command(
+        "OrderConfCommands__setOrderStatusStale",
+        {"orderId": "o1", "tenantId": "t1", "status": "STALE"},
+    )
+    _method, req = client.calls[0]
+    names = req["ExpressionAttributeNames"]
+    values = plain(req["ExpressionAttributeValues"])
+    expr = req["UpdateExpression"]
+    gsi_pk_alias = next(a for a, n in names.items() if n == "GSI1PK")
+    pk_val_alias = expr.split(f"{gsi_pk_alias} = ")[1].split()[0].rstrip(",")
+    assert values[pk_val_alias] == "TENANT#t1#STATUS#running"
+
+
+def test_update_item_rederives_sort_key_and_every_affected_gsi_from_a_literal():
+    # #377: a literal change must re-derive an index's SORT key too, and an entity
+    # with SEVERAL indexes must re-derive every affected one (the shipped fixture
+    # entities all have exactly one GSI, so neither the `<index>SK`-from-literal
+    # path nor the per-index alias numbering was covered). Here `status` composes
+    # GSI1's PK and GSI2's SK, so one literal change moves both.
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt._entities["TwoIndexOrderModel"] = {
+        "gsis": [
+            {
+                "indexName": "GSI1",
+                "inputFields": ["tenantId", "status", "orderId"],
+                "pkTemplate": "TENANT#{tenantId}#STATUS#{status}",
+                "skTemplate": "ORDER#{orderId}",
+            },
+            {
+                "indexName": "GSI2",
+                "inputFields": ["tenantId", "status"],
+                "pkTemplate": "TENANT#{tenantId}",
+                "skTemplate": "STATUS#{status}",
+            },
+        ]
+    }
+    rt._commands["TwoIndexOrder__setStatusLiteral"] = {
+        "type": "UpdateItem",
+        "tableName": "UserPermissions",
+        "entity": "TwoIndexOrderModel",
+        "params": {
+            "orderId": {"type": "string", "required": True},
+            "tenantId": {"type": "string", "required": True},
+        },
+        "keyCondition": {"PK": "ORDER#{orderId}", "SK": "META"},
+        "changes": {"status": "running", "tenantId": "{tenantId}"},
+    }
+    rt.execute_command(
+        "TwoIndexOrder__setStatusLiteral", {"orderId": "o1", "tenantId": "t1"}
+    )
+    _method, req = client.calls[0]
+    names = req["ExpressionAttributeNames"]
+    values = plain(req["ExpressionAttributeValues"])
+    expr = req["UpdateExpression"]
+
+    def value_of(attr):
+        alias = next(a for a, n in names.items() if n == attr)
+        return values[expr.split(f"{alias} = ")[1].split()[0].rstrip(",")]
+
+    assert value_of("GSI1PK") == "TENANT#t1#STATUS#running"
+    assert value_of("GSI1SK") == "ORDER#o1"
+    # The second index's SORT key is the one the literal moves.
+    assert value_of("GSI2PK") == "TENANT#t1"
+    assert value_of("GSI2SK") == "STATUS#running"
+
+
+def test_update_item_gsi_ignores_params_the_row_does_not_carry():
+    # #377: the availability base is the fields the write KNOWS the row will carry —
+    # its key fields plus its changes — NOT the caller's whole param bag. A param
+    # that only feeds a write condition (here `tenantId`, neither a key field nor a
+    # change) says nothing about the row's contents, so composing GSI1PK from it
+    # would aim the index at a value the row does not have. Matches the TS
+    # `buildUpdateInput`, whose base is the update key's fields: throw instead.
+    from graphddb_runtime.errors import GraphDDBError
+
+    client = FakeClient()
+    rt = make_runtime(client)
+    rt._commands["OrderConfCommands__setOrderStatusCondOnly"] = {
+        "type": "UpdateItem",
+        "tableName": "UserPermissions",
+        "entity": "OrderModel",
+        "params": {
+            "orderId": {"type": "string", "required": True},
+            "tenantId": {"type": "string", "required": True},
+        },
+        "keyCondition": {"PK": "ORDER#{orderId}", "SK": "META"},
+        "changes": {"status": "running"},
+    }
+    with pytest.raises(GraphDDBError, match=r"affects index 'GSI1'.*depends on 'tenantId'"):
+        rt.execute_command(
+            "OrderConfCommands__setOrderStatusCondOnly",
+            {"orderId": "o1", "tenantId": "t1"},
+        )
+    assert client.calls == []  # nothing written
+
+
 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