HyperlinkedIdentityField to_internal_value with nested HyperlinkedModelSerializer

[JulienPalard]

Hello world,

I have the following code:

class MembershipSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Membership
        fields = ("url", "user", "team")

    user = UserSerializer(required=True)
    team = TeamSerializer(required=True)

The UserSerializer and TeamSerializer are simple HyperlinkedModelSerializer like:

class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = (
            "url",
            "username",
        )

What I want is to create new memberships by POSTing objects containing a pair of existing user and existing team, like:

{
    "user": {"url":"http://localhost:8000/api/users/2/", "username": "a-teacher"},
    "team": {"url":"http://localhost:8000/api/teams/2/", "name": "TeamOfTeacher"}
}

(I know what you think, and no I don't want to use HyperlinkedRelatedFields, I really want nested serializers here. Because if I use HyperlinkedRelatedFields it would force clients to do 1+N HTTP requests to get a list of memberships with user names and team names. I want clients to be able to get a good view with a single HTTP request. Plus in real life I have a few more fields in the membership, user, and team objects that may be interesting to give at the first request).

So I'm writing a create method in the MembershipSerializer class:

    def create(self, validated_data):
        self.fields["user"].fields["url"].queryset = User.objects.all()
        user = self.fields["user"].fields["url"].to_internal_value(self.initial_data["user"]["url"])
        ...
        ... # Same for the team, followed by the actual membership creation

But having to patch the queryset in the HyperlinkedIndetityField just to have to_internal_value working seems horrible.

I could parse the URL myself, seems horrible too, knowing that to_internal_value exists.

I could use the username instead of the url to find the user back, but that seems horrible too, URI are things identifiers, let's use them?

First, I don't understand why the HyperlinkedModelSerializer don't push the queryset itself to its auto-genrated url field, it could derive the queryset from the model as it have it, that would solve it all, am I right? I would be able to "just" write:

    def create(self, validated_data):
        user = self.fields["user"].fields["url"].to_internal_value(self.initial_data["user"]["url"])

which is nicer but still seems a bit "huge" to "just" get the user, I really feel like I'm missing something big and obvious, am I?

[Natgho]

Hi @JulienPalard ,

Since HyperlinkedIdentityField is technically a read-only field designed for representation, it doesn't handle the lookup logic needed to 'find' an existing object during a POST request. nstead of manually patching the queryset or overriding create in a horrible way, you can easily use drf-writable-nested library. This library is highly functional and useful for nested updates.

In your specific case;

from drf_writable_nested.serializers import WritableNestedModelSerializer

class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ("url", "username")
        # Ensure 'url' is not read_only if you want to use it for lookups
        extra_kwargs = {'url': {'read_only': False}}

class TeamSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Team
        fields = ("url", "name")
        extra_kwargs = {'url': {'read_only': False}}

class MembershipSerializer(WritableNestedModelSerializer):
    user = UserSerializer()
    team = TeamSerializer()

    class Meta:
        model = Membership
        fields = ("url", "user", "team")

Does that make the code a little longer? Yes, but I think readability trumps everything else.

[JulienPalard]

it doesn't handle the lookup logic needed to 'find' an existing object during a POST request

It does.

This:

    self.fields["user"].fields["url"].queryset = User.objects.all()
    user = self.fields["user"].fields["url"].to_internal_value(self.initial_data["user"]["url"])

works, so the to_internal_value of HyperlinkedIdentityField is implemented to do the URL parsing to exctract the object id and the db lookup to find the object.

Also, drf-writable-nested looks designed to allow to updated the nested serializers. I don't want one to be able to update a team name VIA a PUT on /api/memberships/, my nested serializers are only used to identify objects, not to update them.