graphddb-runtime 1.2.5__tar.gz → 1.4.0__tar.gz

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.2.5
+Version: 1.4.0
 Summary: The DynamoDB issuance a GraphDDB behavior module binds: the leaf transports, table mapping, AttributeValue codec and cursor codecs.
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/graphddb_runtime/leaf_handlers.py

@@ -48,6 +48,19 @@ def _key_attrs(index_name: str) -> tuple:
     return (f"{index_name}PK", f"{index_name}SK") if index_name else ("PK", "SK")
 
 
+#: The sort-key predicate of each ``rangeOperator`` ``queryItems`` issues on ``key.sk``
+#: (``between`` reaches up to ``rangeUpper``).
+_SORT_KEY_CLAUSE = {
+    "eq": "#ks = :ks",
+    "begins_with": "begins_with(#ks, :ks)",
+    "lt": "#ks < :ks",
+    "le": "#ks <= :ks",
+    "gt": "#ks > :ks",
+    "ge": "#ks >= :ks",
+    "between": "#ks BETWEEN :ks AND :ku",
+}
+
+
 def _projection_request(projection: List[str]) -> Dict[str, Any]:
     """``ProjectionExpression`` + names for the declared projection.
 
@@ -107,20 +120,30 @@ def leaf_handlers(runtime: Any) -> Dict[str, Callable[..., Mapping[str, Any]]]:
         index_name = ports["indexName"]
         pk_attr, sk_attr = _key_attrs(index_name)
         operator = ports["rangeOperator"]
-        if operator == "begins_with":
-            sk_clause = "begins_with(#ks, :ks)"
-        elif operator == "eq":
-            sk_clause = "#ks = :ks"
-        else:
-            raise GraphDDBError(f"queryItems: unsupported range operator '{operator}'")
+        sk_clause = _SORT_KEY_CLAUSE.get(operator)
+        if sk_clause is None:
+            raise GraphDDBError(
+                f"queryItems: unsupported range operator '{operator}' "
+                f"(expected {', '.join(_SORT_KEY_CLAUSE)})."
+            )
+        upper = ports["rangeUpper"]
+        if operator != "between" and upper != "":
+            raise GraphDDBError(
+                "queryItems: rangeUpper is the upper operand of 'between'; "
+                f"operator '{operator}' takes none."
+            )
+        values = {
+            ":kp": runtime._serializer.serialize(ports["key"]["pk"]),
+            ":ks": runtime._serializer.serialize(ports["key"]["sk"]),
+        }
+        if operator == "between":
+            values[":ku"] = runtime._serializer.serialize(upper)
         request: Dict[str, Any] = {
             "TableName": runtime._physical_table(ports["table"]),
             "KeyConditionExpression": f"#kp = :kp AND {sk_clause}",
             "ExpressionAttributeNames": {"#kp": pk_attr, "#ks": sk_attr},
-            "ExpressionAttributeValues": {
-                ":kp": runtime._serializer.serialize(ports["key"]["pk"]),
-                ":ks": runtime._serializer.serialize(ports["key"]["sk"]),
-            },
+            "ExpressionAttributeValues": values,
+            "ScanIndexForward": ports["scanIndexForward"],
             "Limit": ports["limit"],
         }
         projection = _projection_request(list(ports["projectionFields"]))
@@ -197,7 +220,7 @@ def leaf_handlers(runtime: Any) -> Dict[str, Callable[..., Mapping[str, Any]]]:
     # A condition miss is an EXPECTED OUTCOME of a conditional write, not a
     # transport failure, so a write handler returns ``{"ok": applied}`` rather
     # than raising — the behavior branches on it (the two-stage atomic ADD).
-    # This mirrors ``src/leaf/ddb.ts`` ``isConditionMiss``; the CCF detector is
+    # This mirrors the write leaves of ``src/leaf/ddb.ts``; the CCF detector is
     # the runtime's single one (``_is_conditional_check_failure``).
 
     def _expr_maps(ports: Mapping[str, Any], request: Dict[str, Any]) -> None:

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/graphddb_runtime/runtime.py

@@ -51,9 +51,8 @@ def _is_conditional_check_failure(err: BaseException) -> bool:
     ``original`` is the boto ``ClientError`` (its ``response.Error.Code`` is
     ``ConditionalCheckFailedException``). A fake test client may raise a plain
     exception standing in for the boto error; matched by the exception name / its
-    string carrying ``ConditionalCheckFailed`` (mirroring the TS ``isConditionMiss``,
-    ``src/leaf/ddb.ts``). Unwraps ``__cause__`` / ``original`` so a wrapped error is
-    detected identically."""
+    string carrying ``ConditionalCheckFailed``. Unwraps ``__cause__`` / ``original``
+    so a wrapped error is detected identically."""
     seen: set = set()
     stack: List[BaseException] = [err]
     while stack:

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.2.5
+Version: 1.4.0
 Summary: The DynamoDB issuance a GraphDDB behavior module binds: the leaf transports, table mapping, AttributeValue codec and cursor codecs.
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "1.2.5"
+version = "1.4.0"
 description = "The DynamoDB issuance a GraphDDB behavior module binds: the leaf transports, table mapping, AttributeValue codec and cursor codecs."
 readme = "README.md"
 requires-python = ">=3.9"

{graphddb_runtime-1.2.5 → graphddb_runtime-1.4.0}/tests/test_leaf_handlers.py

@@ -37,6 +37,7 @@ import pytest
 from boto3.dynamodb.types import TypeDeserializer
 
 from graphddb_runtime import (
+    GraphDDBError,
     GraphDDBRuntime,
     Guard,
     OperationExecutionError,
@@ -181,6 +182,8 @@ def test_binds_every_component_the_corpus_declares(generated_module):
         "bulkAdd",
         "bulkRemove",
         "byGroup",
+        "latestBefore",
+        "joinedSince",
         "pair",
         "create",
         "bumpRole",
@@ -285,6 +288,67 @@ def test_query_items_eq_through_a_gsi_keys_on_the_index_attributes(generated_mod
     }
 
 
+def test_query_items_between_reads_descending(generated_module):
+    client = RecordingClient(responses={"query": {"Items": []}})
+    bound = _bind(generated_module, client)
+
+    assert bound["latestBefore"]({"userId": "alice", "kind": "JOIN", "day": "2026-10-01"}) == []
+
+    (request,) = client.requests("query")
+    # `between` reaches from `key.sk` up to `rangeUpper`, inclusive.
+    assert request["KeyConditionExpression"] == "#kp = :kp AND #ks BETWEEN :ks AND :ku"
+    assert _plain(request["ExpressionAttributeValues"]) == {
+        ":kp": "USER#alice",
+        ":ks": "JOIN#",
+        ":ku": "JOIN#2026-10-01",
+    }
+    assert request["ScanIndexForward"] is False
+    assert request["Limit"] == 1
+
+
+def test_query_items_compares_a_gsi_sort_key(generated_module):
+    client = RecordingClient(responses={"query": {"Items": []}})
+    bound = _bind(generated_module, client)
+
+    assert bound["joinedSince"]({"groupId": "g1", "since": "2026-10-01", "limit": 5}) == []
+
+    (request,) = client.requests("query")
+    assert request["IndexName"] == "GSI1"
+    assert request["KeyConditionExpression"] == "#kp = :kp AND #ks >= :ks"
+    assert request["ExpressionAttributeNames"]["#ks"] == "GSI1SK"
+    assert _plain(request["ExpressionAttributeValues"]) == {
+        ":kp": "GROUP#g1",
+        ":ks": "JOINED#2026-10-01",
+    }
+    assert request["ScanIndexForward"] is True
+
+
+def _query_ports(operator, upper=""):
+    return {
+        "table": "members",
+        "indexName": "",
+        "key": {"pk": "USER#alice", "sk": "GROUP#"},
+        "cursor": "",
+        "rangeOperator": operator,
+        "rangeUpper": upper,
+        "scanIndexForward": True,
+        "limit": 10,
+        "projectionFields": [],
+    }
+
+
+def test_query_items_refuses_an_operator_it_cannot_issue():
+    handlers = _handlers(RecordingClient())
+    with pytest.raises(GraphDDBError, match="unsupported range operator 'contains'"):
+        handlers["queryItems"](_query_ports("contains"), {"component": "queryItems"})
+
+
+def test_query_items_refuses_an_upper_operand_without_between():
+    handlers = _handlers(RecordingClient())
+    with pytest.raises(GraphDDBError, match="rangeUpper is the upper operand of 'between'"):
+        handlers["queryItems"](_query_ports("lt", "GROUP#z"), {"component": "queryItems"})
+
+
 def test_batch_get_items_requests_every_key_in_one_batch(generated_module):
     # A projected read returns the projected fields — which is exactly what the
     # behavior declares its rows to be (`MemberRef`, not the whole `MemberRow`).