Let to_json hook take precedence over dataclass asdict in serializer

The JSON serializer encoded dataclasses via dataclasses.asdict before ever
checking for a to_json hook, so a dataclass could not override its own
serialization -- a problem for dataclasses whose fields are not JSON-native
(e.g. timedelta/datetime). The read path already consults from_json before its
dataclass branch; this makes the write path symmetric by checking the to_json
hook first and falling back to asdict/SimpleNamespace.

Author: andystaples

durabletask/internal/json_codec.py

@@ -76,18 +76,25 @@ def _encode_custom_object(o: Any) -> Any:
     namedtuples are handled natively by the encoder (serialized as JSON arrays)
     and never reach this hook.
     """
-    if dataclasses.is_dataclass(o) and not isinstance(o, type):
-        return dataclasses.asdict(o)
-    if isinstance(o, SimpleNamespace):
-        return vars(o)
     # Custom objects may opt in via a ``to_json`` hook. It is resolved off the
     # type and called with the instance (``type(o).to_json(o)``) so that both
     # instance methods and ``@staticmethod`` hooks work -- matching the calling
     # convention used by ``azure-functions-durable``. The hook returns a
     # JSON-serializable value (a structure or a string), not a JSON document.
+    #
+    # The hook is checked before the dataclass / ``SimpleNamespace`` branches so
+    # a type may override the default structural encoding -- mirroring the read
+    # path, where :func:`coerce_to_type` consults ``from_json`` before its
+    # dataclass branch. This matters for dataclasses whose fields are not
+    # JSON-native (e.g. ``timedelta`` / ``datetime``), which ``asdict`` alone
+    # cannot serialize.
     to_json_hook = getattr(cast(Any, type(o)), "to_json", None)
     if callable(to_json_hook):
         return to_json_hook(o)
+    if dataclasses.is_dataclass(o) and not isinstance(o, type):
+        return dataclasses.asdict(o)
+    if isinstance(o, SimpleNamespace):
+        return vars(o)
     # This will raise a TypeError describing the unsupported type.
     raise TypeError(f"Object of type '{type(o).__name__}' is not JSON serializable")
 

tests/durabletask/test_serialization.py

@@ -93,6 +93,40 @@ def test_instance_to_json_hook_receives_instance():
     assert json.loads(json_codec.to_json(Widget("gear", 5))) == {"label": "gear", "size": 5}
 
 
+@dataclass
+class HookedDataclass:
+    """Dataclass that overrides serialization via to_json/from_json.
+
+    Its ``value`` field is not JSON-native on the wire (it is encoded as a
+    string), so plain ``dataclasses.asdict`` would not round-trip. The hooks
+    take precedence over the default dataclass encoding.
+    """
+
+    value: int
+
+    def to_json(self) -> dict:
+        return {"value": str(self.value)}
+
+    @classmethod
+    def from_json(cls, data: dict) -> "HookedDataclass":
+        return cls(int(data["value"]))
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, HookedDataclass) and other.value == self.value
+
+
+def test_dataclass_to_json_hook_takes_precedence_over_asdict():
+    # A dataclass exposing to_json should serialize via the hook, not asdict.
+    encoded = json_codec.to_json(HookedDataclass(7))
+    assert json.loads(encoded) == {"value": "7"}
+
+
+def test_dataclass_hook_round_trips_with_expected_type():
+    encoded = json_codec.to_json(HookedDataclass(7))
+    result = json_codec.from_json(encoded, HookedDataclass)
+    assert result == HookedDataclass(7)
+
+
 # ----- to_json -----