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

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

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

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

@@ -268,15 +268,15 @@ class GraphDDBRuntime:
     def use(self, mw: Any) -> None:
         """Register a host-side middleware (read R1–R5 / write W1–W5 hooks).
 
-        Mirrors the TS ``DDBModel.use``: appended last, so it runs last in the
-        FIFO ``before*`` order and first in the LIFO ``after`` / ``onError``
+        Mirrors the TS ``graphddb.config.use``: appended last, so it runs last in
+        the FIFO ``before*`` order and first in the LIFO ``after`` / ``onError``
         order. The middleware is never serialized.
         """
         self._middleware.use(mw)
 
     def clear_middleware(self) -> None:
         """Remove every registered middleware (teardown / tests). Mirrors the TS
-        ``DDBModel.clearMiddleware``."""
+        ``graphddb.config.clearMiddleware``."""
         self._middleware.clear()
 
     def get_middleware(self) -> Tuple[Any, ...]:
@@ -589,6 +589,33 @@ class GraphDDBRuntime:
         opts = dict(params or {})
 
         is_array = isinstance(key_or_keys, (list, tuple))
+
+        # A **relation-traversal** contract read lowers to >1 operation (the root
+        # read + one leg per resolved relation; e.g. getUserByEmail → 4 ops,
+        # getGroupAccess → 3 ops). The single-op point/range executors below cannot
+        # assemble a multi-op result — that is the job of :meth:`execute_query`,
+        # which walks the whole ``operations`` list and merges the relation legs.
+        # So delegate a multi-op single-key read to the relation-assembly path (the
+        # exact path ``execute_query`` uses), keyed by the method's referenced
+        # operation id. An array of keys against such a method is an N+1 fan-out
+        # (one full traversal per key), forbidden by the same N+1 rule that rejects
+        # a range array — a single-key relation read is the only reachable shape.
+        if len(op_spec.get("operations", [])) > 1:
+            if is_array:
+                raise ContractArityError(
+                    f"{contract_name}.{method_name}: a relation-traversal method "
+                    f"(it lowers to multiple operations) was called with an array of "
+                    f"keys. Each key is a full traversal, so an array would be an N+1 "
+                    f"fan-out — forbidden by the contract's N+1 rule. Loop in "
+                    f"application code for N independent reads."
+                )
+            validate_params(
+                key_or_keys,
+                op_spec.get("params", {}),
+                operation_id=f"{contract_name}.{method_name}",
+            )
+            return self.execute_query(method["operation"], key_or_keys, opts)
+
         if is_array:
             # Only a method whose ``inputArity`` is ``'either'`` coalesces a key
             # array into one batched call. A ``'single'`` method must reject an
@@ -676,12 +703,17 @@ class GraphDDBRuntime:
     def _contract_query_op(
         self, contract_name: str, method_name: str, method: Mapping[str, Any]
     ) -> Mapping[str, Any]:
-        """The single referenced read op spec for a contract query method.
-
-        A contract method resolves to exactly one declarative read op (#58). Any
-        External Query compositions (#63) it declares are carried separately on
-        the method spec (``compose``) and resolved by :meth:`_resolve_compositions`
-        after the parent step — they do **not** add operations to this op spec.
+        """The referenced read op spec for a contract query method.
+
+        A method's referenced operation carries **one or more** read operations: a
+        plain point/range read is a single operation, whereas a relation-traversal
+        read lowers to the root read PLUS one leg per resolved relation (e.g.
+        getUserByEmail → 4 ops). ``execute_query_method`` routes a multi-op spec
+        through the relation-assembly path (:meth:`execute_query`); the single-op
+        point/range executors handle the ``len == 1`` case. Any External Query
+        compositions (#63) a method declares are carried separately on the method
+        spec (``compose``) — they do **not** add operations to this op spec (and a
+        composed child is always a ``point`` read, i.e. a single operation).
         """
         op_name = method["operation"]
         spec = self._queries.get(op_name)
@@ -691,10 +723,10 @@ class GraphDDBRuntime:
                 f"not present in `queries`."
             )
         operations = spec.get("operations", [])
-        if len(operations) != 1:
+        if len(operations) < 1:
             raise GraphDDBError(
-                f"{contract_name}.{method_name}: a single-contract query method must "
-                f"resolve to exactly one read operation, found {len(operations)}."
+                f"{contract_name}.{method_name}: a query method must resolve to at "
+                f"least one read operation, found {len(operations)}."
             )
         return spec
 

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

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

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

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

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_concurrency.py

@@ -166,7 +166,7 @@ def test_independent_relation_stage_runs_concurrently():
 
     # If the two sibling queries did NOT overlap, the barrier (timeout=3) would
     # raise BrokenBarrierError here. Reaching the assertions proves concurrency.
-    out = rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    out = rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
 
     assert out["members"]["items"][0]["userId"] == "alice"
     assert out["permissions"]["items"][0]["resource"] == "codebase"
@@ -192,9 +192,9 @@ def test_stage_concurrency_is_bounded_by_the_declared_limit():
     client = _CountingGroupAccessClient()
     rt = GraphDDBRuntime(client, MULTI_MANIFEST, MULTI_OPS)
     # Force the declared bound to 1 on the loaded spec.
-    rt._queries["getGroupAccess"]["executionPlan"]["concurrency"] = 1
+    rt._queries["GroupAccessMulti__getGroupAccess"]["executionPlan"]["concurrency"] = 1
 
-    rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
     # Bound 1 → strictly one query at a time.
     assert client.peak_in_flight == 1
     assert client.query_count == 2
@@ -215,9 +215,9 @@ def test_plan_absent_falls_back_to_sequential():
     client.barrier = threading.Barrier(1, timeout=3)  # no overlap expected
     rt = GraphDDBRuntime(client, MULTI_MANIFEST, MULTI_OPS)
     # Strip the plan → exercise the backward-compatible (sequential) fallback.
-    rt._queries["getGroupAccess"].pop("executionPlan", None)
+    rt._queries["GroupAccessMulti__getGroupAccess"].pop("executionPlan", None)
 
-    out = rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    out = rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
     assert out["members"]["items"][0]["userId"] == "alice"
     assert out["permissions"]["items"][0]["resource"] == "codebase"
     # Plan-less → each op its own stage → strictly one query in flight at a time.
@@ -227,7 +227,7 @@ def test_plan_absent_falls_back_to_sequential():
 def test_relation_stages_reads_plan_groups():
     """Unit: `_relation_stages` derives stages from the plan (root dropped)."""
     rt = GraphDDBRuntime(_BarrierGroupAccessClient(), MULTI_MANIFEST, MULTI_OPS)
-    spec = rt._queries["getGroupAccess"]
+    spec = rt._queries["GroupAccessMulti__getGroupAccess"]
     operations = spec["operations"]
     # Plan present: [[0],[1,2]] → relation stages [[1, 2]] (root index 0 dropped).
     assert rt._relation_stages(spec, operations) == [[1, 2]]
@@ -243,7 +243,7 @@ def test_relation_stages_reads_plan_groups():
 def test_deep_chain_plan_stages_are_sequential():
     """A result-dependent chain (getUserByEmail) stages into ordered single-op stages."""
     rt = GraphDDBRuntime(_BarrierGroupAccessClient(), MULTI_MANIFEST, MULTI_OPS)
-    spec = rt._queries["getUserByEmail"]
+    spec = rt._queries["UserByEmailMulti__getUserByEmail"]
     # Plan [[0],[1],[2],[3]] → relation stages [[1],[2],[3]] (each depends on prior).
     assert rt._relation_stages(spec, spec["operations"]) == [[1], [2], [3]]
 

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_description.py

@@ -38,7 +38,7 @@ def test_manifest_carries_entity_and_field_description() -> None:
 
 def test_operations_carries_query_param_and_contract_description() -> None:
     ops = _operations()
-    get_group = ops["queries"]["getGroup"]
+    get_group = ops["queries"]["GroupByIdRead__get"]
     assert get_group["description"] == "Fetch a single group by its id."
     assert get_group["params"]["groupId"]["description"] == "The group id to fetch."
     # The contract method description rides the `contracts` map.
@@ -48,7 +48,7 @@ def test_operations_carries_query_param_and_contract_description() -> None:
 
 def test_undescribed_query_has_no_description_key() -> None:
     # `getUser` declares no description — backward compatible.
-    get_user = _operations()["queries"]["getUser"]
+    get_user = _operations()["queries"]["UserByIdRead__get"]
     assert "description" not in get_user
 
 

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_description_jsdoc.py

@@ -63,7 +63,7 @@ def test_manifest_carries_jsdoc_gsi_description() -> None:
 
 
 def test_operations_carry_jsdoc_query_and_param_description() -> None:
-    get_user = _operations()["queries"]["getUserDocumented"]
+    get_user = _operations()["queries"]["UserDocumentedRead__getUserDocumented"]
     assert get_user["description"] == (
         "#165 JSDoc-as-default (query): fetch a single user by id (JSDoc source)."
     )

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_integration.py

@@ -155,11 +155,11 @@ def test_command_put_then_query_then_delete(client, repos):
     membership = repos["membership"]
 
     # put (generated command, key attributes injected by the runtime)
-    membership.add_group_member(group_id="eng", user_id="alice", role="admin")
-    membership.add_group_member(group_id="eng", user_id="bob", role="member")
+    membership.membership_conf_commands__add_group_member(group_id="eng", user_id="alice", role="admin")
+    membership.membership_conf_commands__add_group_member(group_id="eng", user_id="bob", role="member")
 
     # query (generated list query, single Query op on the base partition)
-    result = repos["membership"].list_group_members(group_id="eng")
+    result = repos["membership"].members_by_group_read__list(group_id="eng")
     assert result is not None
     by_user = {m["userId"]: m for m in result["items"]}
     assert set(by_user) == {"alice", "bob"}
@@ -168,17 +168,17 @@ def test_command_put_then_query_then_delete(client, repos):
     assert by_user["alice"]["joinedAt"] == datetime(1970, 1, 1, tzinfo=timezone.utc)
 
     # delete one member, confirm it is gone
-    membership.delete_group_member(group_id="eng", user_id="bob")
-    after = repos["membership"].list_group_members(group_id="eng")
+    membership.membership_conf_commands__delete_group_member(group_id="eng", user_id="bob")
+    after = repos["membership"].members_by_group_read__list(group_id="eng")
     assert {m["userId"] for m in after["items"]} == {"alice"}
 
     # cleanup
-    membership.delete_group_member(group_id="eng", user_id="alice")
+    membership.membership_conf_commands__delete_group_member(group_id="eng", user_id="alice")
 
 
 def test_get_item_on_base_table(client, repos):
     _put_group(client, "product", "Product")
-    out = repos["group"].get_group(group_id="product")
+    out = repos["group"].group_by_id_read__get(group_id="product")
     assert out is not None
     assert out["groupId"] == "product"
     assert out["name"] == "Product"
@@ -188,12 +188,12 @@ def test_get_item_on_base_table(client, repos):
 
 
 def test_get_item_missing_returns_none(repos):
-    assert repos["group"].get_group(group_id="does-not-exist") is None
+    assert repos["group"].group_by_id_read__get(group_id="does-not-exist") is None
 
 
 def test_query_on_unique_gsi(client, repos):
     _put_user(client, "carol", "carol@example.com")
-    out = repos["user"].get_user_by_email(email="carol@example.com")
+    out = repos["user"].user_by_email_read__get(email="carol@example.com")
     # getUserByEmail is a relation-free cardinality-one Query: a single object
     # (matching the generated flat GetUserByEmailResult and the TS executor),
     # not a {items, cursor} connection.
@@ -204,8 +204,8 @@ def test_query_on_unique_gsi(client, repos):
 
 def test_update_item_round_trip(client, repos):
     _put_user(client, "dave", "dave@example.com", status="active")
-    repos["user"].disable_user(status="disabled", user_id="dave")
-    out = repos["user"].get_user(user_id="dave")
+    repos["user"].user_conf_commands__disable_user(status="disabled", user_id="dave")
+    out = repos["user"].user_by_id_read__get(user_id="dave")
     assert out["status"] == "disabled"
 
 
@@ -220,18 +220,18 @@ def test_conditional_put_succeeds_then_fails_on_existing(client, repos):
     from graphddb_runtime import OperationExecutionError
 
     runtime = repos["runtime"]
-    runtime._commands["addGroupMember"]["condition"] = {"kind": "notExists"}
+    runtime._commands["MembershipConfCommands__addGroupMember"]["condition"] = {"kind": "notExists"}
     try:
         runtime.execute_command(
-            "addGroupMember", {"groupId": "cond", "userId": "once", "role": "member"}
+            "MembershipConfCommands__addGroupMember", {"groupId": "cond", "userId": "once", "role": "member"}
         )
         with pytest.raises(OperationExecutionError):
             runtime.execute_command(
-                "addGroupMember",
+                "MembershipConfCommands__addGroupMember",
                 {"groupId": "cond", "userId": "once", "role": "member"},
             )
     finally:
-        runtime._commands["addGroupMember"].pop("condition", None)
+        runtime._commands["MembershipConfCommands__addGroupMember"].pop("condition", None)
         client.delete_item(
             TableName=TABLE,
             Key={"PK": {"S": "GROUP#cond"}, "SK": {"S": "USER#once"}},
@@ -250,32 +250,32 @@ def test_conditional_update_equality_matches_then_mismatches(client, repos):
     runtime = repos["runtime"]
     _put_user(client, "condu", "condu@example.com", status="active")
     # Condition: only disable when the current status equals the param `expect`.
-    runtime._commands["disableUser"]["condition"] = {
+    runtime._commands["UserConfCommands__disableUser"]["condition"] = {
         "kind": "equals",
         "fields": {"status": "{expect}"},
     }
     # Declare the extra param so validate_params accepts `expect`.
-    runtime._commands["disableUser"]["params"]["expect"] = {
+    runtime._commands["UserConfCommands__disableUser"]["params"]["expect"] = {
         "type": "string",
         "required": True,
     }
     try:
         # Condition expects current status 'active' → matches → succeeds.
         runtime.execute_command(
-            "disableUser",
+            "UserConfCommands__disableUser",
             {"userId": "condu", "status": "disabled", "expect": "active"},
         )
-        out = repos["user"].get_user(user_id="condu")
+        out = repos["user"].user_by_id_read__get(user_id="condu")
         assert out["status"] == "disabled"
         # The row's status is now 'disabled', so expecting 'active' must fail.
         with pytest.raises(OperationExecutionError):
             runtime.execute_command(
-                "disableUser",
+                "UserConfCommands__disableUser",
                 {"userId": "condu", "status": "disabled", "expect": "active"},
             )
     finally:
-        runtime._commands["disableUser"].pop("condition", None)
-        runtime._commands["disableUser"]["params"].pop("expect", None)
+        runtime._commands["UserConfCommands__disableUser"].pop("condition", None)
+        runtime._commands["UserConfCommands__disableUser"]["params"].pop("expect", None)
         client.delete_item(
             TableName=TABLE,
             Key={"PK": {"S": "USER#condu"}, "SK": {"S": "PROFILE"}},
@@ -297,7 +297,7 @@ def test_transaction_static_round_trip(client, repos):
         ConsistentRead=True,
     )["Item"]
     assert member["role"]["S"] == "admin"
-    group = repos["group"].get_group(group_id="txg")
+    group = repos["group"].group_by_id_read__get(group_id="txg")
     assert group["name"] == "admin"
     # cleanup
     client.delete_item(
@@ -322,7 +322,7 @@ def test_transaction_foreach_round_trip(client, repos):
             ],
         },
     )
-    members = repos["membership"].list_group_members(group_id="txm")
+    members = repos["membership"].members_by_group_read__list(group_id="txm")
     assert {m["userId"] for m in members["items"]} == {"a", "c"}
     for uid in ("a", "c"):
         client.delete_item(
@@ -366,7 +366,7 @@ def test_transaction_rolls_back_on_condition_failure(client, repos):
                 {"groupId": "txr", "userId": "txu", "role": "admin"},
             )
         # The group name must be unchanged (whole tx rolled back).
-        group = repos["group"].get_group(group_id="txr")
+        group = repos["group"].group_by_id_read__get(group_id="txr")
         assert group["name"] == "Original"
     finally:
         spec["items"][0].pop("condition", None)
@@ -396,7 +396,7 @@ def test_transaction_condition_check_commits_when_target_exists(client, repos):
     assert member is not None
     assert member["role"]["S"] == "member"
     # The asserted group row is untouched (ConditionCheck mutates nothing).
-    group = repos["group"].get_group(group_id="ccok")
+    group = repos["group"].group_by_id_read__get(group_id="ccok")
     assert group["name"] == "CcOkGroup"
     # cleanup
     client.delete_item(
@@ -442,12 +442,12 @@ def test_query_pagination_cursor(client, repos):
     # Seed three memberships under a fresh group and page with limit-less query;
     # then page explicitly using the runtime cursor to confirm round-trip.
     for uid in ("u1", "u2", "u3"):
-        repos["membership"].add_group_member(group_id="pag", user_id=uid, role="member")
+        repos["membership"].membership_conf_commands__add_group_member(group_id="pag", user_id=uid, role="member")
 
     runtime = repos["runtime"]
-    page1 = runtime.execute_query("listGroupMembers", {"groupId": "pag"})
+    page1 = runtime.execute_query("MembersByGroupRead__list", {"groupId": "pag"})
     # DynamoDB Local returns all small items in one page; cursor may be None.
     assert {m["userId"] for m in page1["items"]} == {"u1", "u2", "u3"}
 
     for uid in ("u1", "u2", "u3"):
-        repos["membership"].delete_group_member(group_id="pag", user_id=uid)
+        repos["membership"].membership_conf_commands__delete_group_member(group_id="pag", user_id=uid)

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_integration_edge_write.py

@@ -178,12 +178,12 @@ def _raw(client, pk, sk):
 
 
 def _members(runtime, group_id):
-    out = runtime.execute_query("getGroupMembers", {"groupId": group_id})
+    out = runtime.execute_query("GroupMembersMulti__getGroupMembers", {"groupId": group_id})
     return {m["userId"] for m in out["members"]["items"]}
 
 
 def _groups(runtime, user_id):
-    out = runtime.execute_query("getUserGroups", {"userId": user_id})
+    out = runtime.execute_query("UserGroupsMulti__getUserGroups", {"userId": user_id})
     return {g["groupId"] for g in out["groups"]["items"]}
 
 

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_integration_middleware.py

@@ -167,7 +167,7 @@ def test_r2_filter_narrows_permissions_fan_out_end_to_end(multi_rt):
             ctx.operation["ExpressionAttributeValues"][":mwa"] = {"S": "read"}
 
     multi_rt.use({"read": {"op": {"before": op_before}}})
-    out = multi_rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    out = multi_rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
     actions = sorted(p["action"] for p in out["permissions"]["items"])
     assert actions == ["read"]  # 'write' filtered out by DynamoDB
     # Members are untouched (the filter scoped only the permissions leg).
@@ -176,7 +176,7 @@ def test_r2_filter_narrows_permissions_fan_out_end_to_end(multi_rt):
 
 def test_r4_transforms_final_result_end_to_end(multi_rt):
     multi_rt.use({"read": {"afterFetch": lambda ctx, r: {**r, "redacted": True}}})
-    out = multi_rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    out = multi_rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
     assert out["redacted"] is True
     assert out["groupId"] == "eng"
 
@@ -192,7 +192,7 @@ def test_r5_op_recovery_substitutes_failed_fan_out_end_to_end(multi_rt):
         return None
 
     multi_rt.use({"read": {"op": {"before": op_before, "onError": op_error}}})
-    out = multi_rt.execute_query("getGroupAccess", {"groupId": "eng"})
+    out = multi_rt.execute_query("GroupAccessMulti__getGroupAccess", {"groupId": "eng"})
     assert [m["userId"] for m in out["members"]["items"]] == ["fallback"]
 
 
@@ -202,7 +202,7 @@ def test_r5_op_recovery_substitutes_failed_fan_out_end_to_end(multi_rt):
 def test_w1_soft_delete_rewrite_stores_update_row_survives(std_rt):
     # Seed a membership to soft-delete.
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "carol", "role": "member"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "carol", "role": "member"}
     )
 
     def before(ctx):
@@ -211,7 +211,7 @@ def test_w1_soft_delete_rewrite_stores_update_row_survives(std_rt):
             ctx.input["changes"] = {"role": "SOFT-DELETED"}
 
     std_rt.use({"write": {"before": before}})
-    std_rt.execute_command("deleteGroupMember", {"groupId": "eng", "userId": "carol"})
+    std_rt.execute_command("MembershipConfCommands__deleteGroupMember", {"groupId": "eng", "userId": "carol"})
 
     # The row SURVIVES (soft-deleted): a delete would have removed it.
     raw = std_rt._client.get_item(
@@ -233,7 +233,7 @@ def test_w3_mutation_persisted_on_real_write(std_rt):
 
     std_rt.use({"write": {"persist": {"before": persist_before}}})
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "dave", "role": "member"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "dave", "role": "member"}
     )
     raw = std_rt._client.get_item(
         TableName=TABLE,
@@ -255,7 +255,7 @@ def test_w5_persist_recovery_suppresses_failure(std_rt):
     }}})
     # Recovery suppresses the throw; the row is NOT written (send never ran).
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "erin", "role": "member"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "erin", "role": "member"}
     )
     raw = std_rt._client.get_item(
         TableName=TABLE,
@@ -272,12 +272,12 @@ def test_w2_put_real_old_image_end_to_end(std_rt):
     # overwrites it. W2 sees the exact prior row as oldImage (real ALL_OLD from
     # DynamoDB Local) and the written item as newImage.
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "frank", "role": "member"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "frank", "role": "member"}
     )
     captured = {}
     std_rt.use({"write": {"after": lambda ctx, change: captured.update(change)}})
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "frank", "role": "admin"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "frank", "role": "admin"}
     )
     assert captured["oldImage"]["role"] == "member"  # real pre-write row
     assert captured["newImage"]["role"] == "admin"  # the written item
