Better NdbKeyStringField implementation

Author: ekampf

graphene_gae/ndb/converter.py

@@ -90,7 +90,7 @@ def convert_ndb_key_propety(ndb_key_prop, meta):
         string_prop_name = singular_name + '_ids' if ndb_key_prop._repeated else singular_name + '_id'
         resolved_prop_name = name
 
-    string_field = NdbKeyStringField(name)
+    string_field = NdbKeyStringField(name, ndb_key_prop._kind)
     resolved_field = NdbKeyField(name, ndb_key_prop._kind)
 
     if ndb_key_prop._repeated:

graphene_gae/ndb/fields.py

@@ -91,54 +91,56 @@ def model(self):
 
 
 class NdbKeyStringField(String):
-    def __init__(self, name, *args, **kwargs):
+    def __init__(self, name, kind, *args, **kwargs):
         self.name = name
+        self.kind = kind
 
         if 'resolver' not in kwargs:
             kwargs['resolver'] = self.default_resolver
 
         super(NdbKeyStringField, self).__init__(*args, **kwargs)
 
-    def default_resolver(self, node, args, info):
-        entity = node.instance
-        key = getattr(entity, self.name)
-        if not key:
-            return None
-
-        if isinstance(key, list):
-            t = self.__get_key_internal_type(key[0], info.schema.graphene_schema)
-            return [to_global_id(t.name, k.urlsafe()) for k in key]
-
-        t = self.__get_key_internal_type(key, info.schema.graphene_schema)
-        return to_global_id(t.name, key.urlsafe()) if key else None
-
-    def __get_key_internal_type(self, key, schema):
-        _type = self.__find_key_object_type(key, schema)
+    def internal_type(self, schema):
+        _type = self.get_object_type(schema)
         if not _type and self.parent._meta.only_fields:
             raise Exception(
                 "Model %r is not accessible by the schema. "
                 "You can either register the type manually "
                 "using @schema.register. "
                 "Or disable the field in %s" % (
-                    key.kind(),
+                    self.kind,
                     self.parent,
                 )
             )
 
         if not _type:
             raise SkipField()
 
-        return schema.T(_type)
+        from graphql import GraphQLString
+        return GraphQLString
 
-    def __find_key_object_type(self, key, schema):
+    def get_object_type(self, schema):
         for _type in schema.types.values():
             type_model = hasattr(_type, '_meta') and getattr(_type._meta, 'model', None)
             if not type_model:
                 continue
 
-            if key.kind() == type_model or key.kind() == type_model.__name__:
+            if self.kind == type_model or self.kind == type_model.__name__:
                 return _type
 
+    def default_resolver(self, node, args, info):
+        entity = node.instance
+        key = getattr(entity, self.name)
+        if not key:
+            return None
+
+        if isinstance(key, list):
+            t = self.get_object_type(info.schema.graphene_schema)._meta.type_name
+            return [to_global_id(t, k.urlsafe()) for k in key]
+
+        t = self.get_object_type(info.schema.graphene_schema)._meta.type_name
+        return to_global_id(t, key.urlsafe()) if key else None
+
 
 class NdbKeyField(FieldType):
     def __init__(self, name, kind, *args, **kwargs):

tests/_ndb/test_types.py

@@ -1,3 +1,4 @@
+from graphene_gae.ndb.fields import NdbKeyStringField
 from graphql_relay import to_global_id
 from tests.base_test import BaseTest
 
@@ -104,6 +105,27 @@ def resolve_articles(self):
 
         self.assertIn("Model 'bar' is not accessible by the schema.", str(context.exception.message))
 
+    def testNdbObjectType_keyProperty_stringRepresentation_kindDoesntExist_raisesException(self):
+        with self.assertRaises(Exception) as context:
+            class ArticleType(NdbObjectType):
+                class Meta:
+                    model = Article
+                    only_fields = ('prop',)
+
+                prop = NdbKeyStringField('foo', 'bar')
+
+            class QueryType(graphene.ObjectType):
+                articles = graphene.List(ArticleType)
+
+                @graphene.resolve_only_args
+                def resolve_articles(self):
+                    return Article.query()
+
+            schema = graphene.Schema(query=QueryType)
+            result = schema.execute('query test {  articles { prop } }')
+
+        self.assertIn("Model 'bar' is not accessible by the schema.", str(context.exception.message))
+
     def testQuery_excludedField(self):
         Article(headline="h1", summary="s1").put()