Merge pull request #44 from FloatingGhost/master

Fix #43: Rescan any fields that have not been converted

Author: abawchen

graphene_mongo/converter.py

@@ -89,7 +89,6 @@ def dynamic_type():
         _type = registry.get_type_for_model(model)
         if not _type:
             return None
-
         return Field(_type)
 
     return Dynamic(dynamic_type)

graphene_mongo/registry.py

@@ -11,6 +11,10 @@ def register(self, cls):
         assert cls._meta.registry == self, 'Registry for a Model have to match.'
         self._registry[cls._meta.model] = cls
 
+        # Rescan all fields
+        for model, cls in self._registry.items():
+            cls.rescan_fields()
+
     def get_type_for_model(self, model):
         return self._registry.get(model)
 

graphene_mongo/tests/models.py

@@ -98,3 +98,25 @@ class ProfessorVector(Document):
     meta = {'collection': 'test_professor_vector'}
     vec = ListField(FloatField())
     metadata = EmbeddedDocumentField(ProfessorMetadata)
+
+
+class ParentWithRelationship(Document):
+
+    meta = {'collection': 'test_parent_reference'}
+    before_child = ListField(ReferenceField("ChildRegisteredBefore"))
+    after_child = ListField(ReferenceField("ChildRegisteredAfter"))
+    name = StringField()
+
+
+class ChildRegisteredBefore(Document):
+
+    meta = {'collection': 'test_child_before_reference'}
+    parent = ReferenceField(ParentWithRelationship)
+    name = StringField()
+
+
+class ChildRegisteredAfter(Document):
+
+    meta = {'collection': 'test_child_after_reference'}
+    parent = ReferenceField(ParentWithRelationship)
+    name = StringField()

graphene_mongo/tests/setup.py

@@ -2,6 +2,8 @@
 from .models import (
     Article, Editor, EmbeddedArticle, Player,
     Reporter, Child, ProfessorMetadata, ProfessorVector,
+    ChildRegisteredBefore, ChildRegisteredAfter,
+    ParentWithRelationship
 )
 
 
@@ -105,3 +107,27 @@ def fixtures():
         metadata=professor_metadata
     )
     professor_vector.save()
+
+    ParentWithRelationship.drop_collection()
+    ChildRegisteredAfter.drop_collection()
+    ChildRegisteredBefore.drop_collection()
+
+    # This is one messed up family
+
+    # She'd better have presence this time
+    child3 = ChildRegisteredBefore(name="Akari")
+    child4 = ChildRegisteredAfter(name="Kyouko")
+    child3.save()
+    child4.save()
+
+    parent = ParentWithRelationship(
+        name="Yui",
+        before_child=[child3],
+        after_child=[child4]
+    )
+
+    parent.save()
+
+    child3.parent = child4.parent = parent
+    child3.save()
+    child4.save()

graphene_mongo/tests/test_relay_query.py

@@ -10,7 +10,8 @@
                     EditorNode,
                     PlayerNode,
                     ReporterNode,
-                    ChildNode,)
+                    ChildNode,
+                    ParentWithRelationshipNode)
 from ..fields import MongoengineConnectionField
 
 
@@ -648,3 +649,69 @@ class Query(graphene.ObjectType):
     assert not result.errors
     assert json.dumps(result.data, sort_keys=True) == json.dumps(
         expected, sort_keys=True)
+
+
+def test_should_lazy_reference(fixtures):
+
+    class Query(graphene.ObjectType):
+        node = Node.Field()
+        parents = MongoengineConnectionField(ParentWithRelationshipNode)
+
+    schema = graphene.Schema(query=Query)
+
+    query = """
+    query {
+        parents {
+            edges {
+                node {
+                    beforeChild {
+                        edges {
+                            node {
+                                name,
+                                parent { name }
+                            }
+                        }
+                    },
+                    afterChild {
+                        edges {
+                            node {
+                                name,
+                                parent { name }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    """
+
+    expected = {
+        "parents": {
+            "edges": [
+                {"node": {
+                    "beforeChild": {
+                        "edges": [
+                            {"node": {
+                                "name": "Akari",
+                                "parent": {"name": "Yui"}
+                            }}
+                        ]
+                    },
+                    "afterChild": {
+                        "edges": [
+                            {"node": {
+                                "name": "Kyouko",
+                                "parent": {"name": "Yui"}
+                            }}
+                        ]
+                    }
+                }}
+            ]
+        }
+    }
+
+    result = schema.execute(query)
+    assert not result.errors
+    assert json.dumps(result.data, sort_keys=True) == json.dumps(
+        expected, sort_keys=True)

graphene_mongo/tests/types.py

@@ -4,6 +4,8 @@
 from .models import (
     Article, Editor, EmbeddedArticle, Player, Reporter,
     Parent, Child, ProfessorMetadata, ProfessorVector,
+    ParentWithRelationship, ChildRegisteredBefore,
+    ChildRegisteredAfter
 )
 
 
@@ -107,3 +109,21 @@ class ChildNode(MongoengineObjectType):
     class Meta:
         model = Child
         interfaces = (Node,)
+
+
+class ChildRegisteredBeforeNode(MongoengineObjectType):
+    class Meta:
+        model = ChildRegisteredBefore
+        interfaces = (Node, )
+
+
+class ParentWithRelationshipNode(MongoengineObjectType):
+    class Meta:
+        model = ParentWithRelationship
+        interfaces = (Node, )
+
+
+class ChildRegisteredAfterNode(MongoengineObjectType):
+    class Meta:
+        model = ChildRegisteredAfter
+        interfaces = (Node, )

graphene_mongo/types.py

@@ -80,7 +80,6 @@ def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=Fa
             model, registry, only_fields, exclude_fields
         )
         mongoengine_fields = yank_fields_from_attrs(converted_fields, _as=Field)
-
         if use_connection is None and interfaces:
             use_connection = any((issubclass(interface, Node) for interface in interfaces))
 
@@ -103,6 +102,9 @@ def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=Fa
         _meta.fields = mongoengine_fields
         _meta.filter_fields = filter_fields
         _meta.connection = connection
+        # Save them for later
+        _meta.only_fields = only_fields
+        _meta.exclude_fields = exclude_fields
 
         super(MongoengineObjectType, cls).__init_subclass_with_meta__(
             _meta=_meta, interfaces=interfaces, **options
@@ -117,6 +119,24 @@ def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=Fa
                 cls._meta.fields.update(mongoengine_fields)
                 registry.register(cls)
 
+    @classmethod
+    def rescan_fields(cls):
+        """Attempts to rescan fields and will insert any not converted initially"""
+
+        converted_fields, self_referenced = construct_fields(
+            cls._meta.model, cls._meta.registry,
+            cls._meta.only_fields, cls._meta.exclude_fields
+        )
+
+        mongoengine_fields = yank_fields_from_attrs(converted_fields, _as=Field)
+
+        # The initial scan should take precidence
+        for field in mongoengine_fields:
+            if field not in cls._meta.fields:
+                cls._meta.fields.update({field: mongoengine_fields[field]})
+        # Self-referenced fields can't change between scans!
+
+
     # noqa
     @classmethod
     def is_type_of(cls, root, info):