feat(parse_result): add recursive None stripping for nested structures

Signed-off-by: Ntege Daniel <danientege785@gmail.com>

Author: danielmarv

tck/handlers/registry.py

@@ -81,14 +81,29 @@ def safe_dispatch(method_name: str, params: Any, request_id: str | int | None) -
         return build_json_rpc_error_response(error, request_id)
 
 
+def _strip_none(obj: Any, nullable_keys: set[str] | None = None) -> Any:
+    """Recursively strip None values from nested dicts and lists."""
+    if isinstance(obj, dict):
+        return {
+            k: _strip_none(v)
+            for k, v in obj.items()
+            if v is not None or (nullable_keys is not None and k in nullable_keys)
+        }
+    if isinstance(obj, list):
+        return [_strip_none(item) for item in obj]
+    return obj
+
+
 def parse_result(result: Any) -> dict:
     """Parse the result from the methods to dict containing non none key:values.
 
     Fields with metadata={"nullable": True} are preserved even when None.
+    Recursively strips None from nested structures.
     """
     nullable_fields: set[str] = set()
     for f in dc_fields(result):
         if f.metadata.get("nullable"):
             nullable_fields.add(f.name)
 
-    return {k: v for k, v in asdict(result).items() if v is not None or k in nullable_fields}
+    raw = asdict(result)
+    return _strip_none(raw, nullable_keys=nullable_fields)

tck/handlers/token.py

@@ -489,7 +489,7 @@ def claim_token(params: ClaimTokenParams) -> ClaimTokenResponse:
     return ClaimTokenResponse(status=ResponseCode(receipt.status).name)
 
 
-def _serialize_key(key) -> str:
+def _serialize_key(key) -> str | None:
     """Serialize a key to its DER-encoded hex string representation."""
     if key is None:
         return ""

tests/tck/handlers_test.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from unittest.mock import MagicMock
 
 import pytest
@@ -57,6 +57,24 @@ class DummyResult:
     other: str | None = None
 
 
+@dataclass
+class NestedChild:
+    """Nested dataclass for testing recursive None stripping."""
+
+    amount: str | None = None
+    label: str | None = None
+
+
+@dataclass
+class DummyResultWithNested:
+    """Dataclass with nested fields for testing recursive parse_result."""
+
+    name: str | None = None
+    child: NestedChild | None = None
+    children: list[NestedChild] | None = None
+    nullable_field: str | None = field(metadata={"nullable": True}, default=None)
+
+
 class TestHandlerRegistration:
     def test_handler_registration_via_decorator(self):
         """Test that @rpc_method decorator registers handler."""
@@ -265,3 +283,46 @@ def test_parse_result_dataclass_ignore_none(self):
         parsed = parse_result(result)
 
         assert parsed == {"value": 10}, "Expected filtered dataclass result"
+
+    def test_parse_result_strips_none_in_nested_dicts(self):
+        """None values in nested dataclass dicts should be stripped."""
+        result = DummyResultWithNested(
+            name="test",
+            child=NestedChild(amount="5", label=None),
+        )
+
+        parsed = parse_result(result)
+
+        assert parsed == {"name": "test", "child": {"amount": "5"}, "nullable_field": None}
+
+    def test_parse_result_strips_none_in_nested_lists(self):
+        """None values inside list items should be stripped."""
+        result = DummyResultWithNested(
+            name="test",
+            children=[
+                NestedChild(amount="1", label=None),
+                NestedChild(amount="2", label="ok"),
+            ],
+        )
+
+        parsed = parse_result(result)
+
+        assert parsed == {
+            "name": "test",
+            "children": [
+                {"amount": "1"},
+                {"amount": "2", "label": "ok"},
+            ],
+            "nullable_field": None,
+        }
+
+    def test_parse_result_preserves_nullable_field_when_none(self):
+        """Fields marked nullable should be preserved even when None."""
+        result = DummyResultWithNested(
+            name="test",
+            nullable_field=None,
+        )
+
+        parsed = parse_result(result)
+
+        assert parsed == {"name": "test", "nullable_field": None}