more elegant handling of reverse relations (so the data remains available for filtering)

Author: claytondaley

drf_writable_nested/mixins.py

@@ -516,17 +516,22 @@ def _make_reverse_relations_valid(self):
                         # found the matching field, move on
                         break
 
+    @property
+    def validated_data(self):
+        """If mixed into a standard Serializer, prevents `save` from accessing reverse relations"""
+        return {k: v for k, v in super(RelatedSaveMixin, self).validated_data.items()
+                if self.field_types[k] != self.TYPE_REVERSE}
+
     def save(self, **kwargs):
         """We already converted the inputs into a model so we need to save that model"""
+        # prevent recursion when we save a reverse (which tries to save self as a direct)
         if self._is_saved:
-            # prevent recursion when we save a reverse (which tries to save self as a direct)
             return
         # Create or update direct relations (foreign key, one-to-one)
-        reverse_relations = self._extract_reverse_relations(kwargs)
         self._save_direct_relations(kwargs)
         instance = super(RelatedSaveMixin, self).save(**kwargs)
         self._is_saved = True
-        self._save_reverse_relations(reverse_relations, instance=instance)
+        self._save_reverse_relations(instance=instance, kwargs=kwargs)
         return instance
 
     def _save_direct_relations(self, kwargs):
@@ -560,21 +565,23 @@ def _extract_reverse_relations(self, kwargs):
                 ))
         return related_objects
 
-    def _save_reverse_relations(self, related_objects, instance):
+    def _save_reverse_relations(self, instance, kwargs):
         """Inject the current object as the FK in the reverse related objects and save them"""
-        for field, data, kwargs in related_objects:
-            # inject the PK from the instance
+        for field_name, field in self.fields.items():
+            if self.field_types[field_name] != self.TYPE_REVERSE:
+                continue
+            # inject the instance into validated_data so the *_id field is valid when saved
             related_field = self._get_model_field(field.source).field
             if isinstance(field, serializers.ListSerializer):
-                for obj in data:
+                for obj in self._validated_data[field_name]:
                     obj[related_field.name] = instance
             elif isinstance(field, serializers.ModelSerializer):
-                data[related_field.name] = instance
+                self._validated_data[field_name][related_field.name] = instance
             else:
                 raise Exception("unexpected serializer type")
 
-            # reinject validated_data
-            field._validated_data = data
+            # (re)inject validated_data to field
+            field._validated_data = self._validated_data.get(field_name)
             field.save(**kwargs)
 
 
@@ -588,18 +595,18 @@ def save(self, **kwargs):
         create_values = {}
         for field_name, field in self.fields.items():
             if self.match_on == '__all__' or field_name in self.match_on:
-                # add to match_on dict
+                # build match_on dict
                 match_on[field.source or field_name] = kwargs.get(field_name, self._validated_data.get(field_name))
             if isinstance(field, ManyRelatedField):
                 # we can't provide m2m values as kwargs; must use set() instead
                 m2m_relations[field_name] = kwargs.get(field_name, self._validated_data.get(field_name))
             elif self.field_types[field_name] == self.TYPE_LOCAL:
-                # need to check kwargs since there's no pre-processing
+                # need to check kwargs dict since there's no pre-processing
                 create_values[field_name] = kwargs.get(field_name, self._validated_data.get(field_name))
             elif self.field_types[field_name] == self.TYPE_DIRECT:
-                # kwargs should have been injected when direct relations were saved
+                # kwargs should have been injected into _validated_data when direct relations were saved
                 create_values[field_name] = self._validated_data.get(field_name)
-            # make reverse relations aren't sent to a create
+            # reverse relations aren't sent to a create
         # a parent serializer may inject a value that isn't among the fields, but is in `match_on`
         for key in self.match_on:
             if key not in self.fields.keys():