How to implement polymorphic serializer with non-ORM entities?

[SafaAlfulaij]

My use case is that I am using a JSONField database column to store 10s types of data in nested arrays and objects.
Array children should have the same type, but that type can have a field related to different serializers.

Example (very simplified and abstracted):

WardrobeSerializer:

• id: "xxx"
• type: "wordrobe"
• relationships: cloths: ClothSerializer(many=True)

ClothSerializer:

• id: "xxx"
• type: "cloth"
• attributes: clothType: "tShirt" or "pant", designer: "Mr. Designer", etc...
• relationships: details: (polymorphic) TShirtSerializer or PantSerializer

TShirtSerializer:

• id: "xxx"
• type: "tShirt"
• attributes: size: "L", color: "black", etc...

PantSerializer:

• id: "xxx"
• type: "pant"
• attributes: waist: 22, pantType: "slim", etc...

Example of data:

[
    {
        "id": "xxx",
        "clothType": "tShirt",
        "designer": "Mr. Designer",
        "details": {
            "size": "L",
            "color": "black"
        }
    },
    {
        "id": "xxx",
        "clothType": "pant",
        "designer": "Mr. Designer Number 2",
        "details": {
            "waist": 22,
            "pantType": "slim"
        }
    }
]

[jokiefer]

IF the model looks like

class Cloth(models.Model):
    cloth_type = models.JSONField()

Then your serializer could looks like

class ClothSerializer(serilizers.ModelSerializer):
    cloth_type = SerializerMethodField()

    class Meta:
        model = Cloth

    def get_cloth_type(self, obj):
       # handles cloth type serializing

in get_cloth_type your could call the TShirtSerializer or the PantSerializer.
But this is just one example. There are many ways to rome.

[SafaAlfulaij]

My main concern is includes and nested relationships.

[jokiefer]

Hm - ok. Including and nested relationships are done by concrete django models i think. Maybe a maintainer of this project could tell us more about that.

I would recommend you to modelling this on the django db layer like this:

class Cloth(PolymorphicModel):
    designer = models.CharField(max_length=256)

class TShirt(Cloth):
    size = models.CharField(max_length=50, choices=["S", "M", "L", ])
    color = models.CharField(max_length=50, choices=["black", "white"])

class Path(Cloth):
    waist = models.CharField(max_length=50, choices=["22", "23", "24", ])
    pant_type = models.CharField(max_length=50, choices=["slim", "regular"])

Then the only thing you need to do then is to write a Polymorphic serializer.

I don't know anything about your constraints and why you want to use JSONFields instead of modelling concrete models and relations on the database. But in my experience with django in most cases it is better to modelling a concrete model instead of trying to implement generic things and put it in flat database fields. This is cause any site-package you will use is based on the django model concept (also this package too). I think you could save time if you first rethink about your django model layer instead of trying to hardly use site-packages for your solution if this is not really necessary. Your code base would also become more maintainable ;-)

But this is just my opinion :-) feel free to implement a solution which matches your use cases.