@@ -285,11 +285,11 @@ def test_w2_put_real_old_image_end_to_end(std_rt):
 
 def test_w2_delete_real_old_image_end_to_end(std_rt):
     std_rt.execute_command(
-        "addGroupMember", {"groupId": "eng", "userId": "gina", "role": "member"}
+        "MembershipConfCommands__addGroupMember", {"groupId": "eng", "userId": "gina", "role": "member"}
     )
     captured = {}
     std_rt.use({"write": {"after": lambda ctx, change: captured.update(seen=change)}})
-    std_rt.execute_command("deleteGroupMember", {"groupId": "eng", "userId": "gina"})
+    std_rt.execute_command("MembershipConfCommands__deleteGroupMember", {"groupId": "eng", "userId": "gina"})
     change = captured["seen"]
     assert change["oldImage"]["userId"] == "gina"
     assert change["oldImage"]["role"] == "member"

{graphddb_runtime-0.7.10 → graphddb_runtime-0.8.1}/tests/test_integration_relations.py

@@ -227,7 +227,7 @@ def env(seeded):
 
 
 def test_get_group_access_members_and_permissions(env):
-    out = env["group"].get_group_access(group_id="eng")
+    out = env["group"].group_access_multi__get_group_access(group_id="eng")
     assert out is not None
     assert out["groupId"] == "eng"
     assert out["name"] == "Engineering"
