Added SkipDataMixin, HyperLinkedMixin

Author: Anton-Shutik

rest_framework_json_api/relations.py

@@ -7,8 +7,10 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.urls import NoReverseMatch
 from django.utils.translation import ugettext_lazy as _
-from rest_framework.fields import MISSING_ERROR_MESSAGE
-from rest_framework.relations import MANY_RELATION_KWARGS, PrimaryKeyRelatedField
+from rest_framework.fields import MISSING_ERROR_MESSAGE, SkipField
+from rest_framework.relations import MANY_RELATION_KWARGS
+from rest_framework.relations import ManyRelatedField as DRFManyRelatedField
+from rest_framework.relations import PrimaryKeyRelatedField, RelatedField
 from rest_framework.reverse import reverse
 from rest_framework.serializers import Serializer
 
@@ -29,26 +31,31 @@
 ]
 
 
-class ResourceRelatedField(PrimaryKeyRelatedField):
-    _skip_polymorphic_optimization = True
+class SkipDataMixin(object):
+    """
+    This workaround skips "data" rendering for relationships
+    in order to save some sql queries and improve performance
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(SkipDataMixin, self).__init__(*args, **kwargs)
+
+    def get_attribute(self, instance):
+        raise SkipField
+
+    def to_representation(self, *args):
+        raise NotImplementedError
+
+
+class ManyRelatedFieldWithNoData(SkipDataMixin, DRFManyRelatedField):
+    pass
+
+
+class HyperLinkedMixin(object):
     self_link_view_name = None
     related_link_view_name = None
     related_link_lookup_field = 'pk'
 
-    default_error_messages = {
-        'required': _('This field is required.'),
-        'does_not_exist': _('Invalid pk "{pk_value}" - object does not exist.'),
-        'incorrect_type': _(
-            'Incorrect type. Expected resource identifier object, received {data_type}.'
-        ),
-        'incorrect_relation_type': _(
-            'Incorrect relation type. Expected {relation_type}, received {received_type}.'
-        ),
-        'missing_type': _('Invalid resource identifier object: missing \'type\' attribute'),
-        'missing_id': _('Invalid resource identifier object: missing \'id\' attribute'),
-        'no_match': _('Invalid hyperlink - No URL match.'),
-    }
-
     def __init__(self, self_link_view_name=None, related_link_view_name=None, **kwargs):
         if self_link_view_name is not None:
             self.self_link_view_name = self_link_view_name
@@ -62,34 +69,12 @@ def __init__(self, self_link_view_name=None, related_link_view_name=None, **kwar
             'related_link_url_kwarg', self.related_link_lookup_field
         )
 
-        # check for a model class that was passed in for the relation type
-        model = kwargs.pop('model', None)
-        if model:
-            self.model = model
-
         # We include this simply for dependency injection in tests.
         # We can't add it as a class attributes or it would expect an
         # implicit `self` argument to be passed.
         self.reverse = reverse
 
-        super(ResourceRelatedField, self).__init__(**kwargs)
-
-    def use_pk_only_optimization(self):
-        # We need the real object to determine its type...
-        return self.get_resource_type_from_included_serializer() is not None
-
-    def conflict(self, key, **kwargs):
-        """
-        A helper method that simply raises a validation error.
-        """
-        try:
-            msg = self.error_messages[key]
-        except KeyError:
-            class_name = self.__class__.__name__
-            msg = MISSING_ERROR_MESSAGE.format(class_name=class_name, key=key)
-            raise AssertionError(msg)
-        message_string = msg.format(**kwargs)
-        raise Conflict(message_string)
+        super(HyperLinkedMixin, self).__init__(**kwargs)
 
     def get_url(self, name, view_name, kwargs, request):
         """
@@ -140,6 +125,78 @@ def get_links(self, obj=None, lookup_field='pk'):
             return_data.update({'related': related_link})
         return return_data
 
