Netbox plugin, extend existing serializer

[kemeris2000]

I am trying to create my first plugin to manage SSH public keys.
My SSHList model has ManyToManyField relation to VirtualMachine model. How to extent VirtualMachine serializer to list assigned SSHList's via API /api/virtualization/virtual-machines?

models.py

class SSHList(models.Model):
    tenant = models.ForeignKey(
        Tenant,
        on_delete=models.CASCADE,
        related_name='ssh_lists'
    )

    name = models.CharField(
        max_length=255
    )

    description = models.CharField(
        max_length=255,
        blank=True,
        null=True
    )

    created = models.DateTimeField(
        auto_now_add=True
    )

    last_updated = models.DateTimeField(
        auto_now=True
    )

    ssh_keys = models.ManyToManyField(
        SSHKey,
        related_name='assigned_to_lists',
        blank=True
    )

    virtual_machines = models.ManyToManyField(
        VirtualMachine,
        related_name='ssh_lists',
        blank=True
    )

    devices = models.ManyToManyField(
        Device,
        related_name='ssh_lists',
        blank=True
    )

    tags = TaggableManager()

    objects = RestrictedQuerySet.as_manager()

    class Meta:
        verbose_name = "SSH Lists"
        verbose_name_plural = "SSH Lists"

    def get_absolute_url(self):
        return reverse("plugins:netbox_ssh_keys:sshlist_detail", args=[self.pk])

    def __str__(self):
        return f"SSH Lists - {self.name}"

/api/serializers.py

class SSHListSerializer(NetBoxModelSerializer):
    url = serializers.HyperlinkedIdentityField(
        view_name = "plugins-api:netbox_ssh_keys-api:sshlist-detail"
    )

    name = serializers.CharField(allow_null=True, required=True) 

    ssh_keys = serializers.PrimaryKeyRelatedField(
        queryset=models.SSHKey.objects.all(),
        many=True,
        required=False
    )

    virtual_machines = serializers.NestedRegionSerializer(
        queryset=models.VirtualMachine.objects.all(),
        many=True,
        required=False
    )

    class Meta:
        model = models.SSHList
        fields = tuple(field.name for field in models.SSHList._meta.fields) + ('url',) + ('ssh_keys',) + ('virtual_machines',)

    def validate(self, attrs):
        if 'ssh_keys' in attrs:
            if attrs['ssh_keys'] in [None, '', '']:
                attrs['ssh_keys'] = []
        return attrs

    def to_internal_value(self, data):
        if self.instance and "name" in data and data["name"] in ["null", "", None]:
            data.pop("name")

        if 'ssh_keys' in data:
            ssh_keys = data['ssh_keys']
            if ssh_keys in [None, '', '']:
                data.pop("ssh_keys")

        return super().to_internal_value(data)

    def update(self, instance, validated_data):
        if 'ssh_keys' in validated_data and validated_data['ssh_keys']:
            instance.ssh_keys.set(validated_data['ssh_keys'])
        return super().update(instance, validated_data)

    def to_representation(self, instance):
        data = super().to_representation(instance)
        request = self.context.get('request')  # Ensure request context is passed

        data['ssh_keys'] = SSHKeySerializer(
            instance.ssh_keys.all(), many=True, context={'request': request}
        ).data

        data['virtual_machines'] = VirtualMachineSerializer(
            instance.virtual_machines.all(), many=True, context={'request': request}
        ).data

        return data

Netbox v4.2.4

[pheus]

I might be wrong, but I don't think you can extend NetBox's core API serializers. The only approach that comes to mind is subclassing the VirtualMachineSerializer in your plugin and providing an alternative API endpoint with the extended functionality.
However, I haven't tested this myself. Maybe someone else has a better idea?

[kemeris2000]

Thank you for your reply @pheus. I haven't found a solution for it, so I decided to abandon this project.