@@ -249,7 +249,7 @@ def test_get_group_access_members_and_permissions(env):
 
 
 def test_get_user_by_email_deep_traversal(env):
-    out = env["user"].get_user_by_email(email="alice@example.com")
+    out = env["user"].user_by_email_multi__get_user_by_email(email="alice@example.com")
     assert out is not None
     # cardinality 'one' → root is the User object, not a connection.
     assert out["userId"] == "alice"
@@ -276,7 +276,7 @@ def test_get_user_by_email_deep_traversal(env):
 def test_belongs_to_resolution_is_single_batch_get_no_n_plus_one(env):
     spy = env["spy"]
     spy.reset()
-    env["user"].get_user_by_email(email="alice@example.com")
+    env["user"].user_by_email_multi__get_user_by_email(email="alice@example.com")
 
     # The belongsTo parent-Group resolution for the 2 memberships is ONE
     # BatchGetItem, and NOT a single individual GetItem (N+1 not issued).
@@ -287,7 +287,7 @@ def test_belongs_to_resolution_is_single_batch_get_no_n_plus_one(env):
 def test_user_with_no_groups_returns_empty_connection(env):
     # bob is seeded; a fresh user with no memberships still resolves cleanly.
     env["runtime"]  # warm
-    out = env["user"].get_user_by_email(email="bob@example.com")
+    out = env["user"].user_by_email_multi__get_user_by_email(email="bob@example.com")
     groups = {g["groupId"]: g for g in out["groups"]["items"]}
     assert set(groups) == {"eng", "product"}
 
