fix(json): give on_start the object's own writer and pass the hooks to nested parse nodes

[Max Azatian (HardMax71)]

Overview

Two bugs in how the JSON package runs the serialization and parsing hooks. Both repros use this backed model:

from __future__ import annotations

import json
from dataclasses import dataclass, field
from typing import Optional

from kiota_abstractions.serialization import Parsable
from kiota_abstractions.store import (
    BackedModel,
    BackingStore,
    BackingStoreFactorySingleton,
    BackingStoreSerializationWriterProxyFactory,
)
from kiota_serialization_json.json_parse_node import JsonParseNode
from kiota_serialization_json.json_serialization_writer_factory import JsonSerializationWriterFactory


@dataclass
class Item(BackedModel, Parsable):
    backing_store: BackingStore = field(
        default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store,
        repr=False,
    )
    name: Optional[str] = None
    child: Optional[Item] = None

    @staticmethod
    def create_from_discriminator_value(parse_node):
        return Item()

    def get_field_deserializers(self):
        return {
            "name": lambda n: setattr(self, "name", n.get_str_value()),
            "child": lambda n: setattr(self, "child", n.get_object_value(Item)),
        }

    def serialize(self, writer):
        writer.write_str_value("name", self.name)
        writer.write_object_value("child", self.child)

JsonSerializationWriter gave on_start_object_serialization the outer writer, but each object is written into a temp writer. The backing store uses on_start to write null for properties set to None, so those nulls land in the wrong object:

factory = BackingStoreSerializationWriterProxyFactory(JsonSerializationWriterFactory())

item = Item(name="a")
item.name = None
writer = factory.get_serialization_writer("application/json")
writer.write_object_value(None, item)
writer.get_serialized_content()
# main: ValueError: Invalid Json output
# now:  b'{"name": null}'

parent = Item(name="p", child=Item(name="c"))
parent.child.name = None
writer = factory.get_serialization_writer("application/json")
writer.write_object_value(None, parent)
writer.get_serialized_content()
# main: b'{"name": null, "child": {}}'
# now:  b'{"name": "p", "child": {"name": null}}'

on_start now gets the writer the object is written to, like in C#. msgraph-sdk-python turns on the backing store in its client constructor, so a PATCH that clears a property goes through this.

JsonParseNode built each field's node without the before and after hooks, so they ran only for the root object:

seen = []
node = JsonParseNode(json.loads('{"name": "p", "child": {"name": "c"}}'))
node.on_before_assign_field_values = seen.append
node.get_object_value(Item)
len(seen)
# main: 1
# now:  2

_create_new_node copies the hooks, like in C#, so field nodes now get them.

Related Issue

No issue. Found while typing the proxy factories for #722 (#806).

Testing Instructions

• pytest in packages/serialization/json passes. The three new tests fail without the source change.
• yapf -dr kiota_serialization_json, pylint and mypy pass.
• The repros above give the "main" output on main and the "now" output on this branch.

[Vincent Biret (baywet)]

Thanks for the contribution!

[Copilot]

🟢 Approval recommended

Both focused fixes match the hook contracts and have targeted regression coverage, with no unresolved findings.

0 open findings

🧠 Review effort: Balanced

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud