INTPYTHON-916 Serialize embedded model references in migrations as strings

Author: timgraham

django_mongodb_backend/fields/embedded_model.py

@@ -1,5 +1,6 @@
 import difflib
 
+from django.apps import apps
 from django.core import checks
 from django.core.exceptions import FieldDoesNotExist, ValidationError
 from django.db import models
@@ -9,6 +10,8 @@
 
 from django_mongodb_backend import forms
 
+from .utils import serialize_model_reference
+
 
 class EmbeddedModelField(models.Field):
     """Field that stores a model instance."""
@@ -58,7 +61,7 @@ def deconstruct(self):
             path = path.replace(
                 "django_mongodb_backend.fields.embedded_model", "django_mongodb_backend.fields"
             )
-        kwargs["embedded_model"] = self.embedded_model
+        kwargs["embedded_model"] = serialize_model_reference(self.embedded_model)
         return name, path, args, kwargs
 
     def get_internal_type(self):
@@ -128,11 +131,18 @@ def get_db_prep_save(self, embedded_instance, connection):
         embedded_instance._state.adding = False
         return field_values
 
+    @cached_property
+    def resolved_embedded_model(self):
+        # Since Field.deconstruct() serializes self.embedded_model as a string,
+        # it may need to be resolved after a Field.clone() in querying.
+        model = self.embedded_model
+        return apps.get_model(model) if isinstance(model, str) else model
+
     def get_transform(self, name):
         transform = super().get_transform(name)
         if transform:
             return transform
-        field = self.embedded_model._meta.get_field(name)
+        field = self.resolved_embedded_model._meta.get_field(name)
         return EmbeddedModelTransformFactory(field)
 
     def validate(self, value, model_instance):

django_mongodb_backend/fields/embedded_model_array.py

@@ -13,6 +13,7 @@
 from django_mongodb_backend.query_utils import process_lhs, process_rhs
 
 from .mixins import NoEncryptedEmbeddedFieldsMixin
+from .utils import serialize_model_reference
 
 
 class EmbeddedModelArrayField(NoEncryptedEmbeddedFieldsMixin, ArrayField):
@@ -37,7 +38,7 @@ def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
         if path == "django_mongodb_backend.fields.embedded_model_array.EmbeddedModelArrayField":
             path = "django_mongodb_backend.fields.EmbeddedModelArrayField"
-        kwargs["embedded_model"] = self.embedded_model
+        kwargs["embedded_model"] = serialize_model_reference(self.embedded_model)
         del kwargs["base_field"]
         return name, path, args, kwargs
 
@@ -70,7 +71,7 @@ def get_transform(self, name):
         transform = super().get_transform(name)
         if transform:
             return transform
-        field = self.base_field.embedded_model._meta.get_field(name)
+        field = self.base_field.resolved_embedded_model._meta.get_field(name)
         return EmbeddedModelArrayFieldTransformFactory(field)
 
     def _get_lookup(self, lookup_name):

django_mongodb_backend/fields/polymorphic_embedded_model.py

@@ -1,12 +1,14 @@
 import contextlib
 
+from django.apps import apps
 from django.core import checks
 from django.core.exceptions import FieldDoesNotExist, ValidationError
 from django.db import models
 from django.db.models.fields.related import lazy_related_operation
+from django.utils.functional import cached_property
 
 from .embedded_model import EmbeddedModelTransformFactory
-from .utils import get_mongodb_connection
+from .utils import get_mongodb_connection, serialize_model_reference
 
 
 class PolymorphicEmbeddedModelField(models.Field):
@@ -80,7 +82,9 @@ def deconstruct(self):
                 "django_mongodb_backend.fields.polymorphic_embedded_model",
                 "django_mongodb_backend.fields",
             )
-        kwargs["embedded_models"] = self.embedded_models
+        kwargs["embedded_models"] = tuple(
+            serialize_model_reference(x) for x in self.embedded_models
+        )
         del kwargs["editable"]
         return name, path, args, kwargs
 
@@ -158,11 +162,21 @@ def get_db_prep_save(self, embedded_instance, connection):
         embedded_instance._state.adding = False
         return field_values
 
+    @cached_property
+    def resolved_embedded_models(self):
+        # Since Field.deconstruct() serializes self.embedded_models as a list
+        # of strings, these strings may need to be resolved after a
+        # Field.clone() in querying.
+        return tuple(
+            apps.get_model(model) if isinstance(model, str) else model
+            for model in self.embedded_models
+        )
+
     def get_transform(self, name):
         transform = super().get_transform(name)
         if transform:
             return transform
-        for model in self.embedded_models:
+        for model in self.resolved_embedded_models:
             with contextlib.suppress(FieldDoesNotExist):
                 field = model._meta.get_field(name)
                 break

django_mongodb_backend/fields/polymorphic_embedded_model_array.py

@@ -11,6 +11,7 @@
     EmbeddedModelArrayFieldTransform,
     EmbeddedModelArrayFieldTransformFactory,
 )
+from .utils import serialize_model_reference
 
 
 class PolymorphicEmbeddedModelArrayField(ArrayField):
@@ -39,7 +40,9 @@ def deconstruct(self):
             "PolymorphicEmbeddedModelArrayField"
         ):
             path = "django_mongodb_backend.fields.PolymorphicEmbeddedModelArrayField"