@@ -304,7 +304,7 @@ def test_depth_limit_exceeded_is_runtime_error(seeded):
     )
     bridge = _load_generated_package()
     with pytest.raises(LimitExceededError):
-        bridge.UserRepository(runtime).get_user_by_email(email="alice@example.com")
+        bridge.UserRepository(runtime).user_by_email_multi__get_user_by_email(email="alice@example.com")
 
 
 def test_operations_limit_exceeded_is_runtime_error(seeded):
@@ -316,7 +316,7 @@ def test_operations_limit_exceeded_is_runtime_error(seeded):
     )
     bridge = _load_generated_package()
     with pytest.raises(LimitExceededError):
-        bridge.UserRepository(runtime).get_user_by_email(email="alice@example.com")
+        bridge.UserRepository(runtime).user_by_email_multi__get_user_by_email(email="alice@example.com")
 
 
 def test_explain_lists_operations_without_touching_dynamodb(seeded):
@@ -327,7 +327,7 @@ def test_explain_lists_operations_without_touching_dynamodb(seeded):
         operations_path=MULTI_OPS,
         limits=RuntimeLimits(max_depth=3),
     )
-    plan = runtime.explain("getUserByEmail", {"email": "alice@example.com"})
+    plan = runtime.explain("UserByEmailMulti__getUserByEmail", {"email": "alice@example.com"})
     assert len(plan["operations"]) == 4
     assert plan["operations"][0]["keyCondition"]["GSI1PK"] == "EMAIL#alice@example.com"
     assert plan["operations"][2]["type"] == "BatchGetItem"
@@ -342,7 +342,7 @@ def test_refs_fan_out_resolves_inline_id_list_in_one_batch_get(env):
     repo = bridge.ArticleRepository(env["runtime"])
     env["spy"].reset()
 
-    out = repo.get_article_with_tags(article_id="a1")
+    out = repo.article_with_tags_multi__get_article_with_tags(article_id="a1")
     assert out is not None
     assert out["articleId"] == "a1"
     assert out["title"] == "Refs!"
@@ -368,7 +368,7 @@ def test_refs_empty_list_resolves_empty_connection_without_batch_get(env):
     repo = bridge.ArticleRepository(env["runtime"])
     env["spy"].reset()
 
-    out = repo.get_article_with_tags(article_id="a2")
+    out = repo.article_with_tags_multi__get_article_with_tags(article_id="a2")
     assert out is not None
     assert out["tags"] == {"items": [], "cursor": None}
     assert "tagRefs" not in out