Including GenericForeignKey fields

[SafaAlfulaij]

When you have a model defined as:

class TaggedItem(models.Model):
    tag = models.SlugField()
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

And a serializer defined as:

class TaggedItemSerializer(serializers.ModelSerializer):

    content_object = relations.ResourceRelatedField(read_only=True) # This returns correct results based on the object (proper `id`s and `type`s)

    included_serializers = {
        "content_object": "", # What to have here?
    }

    class Meta:
        model = TaggedItem
        fields = ("tag", "content_object")

How to use the include "feature" for generic foreign keys?
There is this #319 but it doesn't seem right...

[SafaAlfulaij]

This is achievable by using PolymorphicResourceRelatedField, with an abstract class being the base class (this fails in schema generation in DRF side as abstract classes shouldn't be used in ModelSerializers, but solvable).
The missing part is input and validation. This will require some changes to allow validating type (if not there) and queryset.

[sliverc]

I've found a related discussion on JSON:API forums which discusses polymorphic relationships and its challenges.

Especially when it comes to include parameter JSON:API assumes an uniform API to work. So actually also a reason why GenericForeignKey is not supported.

[SafaAlfulaij]

As mentioned, PolymorphicResourceRelatedField already have this kind of functionality, so it worked for me. And I solved the input part by modifying to_internal_value of relations.PolymorphicResourceRelatedField to interpolate the type.
Even if JSON:API doesn't really know how to do it, as long as the solution provided here is solid, it's enough.
One problem of this is that related includes can't work easily.

[sliverc]

In the example app there is an example which uses the reverse relationship using GenericRelation, where include works.

Like the following:

class TaggedItem(BaseModel):
    tag = models.SlugField()
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")

    def __str__(self):
        return self.tag

    class Meta:
        ordering = ("id",)


class Blog(BaseModel):
    name = models.CharField(max_length=100)
    tagline = models.TextField()
    tags = GenericRelation(TaggedItem)

    def __str__(self):
        return self.name

    class Meta:
        ordering = ("id",)

class TaggedItemSerializer(serializers.ModelSerializer):
    class Meta:
        model = TaggedItem
        fields = ("tag",)

class BlogSerializer(serializers.ModelSerializer):
    copyright = serializers.SerializerMethodField()
    tags = relations.ResourceRelatedField(many=True, read_only=True)

    included_serializers = {
        "tags": "example.serializers.TaggedItemSerializer",
    }

    def get_copyright(self, resource):
        return datetime.now().year

    def get_root_meta(self, resource, many):
        return {"api_docs": "/docs/api/blogs"}

    class Meta:
        model = Blog
        fields = ("name", "url", "tags")
        read_only_fields = ("tags",)
        meta_fields = ("copyright",)

To directly serialize GenericForeignKey DRF docs suggest to create custom related field which overwrites to_representation. This won't help in our case though as included_serializers is a separate DJA feature. As far as I see are the include feature can only be used with GenericRelation but currently not with GenericForeignKey directly. For this to work I assume there needs to be an API change where included serializers is directly configured on ResourceRelatedField which can then be overwritten.

[auvipy]

as far as I can remember, django core devs suggest not to use genericforeignkey

[SafaAlfulaij]

Can you please share the source? It's not the best, I know, but sometimes it's a must...