-        kwargs["embedded_models"] = self.embedded_models
+        kwargs["embedded_models"] = tuple(
+            serialize_model_reference(x) for x in self.embedded_models
+        )
         del kwargs["base_field"]
         del kwargs["editable"]
         return name, path, args, kwargs
@@ -64,7 +67,7 @@ def get_transform(self, name):
         transform = super().get_transform(name)
         if transform:
             return transform
-        for model in self.base_field.embedded_models:
+        for model in self.base_field.resolved_embedded_models:
             with contextlib.suppress(FieldDoesNotExist):
                 field = model._meta.get_field(name)
                 break

django_mongodb_backend/fields/utils.py

@@ -6,3 +6,15 @@ def get_mongodb_connection():
         if connections[alias].vendor == "mongodb":
             return connections[alias]
     return None
+
+
+def serialize_model_reference(model):
+    """Serialize a model to its label for use in migrations."""
+    if isinstance(model, str):
+        # For "app_label.Model", lowercase the model name only.
+        if "." in model:
+            app_label, model_name = model.split(".")
+            return f"{app_label}.{model_name.lower()}"
+        # For "Model", lowercase it.
+        return model.lower()
+    return model._meta.label_lower

docs/releases/6.0.x.rst

@@ -19,6 +19,9 @@ Bug fixes
 - Made model saving raise an exception to prevent a misconfiguration from
   resulting in the creation of models with encrypted fields in non-encrypted
   databases.
+- Made ``makemigrations`` serialize embedded model references as strings so
+  that references in existing migrations don't need to be adjusted if models
+  are later removed.
 
 6.0.2
 =====

tests/model_fields_/test_embedded_model.py

@@ -42,7 +42,17 @@ def test_deconstruct(self):
         self.assertEqual(name, "field_name")
         self.assertEqual(path, "django_mongodb_backend.fields.EmbeddedModelField")
         self.assertEqual(args, [])
-        self.assertEqual(kwargs, {"embedded_model": "Data", "null": True})
+        self.assertEqual(kwargs, {"embedded_model": "data", "null": True})
+
+    def test_deconstruct_model_class(self):
+        field = EmbeddedModelField(Data)
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_model"], "model_fields_.data")
+
+    def test_deconstruct_model_string(self):
+        field = EmbeddedModelField("app_label.Model")
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_model"], "app_label.model")
 
     def test_get_db_prep_save_invalid(self):
         msg = "Expected instance of type <class 'model_fields_.models.Data'>, not <class 'int'>."

tests/model_fields_/test_embedded_model_array.py

@@ -24,7 +24,17 @@ def test_deconstruct(self):
         self.assertEqual(name, "field_name")
         self.assertEqual(path, "django_mongodb_backend.fields.EmbeddedModelArrayField")
         self.assertEqual(args, [])
-        self.assertEqual(kwargs, {"embedded_model": "Data", "null": True})
+        self.assertEqual(kwargs, {"embedded_model": "data", "null": True})
+
+    def test_deconstruct_model_class(self):
+        field = EmbeddedModelArrayField(Movie)
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_model"], "model_fields_.movie")
+
+    def test_deconstruct_model_string(self):
+        field = EmbeddedModelArrayField("app_label.Model")
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_model"], "app_label.model")
 
     def test_size_not_supported(self):
         msg = "EmbeddedModelArrayField does not support size."

tests/model_fields_/test_polymorphic_embedded_model.py

@@ -28,7 +28,17 @@ def test_deconstruct(self):
         self.assertEqual(name, "field_name")
         self.assertEqual(path, "django_mongodb_backend.fields.PolymorphicEmbeddedModelField")
         self.assertEqual(args, [])
-        self.assertEqual(kwargs, {"embedded_models": ["Data"], "null": True})
+        self.assertEqual(kwargs, {"embedded_models": ("data",), "null": True})
+
+    def test_deconstruct_model_class(self):
+        field = PolymorphicEmbeddedModelField([Cat, Dog])
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_models"], ("model_fields_.cat", "model_fields_.dog"))
+
+    def test_deconstruct_model_string(self):
+        field = PolymorphicEmbeddedModelField(["app_label.Model"])
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_models"], ("app_label.model",))
 
     def test_get_db_prep_save_invalid(self):
         msg = (

tests/model_fields_/test_polymorphic_embedded_model_array.py

@@ -23,7 +23,17 @@ def test_deconstruct(self):
         self.assertEqual(name, "field_name")
         self.assertEqual(path, "django_mongodb_backend.fields.PolymorphicEmbeddedModelArrayField")
         self.assertEqual(args, [])
-        self.assertEqual(kwargs, {"embedded_models": ["Dog"], "null": True})
+        self.assertEqual(kwargs, {"embedded_models": ("dog",), "null": True})
+
+    def test_deconstruct_model_class(self):
+        field = PolymorphicEmbeddedModelArrayField([Cat, Dog])
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_models"], ("model_fields_.cat", "model_fields_.dog"))
+
+    def test_deconstruct_model_string(self):
+        field = PolymorphicEmbeddedModelArrayField(["app_label.Model"])
+        *_, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["embedded_models"], ("app_label.model",))
 
     def test_size_not_supported(self):
         msg = "PolymorphicEmbeddedModelArrayField does not support size."