Add a Writeable SerializerMethodField to DRF

[HHHMHA]

You know how the front end guys always want the format output in a weird way right?

including a field where we can format the outputs will be great, there are solutions online like this:

class WriteableSerializerMethodField(serializers.Field):
    def __init__(self, write_serializer=None, method_name=None, **kwargs):
        assert write_serializer is not None and isinstance(write_serializer, serializers.Field), 'write_serializer must be a valid serializer field'
        self.write_serializer = write_serializer
        self.method_name = method_name
        super(WriteableSerializerMethodField, self).__init__(**kwargs)

    def bind(self, field_name, parent):
        # In order to enforce a consistent style, we error if a redundant
        # 'method_name' argument has been used. For example:
        # my_field = serializer.CharField(source='my_field')
        default_method_name = 'get_{field_name}'.format(field_name=field_name)
        assert self.method_name != default_method_name, (
            "It is redundant to specify `%s` on SerializerMethodField '%s' in "
            "serializer '%s', because it is the same as the default method name. "
            "Remove the `method_name` argument." %
            (self.method_name, field_name, parent.__class__.__name__)
        )

        # The method name should default to `get_{field_name}`.
        if self.method_name is None:
            self.method_name = default_method_name

        super(WriteableSerializerMethodField, self).bind(field_name, parent)

    def to_internal_value(self, data):
        return self.write_serializer.to_internal_value(data)

    def to_representation(self, value):
        method = getattr(self.parent, self.method_name)
        return method(value)

just wondering if it can be added to DRF.

[auvipy]

can you share the output format/formats please to understand the reasoning behind it?

[HHHMHA]

Let's assume we have a phone field
it will come as input like this: +963XXXXXXXXXX
But front end want the output like this:

    "phone": {
        "prefix": "+963",
        "number": "XXXXXXXXXX",
        "flag": "",
    }

If we have the field above we can use something like this:

phone = WriteableSerializerMethodField(
    write_serializer=serializers.CharField(<params_here>) # Or use the PhoneField whatever
)

def get_phone(self, phone):
    return {
        "prefix": <code_for_prefix>,
        "number": <code_for_number>,
        "flag": <code_for_flag
    }

[auvipy]

i think you can do this in model level as well or them using a model method and make the output in API as well

[HHHMHA]

There are multiple ways to solve this yes, we can in the view for example replace the data["phone"]
but in the serializer like this would be the best

[pktiuk]

This is a great idea. My desired usage for such a ReadWriteSerializerMethodField would look like this:

from django.contrib.auth.models import User
from django.utils.timezone import now
from rest_framework import serializers

class UserSerializer(serializers.ModelSerializer):
    days_since_joined = serializers.ReadWriteSerializerMethodField()

    class Meta:
        model = User
        fields = '__all__'

    def get_days_since_joined(self, obj):
        return (now() - obj.date_joined).days

   def set_days_since_joined(self, instance: User, value: int):
      instance.date_joined = now() - time_in_days(value)

In the setter I can directly interact with instance of my object.

[browniebroke]

While the SerializerMethodField is a quick shortcut for read-only fields, if you need read + write, then I think you're better off writing a separate serializer, handling read and write in a self-contained way.

The OP seems to imply the need for write_serializer anyway, so this would need to be written.

The second example with a getter and setter methods might be a better API, but I can see that becoming very messy as the number of fields grow.

Overall, I'm -1 on this 👎🏻