+
+class HyperLinkedRelatedField(HyperLinkedMixin, SkipDataMixin, RelatedField):
+
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        """
+        This method handles creating a parent `ManyRelatedField` instance
+        when the `many=True` keyword argument is passed.
+
+        Typically you won't need to override this method.
+
+        Note that we're over-cautious in passing most arguments to both parent
+        and child classes in order to try to cover the general case. If you're
+        overriding this method you'll probably want something much simpler, eg:
+
+        @classmethod
+        def many_init(cls, *args, **kwargs):
+            kwargs['child'] = cls()
+            return CustomManyRelatedField(*args, **kwargs)
+        """
+        list_kwargs = {'child_relation': cls(*args, **kwargs)}
+        for key in kwargs:
+            if key in MANY_RELATION_KWARGS:
+                list_kwargs[key] = kwargs[key]
+        return ManyRelatedFieldWithNoData(**list_kwargs)
+
+
+class ResourceRelatedField(HyperLinkedMixin, PrimaryKeyRelatedField):
+    _skip_polymorphic_optimization = True
+    self_link_view_name = None
+    related_link_view_name = None
+    related_link_lookup_field = 'pk'
+
+    default_error_messages = {
+        'required': _('This field is required.'),
+        'does_not_exist': _('Invalid pk "{pk_value}" - object does not exist.'),
+        'incorrect_type': _(
+            'Incorrect type. Expected resource identifier object, received {data_type}.'
+        ),
+        'incorrect_relation_type': _(
+            'Incorrect relation type. Expected {relation_type}, received {received_type}.'
+        ),
+        'missing_type': _('Invalid resource identifier object: missing \'type\' attribute'),
+        'missing_id': _('Invalid resource identifier object: missing \'id\' attribute'),
+        'no_match': _('Invalid hyperlink - No URL match.'),
+    }
+
+    def __init__(self, **kwargs):
+        # check for a model class that was passed in for the relation type
+        model = kwargs.pop('model', None)
+        if model:
+            self.model = model
+
+        super(ResourceRelatedField, self).__init__(**kwargs)
+
+    def use_pk_only_optimization(self):
+        # We need the real object to determine its type...
+        return self.get_resource_type_from_included_serializer() is not None
+
+    def conflict(self, key, **kwargs):
+        """
+        A helper method that simply raises a validation error.
+        """
+        try:
+            msg = self.error_messages[key]
+        except KeyError:
+            class_name = self.__class__.__name__
+            msg = MISSING_ERROR_MESSAGE.format(class_name=class_name, key=key)
+            raise AssertionError(msg)
+        message_string = msg.format(**kwargs)
+        raise Conflict(message_string)
+
     def to_internal_value(self, data):
         if isinstance(data, six.text_type):
             try:
@@ -323,3 +380,7 @@ def to_representation(self, value):
             base = super(SerializerMethodResourceRelatedField, self)
             return [base.to_representation(x) for x in value]
         return super(SerializerMethodResourceRelatedField, self).to_representation(value)
+
+
+class SerializerMethodHyperLinkedRelatedField(SkipDataMixin, SerializerMethodResourceRelatedField):
+    pass

rest_framework_json_api/renderers.py

@@ -2,7 +2,7 @@
 Renderers
 """
 import copy
-from collections import OrderedDict, defaultdict
+from collections import Iterable, OrderedDict, defaultdict
 
 import inflection
 from django.db.models import Manager
@@ -13,7 +13,7 @@
 
 import rest_framework_json_api
 from rest_framework_json_api import utils
-from rest_framework_json_api.relations import ResourceRelatedField
+from rest_framework_json_api.relations import HyperLinkedMixin, ResourceRelatedField, SkipDataMixin
 
 
 class JSONRenderer(renderers.JSONRenderer):
@@ -126,25 +126,23 @@ def extract_relationships(cls, fields, resource, resource_instance):
                 }})
                 continue
 
-            if isinstance(field, ResourceRelatedField):
+            relation_data = {}
+            if isinstance(field, HyperLinkedMixin):
+                field_links = field.get_links(resource_instance, field.related_link_lookup_field)
+                relation_data.update({'links': field_links} if field_links else dict())
+                data.update({field_name: relation_data})
+
+            if isinstance(field, (ResourceRelatedField, )):
                 relation_instance_id = getattr(resource_instance, source + "_id", None)
                 if not relation_instance_id:
                     resolved, relation_instance = utils.get_relation_instance(resource_instance,
                                                                               source, field.parent)
                     if not resolved:
                         continue
 
-                # special case for ResourceRelatedField
-                relation_data = {
-                    'data': resource.get(field_name)
-                }
+                if not isinstance(field, SkipDataMixin):
+                    relation_data.update({'data': resource.get(field_name)})
 
-                field_links = field.get_links(
-                    resource_instance, field.related_link_lookup_field)
-                relation_data.update(
-                    {'links': field_links}
-                    if field_links else dict()
-                )
                 data.update({field_name: relation_data})
                 continue
 
@@ -186,12 +184,22 @@ def extract_relationships(cls, fields, resource, resource_instance):
                 if not resolved:
                     continue
 
+                relation_data = {}
+
+                if isinstance(resource.get(field_name), Iterable):
+                    relation_data.update(
+                        {
+                            'meta': {'count': len(resource.get(field_name))}
+                        }
+                    )
+
                 if isinstance(field.child_relation, ResourceRelatedField):
                     # special case for ResourceRelatedField
-                    relation_data = {
-                        'data': resource.get(field_name)
-                    }
+                    relation_data.update(
+                        {'data': resource.get(field_name)}
+                    )
 
+                if isinstance(field.child_relation, HyperLinkedMixin):
                     field_links = field.child_relation.get_links(
                         resource_instance,
                         field.child_relation.related_link_lookup_field
@@ -200,13 +208,7 @@ def extract_relationships(cls, fields, resource, resource_instance):
                         {'links': field_links}
                         if field_links else dict()
                     )
-                    relation_data.update(
-                        {
-                            'meta': {
-                                'count': len(resource.get(field_name))
-                            }
-                        }
-                    )
+
                     data.update({field_name: relation_data})
                     continue